Overriding Services and Configuration in Tests

using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc.Testing;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Microsoft.Extensions.Time.Testing;

public sealed class ShopApiFactory : WebApplicationFactory<Program>
{
    public FakeTimeProvider Clock { get; } = new(new DateTimeOffset(2026, 3, 2, 9, 0, 0, TimeSpan.Zero));
    public RecordingGateway Payments { get; } = new();

    protected override void ConfigureWebHost(IWebHostBuilder builder)
    {
        builder.UseEnvironment("Testing");
        builder.UseSetting("Payments:WebhookSecret", "test-only-secret");
        builder.UseSetting("FeatureFlags:SplitShipments", "true");

        builder.ConfigureTestServices(services =>
        {
            services.RemoveAll<TimeProvider>();
            services.AddSingleton<TimeProvider>(Clock);

            services.RemoveAll<IPaymentGateway>();
            services.AddSingleton<IPaymentGateway>(Payments);

            // Single, not SingleOrDefault: if the API changes how it registers the dispatcher,
            // the suite fails here instead of quietly publishing to the real broker.
            var poller = services.Single(d => d.ServiceType == typeof(IHostedService)
                                              && d.ImplementationType == typeof(OutboxDispatcher));
            services.Remove(poller);
        });
    }
}

public interface IPaymentGateway { Task<string> ChargeAsync(string orderRef, decimal amount, CancellationToken ct); }

public sealed class RecordingGateway : IPaymentGateway
{
    private readonly List<(string OrderRef, decimal Amount)> _charges = [];
    public IReadOnlyList<(string OrderRef, decimal Amount)> Charges { get { lock (_charges) return [.. _charges]; } }

    public Task<string> ChargeAsync(string orderRef, decimal amount, CancellationToken ct)
    {
        lock (_charges) _charges.Add((orderRef, amount));
        return Task.FromResult("ch_test_" + Guid.NewGuid().ToString("N")[..8]);
    }
}

public sealed class OutboxDispatcher : BackgroundService
{
    protected override Task ExecuteAsync(CancellationToken stoppingToken) => Task.CompletedTask;
}

// Stand-in so this file compiles on its own. Delete it in a real test project: in .NET 10 the API's
// generated Program is already public, and a Program declared here would shadow it (CS0436).
public partial class Program;

using Microsoft.AspNetCore.Mvc.Testing;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Data.Sqlite;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Xunit;

public sealed class SqliteApiFactory : WebApplicationFactory<Program>, IAsyncLifetime
{
    // An in-memory SQLite database lives only while one connection to it stays open.
    private readonly SqliteConnection _connection = new("Data Source=:memory:");

    protected override void ConfigureWebHost(Microsoft.AspNetCore.Hosting.IWebHostBuilder builder) =>
        builder.ConfigureTestServices(services =>
        {
            services.RemoveAll<DbContextOptions<OrdersDb>>();
            services.RemoveAll<IDbContextOptionsConfiguration<OrdersDb>>();   // the app's UseNpgsql lambda
            services.AddDbContext<OrdersDb>(options => options.UseSqlite(_connection));
        });

    public async ValueTask InitializeAsync()
    {
        await _connection.OpenAsync();
        using var scope = Services.CreateScope();
        await scope.ServiceProvider.GetRequiredService<OrdersDb>().Database.EnsureCreatedAsync();
    }

    public override async ValueTask DisposeAsync()
    {
        await base.DisposeAsync();
        await _connection.DisposeAsync();
    }
}

public sealed class OrdersDb(DbContextOptions<OrdersDb> options) : DbContext(options)
{
    public DbSet<OrderRow> Orders => Set<OrderRow>();
}

public sealed class OrderRow
{
    public int Id { get; set; }
    public required string CustomerId { get; set; }
    public decimal Total { get; set; }
}

// Stand-in so this file compiles on its own. Delete it in a real test project: in .NET 10 the API's
// generated Program is already public, and a Program declared here would shadow it (CS0436).
public partial class Program;

{
  // tests/Shop.Api.IntegrationTests/testsettings.json: lives in the test project
  // (copied to output), so it never ships in the API's publish output or image.
  "Logging": {
    "LogLevel": {
      "Default": "Warning",
      "Microsoft.EntityFrameworkCore.Database.Command": "Warning"
    }
  },
  "Payments": {
    "Mode": "fake",
    "WebhookSecret": "<test-placeholder>"
  },
  "Outbox": {
    "Enabled": false
  },
  "RateLimiting": {
    "PermitLimit": 10000
  }
}