Test an API endpoint that calls a slow pricing service and must stop when the request is cancelled.

Replace the pricing service handler with a test double that waits indefinitely until its cancellation token fires. Start the API request with a cancellable token, cancel it, and assert the downstream handler observed cancellation. No real network dependency is allowed.

The client aborts the request while pricing is pending. The fake handler records cancellation and no order is persisted.

• Use a controllable fake, not Task.Delay timing guesses.
• Pass cancellation through every async boundary.
• Assert side effects did not happen.
• Keep timeout tests separate from caller-cancellation tests.

I make the fake handler signal when it starts, then wait on its token. This removes timing races from the test. After cancellation I assert both propagation and absence of downstream business side effects.

[Fact]
public async Task Cancelled_request_cancels_pricing_call()
{
    var handler = new BlockingPricingHandler();
    await using var factory = new ApiTestFactory(services =>
        services.AddHttpClient<IPricingClient, PricingClient>()
            .ConfigurePrimaryHttpMessageHandler(() => handler));

    var client = factory.CreateAuthenticatedClient("buyer-1", "quotes.create");
    using var cancellation = new CancellationTokenSource();

    var request = client.PostAsJsonAsync(
        "/api/quotes",
        new { ProductId = "p-1" },
        cancellation.Token);

    await handler.Started;
    cancellation.Cancel();

    await Assert.ThrowsAnyAsync<OperationCanceledException>(() => request);
    Assert.True(handler.CancellationObserved);
    Assert.Equal(0, await factory.CountQuotesAsync());
}

The test exercises the real HTTP pipeline but replaces the external service and persistence with isolated dependencies. It proves cancellation wiring without sleeping or relying on a real timeout duration.

• Cancellation happens before the downstream call starts.
• The downstream handler ignores cancellation.
• A side effect occurs before pricing completes.
• A configured timeout fires instead of caller cancellation.

• Use synchronization signals rather than fixed delays.
• Assert no persistence or message publication occurred.
• Test timeout mapping separately as a predictable API response.

• Using a real slow service.
• Waiting arbitrary seconds in the test.
• Accepting cancellation at the controller but dropping the token downstream.
• Assuming cancellation rolls back earlier side effects.