accordant-concurrency

Concurrency Testing in Accordant

Accordant can test concurrent operations to find race conditions. It runs operations simultaneously and validates that results are linearizable — explainable by some sequential ordering.

The Problem: Race Conditions

Consider a booking system where each slot can only be booked once:

Slot "9am" is available.

Concurrent requests:
  - Alice: BookSlot("9am")
  - Bob: BookSlot("9am")

Valid outcomes (one must fail):
  ✓ Alice succeeds, Bob gets Conflict
  ✓ Bob succeeds, Alice gets Conflict

Invalid outcome (BUG!):
  ✗ Both succeed — double booking!

Linearizability

The correctness criterion for concurrent operations:

Results must be explainable by some sequential ordering of the operations.

If Alice got 200 and Bob got 409 → Valid (as if Alice went first)
If both got 200 → Invalid (no sequential order explains this)

Defining the Spec

[State]
public partial class BookingState
{
    public Dictionary<string, string?> Slots { get; set; } = new();  // null = available
}

var spec = new Spec<BookingState>();

spec.Operation<string, ApiResult<Slot>>("CreateSlot", (slotId, state) =>
{
    if (state.Slots.ContainsKey(slotId))
        return Expect.That<ApiResult<Slot>>(r => r.IsConflict).SameState();

    return Expect.That<ApiResult<Slot>>(r => r.IsSuccess && r.Data.IsAvailable)
           .ThenState<BookingState>(s => s.Slots[slotId] = null);
});

spec.Operation<(string SlotId, string Customer), ApiResult<Slot>>("BookSlot", (request, state) =>
{
    var (slotId, customer) = request;

    if (!state.Slots.TryGetValue(slotId, out var bookedBy))
        return Expect.That<ApiResult<Slot>>(r => r.IsNotFound).SameState();

    if (bookedBy != null)
        return Expect.That<ApiResult<Slot>>(r => r.IsConflict, $"Already booked by {bookedBy}").SameState();

    return Expect.That<ApiResult<Slot>>(r => r.IsSuccess && r.Data.BookedBy == customer)
           .ThenState<BookingState>(s => s.Slots[slotId] = customer);
});