Как тестировать асинхронный код в .NET?

// Правильно
[Fact]
public async Task Returns_order_by_id()
{
    var repo = Substitute.For<IOrderRepository>();
    repo.GetAsync(42, Arg.Any<CancellationToken>()).Returns(new Order(42));   // NSubstitute оборачивает в Task
    var sut = new OrderService(repo);

    var order = await sut.GetAsync(42, CancellationToken.None);

    order!.Id.Should().Be(42);
}

// Неправильно: async void — фреймворк не узнает о падении после await
[Fact]
public async void Bad_test() { await Task.Delay(1); throw new Exception(); }   // xUnit сейчас выдаёт ошибку анализатора

// Неправильно: блокировка
[Fact]
public void Blocking_test() => sut.GetAsync(42, default).Result.Should().NotBeNull();   // риск deadlock, AggregateException

[Fact]
public async Task Throws_when_order_not_found()
{
    var sut = new OrderService(Substitute.For<IOrderRepository>());   // вернёт null по умолчанию

    var act = () => sut.PayAsync(99, default);

    await act.Should().ThrowAsync<NotFoundException>().WithMessage("*99*");
    // или: await Assert.ThrowsAsync<NotFoundException>(() => sut.PayAsync(99, default));
}

public sealed class ReservationService(IReservationStore store, TimeProvider clock)
{
    public async Task<Reservation> ReserveAsync(Guid productId, CancellationToken ct)
    {
        var r = new Reservation(productId, expiresAt: clock.GetUtcNow().AddMinutes(15));
        await store.SaveAsync(r, ct);
        return r;
    }

    public async Task WaitAndReleaseAsync(Reservation r, CancellationToken ct)
    {
        await Task.Delay(r.ExpiresAt - clock.GetUtcNow(), clock, ct);   // перегрузка Task.Delay с TimeProvider (.NET 8)
        await store.ReleaseAsync(r.Id, ct);
    }
}

[Fact]
public async Task Reservation_is_released_after_15_minutes()
{
    var clock = new FakeTimeProvider(DateTimeOffset.Parse("2025-09-30T10:00:00Z"));
    var store = new InMemoryReservationStore();
    var sut = new ReservationService(store, clock);
    var reservation = await sut.ReserveAsync(Guid.NewGuid(), default);

    var waiting = sut.WaitAndReleaseAsync(reservation, default);    // не await — задача «спит»

    clock.Advance(TimeSpan.FromMinutes(14));
    waiting.IsCompleted.Should().BeFalse();                        // ещё рано

    clock.Advance(TimeSpan.FromMinutes(1));                        // таймер срабатывает мгновенно
    await waiting;
    store.IsReleased(reservation.Id).Should().BeTrue();
}

[Fact]
public async Task Stops_processing_when_cancelled()
{
    using var cts = new CancellationTokenSource();
    var processor = new BatchProcessor(new SlowFakeSource(itemCount: 1000));

    var run = processor.RunAsync(cts.Token);
    await cts.CancelAsync();

    await FluentActions.Awaiting(() => run).Should().ThrowAsync<OperationCanceledException>();
    processor.ProcessedCount.Should().BeLessThan(1000);
}

public static async Task WaitUntilAsync(Func<bool> condition, TimeSpan? timeout = null)
{
    var deadline = DateTime.UtcNow + (timeout ?? TimeSpan.FromSeconds(10));
    while (!condition())
    {
        if (DateTime.UtcNow > deadline) throw new TimeoutException("Условие не выполнилось вовремя");
        await Task.Delay(20);
    }
}

[Fact]
public async Task Worker_processes_queued_message()
{
    var channel = Channel.CreateUnbounded<Job>();
    var handled = new ConcurrentBag<Guid>();
    var worker = new JobWorker(channel.Reader, job => { handled.Add(job.Id); return Task.CompletedTask; });
    using var cts = new CancellationTokenSource();
    await worker.StartAsync(cts.Token);

    var job = new Job(Guid.NewGuid());
    await channel.Writer.WriteAsync(job);

    await WaitUntilAsync(() => handled.Contains(job.Id));
    await worker.StopAsync(default);
}

var processed = new TaskCompletionSource<Guid>(TaskCreationOptions.RunContinuationsAsynchronously);
var worker = new JobWorker(channel.Reader, job => { processed.TrySetResult(job.Id); return Task.CompletedTask; });
// ...
(await processed.Task.WaitAsync(TimeSpan.FromSeconds(5))).Should().Be(job.Id);

[Fact]
public async Task Counter_is_thread_safe()
{
    var counter = new RequestCounter();
    await Parallel.ForEachAsync(Enumerable.Range(0, 10_000), async (_, ct) =>
    {
        counter.Increment();
        await Task.Yield();
    });
    counter.Value.Should().Be(10_000);
}