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

• 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.