Testing Time and Background Work

using Microsoft.Extensions.Time.Testing;
using Xunit;

public sealed class InvoiceDueDates(TimeProvider time)
{
    private static readonly TimeSpan CutOff = new(17, 0, 0);

    // Invoices issued after 17:00 local time count as issued the next business day; due 14 days later.
    public DateOnly DueDateForInvoiceIssuedNow()
    {
        var local = time.GetLocalNow();
        var issued = DateOnly.FromDateTime(local.DateTime);
        if (local.TimeOfDay >= CutOff) issued = issued.AddDays(1);
        while (issued.DayOfWeek is DayOfWeek.Saturday or DayOfWeek.Sunday) issued = issued.AddDays(1);
        return issued.AddDays(14);
    }
}

public sealed class InvoiceDueDateTests
{
    private static readonly TimeZoneInfo Sydney = TimeZoneInfo.FindSystemTimeZoneById("Australia/Sydney");

    [Theory]
    [InlineData("2026-03-05T05:59:00Z", "2026-03-19")]   // 16:59 Thursday in Sydney
    [InlineData("2026-03-05T06:00:00Z", "2026-03-20")]   // 17:00 Thursday: counts as Friday
    [InlineData("2026-03-06T06:30:00Z", "2026-03-23")]   // 17:30 Friday: rolls past the weekend to Monday
    public void Cut_off_is_17_00_Sydney_time(string utcNow, string expectedDue)
    {
        var clock = new FakeTimeProvider(DateTimeOffset.Parse(utcNow, System.Globalization.CultureInfo.InvariantCulture));
        clock.SetLocalTimeZone(Sydney);

        var due = new InvoiceDueDates(clock).DueDateForInvoiceIssuedNow();

        Assert.Equal(DateOnly.Parse(expectedDue, System.Globalization.CultureInfo.InvariantCulture), due);
    }

    [Fact]
    public void Advancing_the_clock_moves_local_time_too()
    {
        var clock = new FakeTimeProvider(new DateTimeOffset(2026, 3, 5, 5, 0, 0, TimeSpan.Zero));
        clock.SetLocalTimeZone(Sydney);
        var dueDates = new InvoiceDueDates(clock);
        var before = dueDates.DueDateForInvoiceIssuedNow();

        clock.Advance(TimeSpan.FromHours(1));

        Assert.Equal(before.AddDays(1), dueDates.DueDateForInvoiceIssuedNow());
    }
}

using Microsoft.Extensions.Time.Testing;
using Xunit;

public sealed class PaymentCapture(IPaymentApi api, TimeProvider time)
{
    private static readonly TimeSpan[] Backoff = [TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(30)];

    public async Task<bool> CaptureAsync(string paymentId, CancellationToken ct)
    {
        for (var attempt = 0; ; attempt++)
        {
            if (await api.TryCaptureAsync(paymentId, ct)) return true;
            if (attempt == Backoff.Length) return false;
            await Task.Delay(Backoff[attempt], time, ct);   // the provider overload, so tests control the wait
        }
    }
}

public interface IPaymentApi { Task<bool> TryCaptureAsync(string paymentId, CancellationToken ct); }

public sealed class PaymentCaptureTests
{
    private sealed class FailsTimes(int failures) : IPaymentApi
    {
        public int Calls;
        public Task<bool> TryCaptureAsync(string paymentId, CancellationToken ct) =>
            Task.FromResult(Interlocked.Increment(ref Calls) > failures);
    }

    [Fact]
    public async Task Gives_up_after_three_retries_spread_over_42_seconds()
    {
        var clock = new FakeTimeProvider(new DateTimeOffset(2026, 3, 2, 9, 0, 0, TimeSpan.Zero));
        var api = new FailsTimes(failures: 10);
        var capture = new PaymentCapture(api, clock).CaptureAsync("pay_8Kd2", TestContext.Current.CancellationToken);

        // Advance one second at a time until the operation finishes; no real waiting happens.
        while (!capture.IsCompleted && clock.GetUtcNow() < new DateTimeOffset(2026, 3, 2, 9, 5, 0, TimeSpan.Zero))
        {
            clock.Advance(TimeSpan.FromSeconds(1));
            await Task.Yield();
        }

        Assert.False(await capture);
        Assert.Equal(4, api.Calls);
        Assert.True(clock.GetUtcNow() >= new DateTimeOffset(2026, 3, 2, 9, 0, 42, TimeSpan.Zero));
    }
}

using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Time.Testing;
using Xunit;

public interface IOutboxBatch { Task<int> PublishPendingAsync(CancellationToken ct); }

public sealed class OutboxPublisher(IOutboxBatch batch, TimeProvider time, ILogger<OutboxPublisher> logger) : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        using var timer = new PeriodicTimer(TimeSpan.FromSeconds(10), time);
        while (await timer.WaitForNextTickAsync(stoppingToken))
        {
            try
            {
                await batch.PublishPendingAsync(stoppingToken);
            }
            catch (Exception ex) when (IsTransient(ex) && !stoppingToken.IsCancellationRequested)
            {
                // A client timeout (TaskCanceledException) the stopping token did not cause is transient too.
                // Anything else, such as rejected broker credentials, escapes and stops the host.
                logger.LogWarning(ex, "Outbox batch failed; retrying on the next tick");
            }
        }
    }

    private static bool IsTransient(Exception ex) =>
        ex is TimeoutException or HttpRequestException or OperationCanceledException;
}

public sealed class OutboxPublisherTests
{
    private sealed class FlakyBatch : IOutboxBatch
    {
        public int Calls;
        public Task<int> PublishPendingAsync(CancellationToken ct) => Interlocked.Increment(ref Calls) switch
        {
            1 => throw new TimeoutException("broker did not confirm"),
            2 => throw new TaskCanceledException("HttpClient.Timeout of 100 seconds elapsed"),
            _ => Task.FromResult(3),
        };
    }

    [Fact]
    public async Task Keeps_publishing_after_a_failed_batch()
    {
        var ct = TestContext.Current.CancellationToken;
        var clock = new FakeTimeProvider();
        var batch = new FlakyBatch();
        using var publisher = new OutboxPublisher(batch, clock, NullLogger<OutboxPublisher>.Instance);
        await publisher.StartAsync(ct);

        var deadline = DateTime.UtcNow.AddSeconds(5);
        while (Volatile.Read(ref batch.Calls) < 3 && DateTime.UtcNow < deadline)
        {
            clock.Advance(TimeSpan.FromSeconds(10));
            await Task.Delay(10, ct);
        }

        Assert.True(batch.Calls >= 3, $"expected a third batch, saw {batch.Calls}");
        Assert.False(publisher.ExecuteTask!.IsFaulted);
        await publisher.StopAsync(ct);
    }

    private sealed class RejectedCredentials : IOutboxBatch
    {
        public Task<int> PublishPendingAsync(CancellationToken ct) =>
            throw new UnauthorizedAccessException("broker rejected the credentials");
    }

    [Fact]
    public async Task Rejected_credentials_end_the_loop()
    {
        var clock = new FakeTimeProvider();
        using var publisher = new OutboxPublisher(new RejectedCredentials(), clock, NullLogger<OutboxPublisher>.Instance);
        await publisher.StartAsync(TestContext.Current.CancellationToken);

        var deadline = DateTime.UtcNow.AddSeconds(5);
        while (!publisher.ExecuteTask!.IsCompleted && DateTime.UtcNow < deadline)
        {
            clock.Advance(TimeSpan.FromSeconds(10));
            await Task.Delay(10, TestContext.Current.CancellationToken);
        }

        Assert.True(publisher.ExecuteTask.IsFaulted);   // under StopHost this stops the host and alerts fire
    }
}