Part V: Tests First📋

[Collection("Database")]
public class BillingCharacterizationTests : IClassFixture<DatabaseFixture>
{
    private readonly DatabaseFixture _db;

    public BillingCharacterizationTests(DatabaseFixture db)
    {
        _db = db;
    }

    [Fact]
    public async Task ProcessMonthlyBilling_ActiveSubscription_GoldenMaster()
    {
        // Arrange: seed a known state
        await using var context = _db.CreateContext();

        var plan = new Plan
        {
            Name = "Professional",
            MonthlyPrice = 49.99m,
            AnnualPrice = 499.99m,
            MaxUsers = 10
        };
        context.Plans.Add(plan);
        await context.SaveChangesAsync();

        var customer = new Customer
        {
            FullName = "Alice Martin",
            Email = "alice@example.com",
            CompanyName = "Acme Corp",
            BillingAddress = new BillingAddress
            {
                Country = "FR",
                Currency = "EUR"
            }
        };
        context.Customers.Add(customer);
        await context.SaveChangesAsync();

        var subscription = new Subscription
        {
            CustomerId = customer.Id,
            PlanId = plan.Id,
            Status = "Active",
            BillingInterval = "Monthly",
            StartDate = new DateTime(2025, 1, 1),
            CurrentPeriodStart = new DateTime(2025, 6, 1),
            CurrentPeriodEnd = new DateTime(2025, 7, 1)
        };
        context.Subscriptions.Add(subscription);

        var usageRecords = new[]
        {
            new UsageRecord
            {
                SubscriptionId = subscription.Id,
                MetricName = "api_calls",
                Quantity = 15000,
                RecordedAt = new DateTime(2025, 6, 15)
            }
        };
        context.UsageRecords.AddRange(usageRecords);
        await context.SaveChangesAsync();

        // Act: call the legacy method
        var billingService = CreateLegacyBillingService(context);
        var result = await billingService.ProcessMonthlyBilling(
            customer.Id, new DateTime(2025, 7, 1));

        // Assert: golden master -- capture what the system actually does
        result.InvoiceId.Should().BeGreaterThan(0);
        result.TotalAmount.Should().Be(49.99m);
        result.Currency.Should().Be("EUR");
        result.LineItemCount.Should().Be(1);
        result.TaxAmount.Should().Be(10.00m); // 20% FR VAT on 49.99 = 10.00
        result.Status.Should().Be("Draft");

        // Verify side effects in the database
        var invoice = await context.Invoices
            .Include(i => i.LineItems)
            .FirstAsync(i => i.Id == result.InvoiceId);
        invoice.LineItems.Should().HaveCount(1);
        invoice.LineItems[0].Description.Should().Be("Plan: Professional");
        invoice.LineItems[0].Amount.Should().Be(49.99m);

        // Verify notification was queued
        var notifications = await context.NotificationQueue
            .Where(n => n.CustomerId == customer.Id)
            .ToListAsync();
        notifications.Should().HaveCount(1);
        notifications[0].Type.Should().Be("InvoiceGenerated");
    }
}

[Fact]
public async Task ChangePlan_ActiveSubscription_GoldenMaster()
{
    await using var context = _db.CreateContext();
    var (customer, subscription) = await SeedActiveSubscription(context);

    var subscriptionService = CreateLegacySubscriptionService(context);
    var result = await subscriptionService.ChangePlan(
        subscription.Id, newPlanId: 2);

    result.Success.Should().BeTrue();
    result.NewPlanName.Should().Be("Enterprise");
    result.ProratedAmount.Should().Be(25.00m);

    var updated = await context.Subscriptions.FindAsync(subscription.Id);
    updated!.PlanId.Should().Be(2);
    updated.PlanChangedDate.Should().NotBeNull();
    updated.Status.Should().Be("Active");
}

[Fact]
public async Task ChangePlan_CancelledSubscription_GoldenMaster_BUG()
{
    // BUG: cancelled subscriptions silently accept plan changes.
    // The legacy system does not check subscription status before
    // applying the change. This test captures the buggy behavior
    // so we can consciously fix it in Phase 5 when we build the
    // Subscription aggregate with proper invariants.

    await using var context = _db.CreateContext();
    var (customer, subscription) = await SeedCancelledSubscription(context);

    var subscriptionService = CreateLegacySubscriptionService(context);
    var result = await subscriptionService.ChangePlan(
        subscription.Id, newPlanId: 2);

    // The bug: this succeeds when it should fail
    result.Success.Should().BeTrue();
    result.NewPlanName.Should().Be("Enterprise");

    var updated = await context.Subscriptions.FindAsync(subscription.Id);
    updated!.PlanId.Should().Be(2);
    updated.Status.Should().Be("Cancelled"); // Still cancelled, but plan changed
}

// Phase 5 update -- replace the BUG test with the correct behavior
[Fact]
public async Task ChangePlan_CancelledSubscription_RejectsChange()
{
    var subscription = new SubscriptionBuilder()
        .WithStatus(SubscriptionStatus.Cancelled)
        .Build();

    var result = subscription.ChangePlan(PlanId.Enterprise);

    result.IsFailure.Should().BeTrue();
    result.Error.Should().Be(SubscriptionErrors.CannotChangePlanWhenCancelled);
}

[Fact]
public async Task StripeAdapter_CreateCharge_TranslatesToPaymentResult()
{
    var fakeStripe = new FakeStripeAdapter();
    IPaymentGateway gateway = fakeStripe;

    var result = await gateway.CreateCharge(
        PaymentRequest.Create(
            customerId: CustomerId.From("cus_test_123"),
            amount: Money.EUR(49.99m),
            description: "Invoice #INV-2025-001"
        ));

    result.IsSuccess.Should().BeTrue();
    result.Value.TransactionId.Should().NotBeEmpty();
    result.Value.Amount.Should().Be(Money.EUR(49.99m));
    result.Value.Status.Should().Be(PaymentStatus.Succeeded);
}

[Fact]
public async Task StripeAdapter_PaymentFailure_TranslatesToResult()
{
    var fakeStripe = new FakeStripeAdapter();
    fakeStripe.SimulateDecline(DeclineReason.InsufficientFunds);
    IPaymentGateway gateway = fakeStripe;

    var result = await gateway.CreateCharge(
        PaymentRequest.Create(
            customerId: CustomerId.From("cus_test_123"),
            amount: Money.EUR(49.99m),
            description: "Invoice #INV-2025-001"
        ));

    result.IsFailure.Should().BeTrue();
    result.Error.Should().Be(PaymentErrors.InsufficientFunds);
}

[Fact]
public void Money_Add_SameCurrency_ReturnsSum()
{
    var a = Money.EUR(30.00m);
    var b = Money.EUR(19.99m);

    var result = a.Add(b);

    result.IsSuccess.Should().BeTrue();
    result.Value.Should().Be(Money.EUR(49.99m));
}

[Fact]
public void Money_Add_DifferentCurrency_ReturnsFailure()
{
    var eur = Money.EUR(30.00m);
    var usd = Money.USD(30.00m);

    var result = eur.Add(usd);

    result.IsFailure.Should().BeTrue();
    result.Error.Should().Be(MoneyErrors.CurrencyMismatch);
}

[Fact]
public void Money_Negative_ReturnsFailure()
{
    var result = Money.Create(-10.00m, Currency.EUR);

    result.IsFailure.Should().BeTrue();
    result.Error.Should().Be(MoneyErrors.NegativeAmount);
}

[Fact]
public void Subscription_ChangePlan_WhenCancelled_Fails()
{
    var subscription = new SubscriptionBuilder()
        .WithStatus(SubscriptionStatus.Cancelled)
        .Build();

    var result = subscription.ChangePlan(
        PlanId.Enterprise,
        clock: new FakeClock(new DateTime(2025, 7, 15)));

    result.IsFailure.Should().BeTrue();
    result.Error.Should().Be(SubscriptionErrors.CannotChangePlanWhenCancelled);
}

[Fact]
public void Subscription_ChangePlan_WhenActive_SucceedsAndRaisesDomainEvent()
{
    var subscription = new SubscriptionBuilder()
        .WithStatus(SubscriptionStatus.Active)
        .WithPlan(PlanId.Professional)
        .Build();

    var result = subscription.ChangePlan(
        PlanId.Enterprise,
        clock: new FakeClock(new DateTime(2025, 7, 15)));

    result.IsSuccess.Should().BeTrue();
    subscription.PlanId.Should().Be(PlanId.Enterprise);
    subscription.DomainEvents.Should().ContainSingle<PlanChangedEvent>(e =>
        e.OldPlanId == PlanId.Professional &&
        e.NewPlanId == PlanId.Enterprise);
}

[Fact]
public async Task PlanChangedHandler_GeneratesProratedInvoice()
{
    var fakeRepository = new FakeSubscriptionRepository();
    var fakeInvoiceService = new FakeInvoiceService();
    var handler = new GenerateProratedInvoiceHandler(
        fakeRepository, fakeInvoiceService);

    var @event = new PlanChangedEvent(
        SubscriptionId: SubscriptionId.From(42),
        OldPlanId: PlanId.Professional,
        NewPlanId: PlanId.Enterprise,
        ChangedAt: new DateTime(2025, 7, 15));

    await handler.HandleAsync(@event);

    fakeInvoiceService.GeneratedInvoices.Should().ContainSingle(inv =>
        inv.SubscriptionId == SubscriptionId.From(42) &&
        inv.Type == InvoiceType.ProratedCredit);
}

public sealed class DatabaseFixture : IAsyncLifetime
{
    private readonly PostgreSqlContainer _container = new PostgreSqlBuilder()
        .WithImage("postgres:16")
        .WithDatabase("subscriptionhub_test")
        .WithUsername("test")
        .WithPassword("test")
        .WithCleanUp(true)
        .Build();

    public string ConnectionString => _container.GetConnectionString();

    public async Task InitializeAsync()
    {
        await _container.StartAsync();

        // Apply EF Core migrations to the test database
        await using var context = CreateContext();
        await context.Database.MigrateAsync();
    }

    public async Task DisposeAsync()
    {
        await _container.DisposeAsync();
    }

    public AppDbContext CreateContext()
    {
        var options = new DbContextOptionsBuilder<AppDbContext>()
            .UseNpgsql(ConnectionString)
            .Options;

        return new AppDbContext(options);
    }
}

[Collection("Database")]
public class InvoiceCharacterizationTests : IClassFixture<DatabaseFixture>
{
    private readonly DatabaseFixture _db;

    public InvoiceCharacterizationTests(DatabaseFixture db)
    {
        _db = db;
    }

    [Fact]
    public async Task GenerateInvoice_WithUsageMetering_CalculatesOverageCharges()
    {
        await using var context = _db.CreateContext();

        // Seed data and run legacy code...
        var (customer, subscription) = await SeedSubscriptionWithUsage(
            context, apiCalls: 15_000, includedCalls: 10_000);

        var billingService = CreateLegacyBillingService(context);
        var result = await billingService.ProcessMonthlyBilling(
            customer.Id, new DateTime(2025, 7, 1));

        // Golden master: 5,000 overage calls * $0.001 = $5.00 extra
        result.LineItemCount.Should().Be(2);
        result.TotalAmount.Should().Be(54.99m); // 49.99 base + 5.00 overage
    }
}

public class ApiFixture : WebApplicationFactory<Program>, IAsyncLifetime
{
    private readonly PostgreSqlContainer _container = new PostgreSqlBuilder()
        .WithImage("postgres:16")
        .WithDatabase("subscriptionhub_test")
        .WithUsername("test")
        .WithPassword("test")
        .WithCleanUp(true)
        .Build();

    public async Task InitializeAsync()
    {
        await _container.StartAsync();
    }

    public new async Task DisposeAsync()
    {
        await _container.DisposeAsync();
        await base.DisposeAsync();
    }

    protected override void ConfigureWebHost(IWebHostBuilder builder)
    {
        builder.ConfigureServices(services =>
        {
            // Remove the real DbContext registration
            var descriptor = services.SingleOrDefault(
                d => d.ServiceType == typeof(DbContextOptions<AppDbContext>));
            if (descriptor != null) services.Remove(descriptor);

            // Register DbContext with Testcontainers connection string
            services.AddDbContext<AppDbContext>(options =>
                options.UseNpgsql(_container.GetConnectionString()));

            // Replace real external adapters with fakes
            services.RemoveAll<IPaymentGateway>();
            services.AddSingleton<IPaymentGateway, FakeStripeAdapter>();

            services.RemoveAll<ITaxCalculator>();
            services.AddSingleton<ITaxCalculator, FakeTaxCalculator>();

            services.RemoveAll<IEmailSender>();
            services.AddSingleton<IEmailSender, FakeEmailSender>();
        });
    }
}

[Collection("Api")]
public class SubscriptionApiTests : IClassFixture<ApiFixture>
{
    private readonly HttpClient _client;
    private readonly ApiFixture _fixture;

    public SubscriptionApiTests(ApiFixture fixture)
    {
        _fixture = fixture;
        _client = fixture.CreateClient();
    }

    [Fact]
    public async Task ChangePlan_ActiveSubscription_Returns200AndUpdatesState()
    {
        // Arrange: seed via API (tests the POST endpoint too)
        var createResponse = await _client.PostAsJsonAsync(
            "/api/subscriptions",
            new
            {
                CustomerEmail = "alice@example.com",
                PlanId = "professional",
                BillingInterval = "monthly"
            });
        createResponse.EnsureSuccessStatusCode();
        var created = await createResponse.Content
            .ReadFromJsonAsync<SubscriptionDto>();

        // Act: change plan
        var changeResponse = await _client.PutAsJsonAsync(
            $"/api/subscriptions/{created!.Id}/change-plan",
            new { NewPlanId = "enterprise" });

        // Assert: HTTP response
        changeResponse.StatusCode.Should().Be(HttpStatusCode.OK);
        var result = await changeResponse.Content
            .ReadFromJsonAsync<PlanChangeResultDto>();
        result!.OldPlan.Should().Be("professional");
        result.NewPlan.Should().Be("enterprise");
        result.ProratedAmount.Should().BeGreaterThan(0);

        // Assert: database state
        using var scope = _fixture.Services.CreateScope();
        var context = scope.ServiceProvider.GetRequiredService<AppDbContext>();
        var subscription = await context.Subscriptions
            .FirstAsync(s => s.Id == created.Id);
        subscription.PlanId.Should().Be(
            context.Plans.First(p => p.Name == "Enterprise").Id);
        subscription.PlanChangedDate.Should().NotBeNull();

        // Assert: notification was queued
        var emailSender = _fixture.Services
            .GetRequiredService<IEmailSender>() as FakeEmailSender;
        emailSender!.SentEmails.Should().Contain(e =>
            e.To == "alice@example.com" &&
            e.Subject.Contains("plan change"));
    }
}

[Fact]
public async Task LegacyEndpoint_StillReturnsOriginalShape_DuringMigration()
{
    // Arrange
    var (client, subscriptionId) = await CreateActiveSubscription();

    // Act: call the legacy endpoint that now delegates to the new aggregate
    var response = await client.PostAsJsonAsync(
        $"/api/billing/process/{subscriptionId}",
        new { BillingDate = "2025-07-01" });

    // Assert: response shape unchanged -- golden master
    response.StatusCode.Should().Be(HttpStatusCode.OK);
    var result = await response.Content.ReadFromJsonAsync<JsonElement>();
    result.GetProperty("invoiceId").GetInt32().Should().BeGreaterThan(0);
    result.GetProperty("totalAmount").GetDecimal().Should().BeGreaterThan(0);
    result.GetProperty("currency").GetString().Should().NotBeNullOrEmpty();
    result.GetProperty("lineItemCount").GetInt32().Should().BeGreaterThan(0);
    result.GetProperty("status").GetString().Should().Be("Draft");
}

// Mock-based test -- fragile, coupled to implementation
[Fact]
public async Task ProcessBilling_CallsStripe_WithCorrectAmount()
{
    var mockGateway = new Mock<IPaymentGateway>();
    mockGateway
        .Setup(g => g.CreateCharge(It.IsAny<PaymentRequest>()))
        .ReturnsAsync(Result.Success(new PaymentResult("ch_123",
            Money.EUR(49.99m), PaymentStatus.Succeeded)));

    var service = new BillingService(mockGateway.Object, ...);

    await service.ProcessMonthlyBilling(customerId, billingDate);

    mockGateway.Verify(g => g.CreateCharge(
        It.Is<PaymentRequest>(r => r.Amount == Money.EUR(49.99m))),
        Times.Once);
}

public class FakeStripeAdapter : IPaymentGateway
{
    private readonly Dictionary<string, PaymentResult> _charges = new();
    private DeclineReason? _forcedDecline;

    public IReadOnlyList<PaymentRequest> ReceivedRequests { get; } = new List<PaymentRequest>();

    public Task<Result<PaymentResult>> CreateCharge(PaymentRequest request)
    {
        ((List<PaymentRequest>)ReceivedRequests).Add(request);

        if (_forcedDecline.HasValue)
        {
            return Task.FromResult(Result.Failure<PaymentResult>(
                PaymentErrors.Declined(_forcedDecline.Value)));
        }

        var transactionId = $"ch_fake_{Guid.NewGuid():N}";
        var result = new PaymentResult(
            transactionId, request.Amount, PaymentStatus.Succeeded);
        _charges[transactionId] = result;

        return Task.FromResult(Result.Success(result));
    }

    public Task<Result<RefundResult>> RefundCharge(
        string transactionId, Money amount)
    {
        if (!_charges.ContainsKey(transactionId))
        {
            return Task.FromResult(Result.Failure<RefundResult>(
                PaymentErrors.TransactionNotFound));
        }

        var result = new RefundResult(
            $"re_fake_{Guid.NewGuid():N}", amount, RefundStatus.Succeeded);
        return Task.FromResult(Result.Success(result));
    }

    // Test control methods
    public void SimulateDecline(DeclineReason reason) => _forcedDecline = reason;
    public void Reset() { _charges.Clear(); _forcedDecline = null; }
}

public class FakeTaxCalculator : ITaxCalculator
{
    private decimal _taxRate = 0.20m; // Default: 20% (FR VAT)

    public Task<Result<TaxCalculation>> CalculateTax(
        Money amount, Address billingAddress)
    {
        var taxAmount = Money.Create(
            Math.Round(amount.Amount * _taxRate, 2),
            amount.Currency);

        if (taxAmount.IsFailure)
            return Task.FromResult(Result.Failure<TaxCalculation>(
                taxAmount.Error));

        var calculation = new TaxCalculation(
            amount, taxAmount.Value, _taxRate, billingAddress.Country);

        return Task.FromResult(Result.Success(calculation));
    }

    // Test control
    public void SetTaxRate(decimal rate) => _taxRate = rate;
    public void SetZeroRate() => _taxRate = 0m;
}

public class FakeEventBus : IEventPublisher
{
    private readonly List<IDomainEvent> _publishedEvents = new();

    public IReadOnlyList<IDomainEvent> PublishedEvents => _publishedEvents;

    public Task PublishAsync(IDomainEvent @event,
        CancellationToken cancellationToken = default)
    {
        _publishedEvents.Add(@event);
        return Task.CompletedTask;
    }

    public Task PublishAsync(IEnumerable<IDomainEvent> events,
        CancellationToken cancellationToken = default)
    {
        _publishedEvents.AddRange(events);
        return Task.CompletedTask;
    }

    // Assertion helpers
    public void ShouldHavePublished<TEvent>() where TEvent : IDomainEvent
    {
        _publishedEvents.Should().ContainSingle(e => e is TEvent,
            $"Expected a {typeof(TEvent).Name} event to be published");
    }

    public TEvent Single<TEvent>() where TEvent : IDomainEvent
    {
        return _publishedEvents.OfType<TEvent>().Should().ContainSingle()
            .Subject;
    }

    public void ShouldBeEmpty()
    {
        _publishedEvents.Should().BeEmpty(
            "No events should have been published");
    }

    public void Reset() => _publishedEvents.Clear();
}

[Fact]
public void Subscription_ChangePlan_PublishesPlanChangedEvent()
{
    var subscription = new SubscriptionBuilder()
        .WithStatus(SubscriptionStatus.Active)
        .WithPlan(PlanId.Professional)
        .Build();

    subscription.ChangePlan(PlanId.Enterprise,
        clock: new FakeClock(new DateTime(2025, 7, 15)));

    var @event = subscription.DomainEvents.OfType<PlanChangedEvent>().Single();
    @event.OldPlanId.Should().Be(PlanId.Professional);
    @event.NewPlanId.Should().Be(PlanId.Enterprise);
    @event.ChangedAt.Should().Be(new DateTime(2025, 7, 15));
}

public class SubscriptionBuilder
{
    private SubscriptionStatus _status = SubscriptionStatus.Active;
    private PlanId _planId = PlanId.Professional;
    private Money _price = Money.EUR(49.99m);
    private DateTime _startDate = new(2025, 1, 1);
    private DateTime? _planChangedDate;
    private string _billingInterval = "Monthly";
    private CustomerId _customerId = CustomerId.From(1);

    public SubscriptionBuilder WithStatus(SubscriptionStatus status)
    {
        _status = status;
        return this;
    }

    public SubscriptionBuilder WithPlan(PlanId planId)
    {
        _planId = planId;
        return this;
    }

    public SubscriptionBuilder WithPrice(Money price)
    {
        _price = price;
        return this;
    }

    public SubscriptionBuilder WithPlanChangedDate(DateTime date)
    {
        _planChangedDate = date;
        return this;
    }

    public SubscriptionBuilder WithBillingInterval(string interval)
    {
        _billingInterval = interval;
        return this;
    }

    public SubscriptionBuilder ForCustomer(CustomerId customerId)
    {
        _customerId = customerId;
        return this;
    }

    public Subscription Build()
    {
        return Subscription.Reconstitute(
            id: SubscriptionId.New(),
            customerId: _customerId,
            planId: _planId,
            status: _status,
            price: _price,
            billingInterval: _billingInterval,
            startDate: _startDate,
            planChangedDate: _planChangedDate);
    }
}

// Without builder -- 15 lines, most of it noise
var subscription = new Subscription
{
    Id = 42,
    CustomerId = 1,
    PlanId = 2,
    Status = "Active",
    BillingInterval = "Monthly",
    StartDate = new DateTime(2025, 1, 1),
    CurrentPeriodStart = new DateTime(2025, 6, 1),
    CurrentPeriodEnd = new DateTime(2025, 7, 1),
    MonthlyPrice = 49.99m,
    Currency = "EUR"
};

// With builder -- 3 lines, signal only
var subscription = new SubscriptionBuilder()
    .WithStatus(SubscriptionStatus.Active)
    .Build();

public class InvoiceBuilder
{
    private Money _amount = Money.EUR(49.99m);
    private InvoiceStatus _status = InvoiceStatus.Draft;
    private SubscriptionId _subscriptionId = SubscriptionId.From(1);
    private DateTime _invoiceDate = new(2025, 7, 1);
    private readonly List<InvoiceLineItem> _lineItems = new();

    public InvoiceBuilder WithAmount(Money amount)
    { _amount = amount; return this; }

    public InvoiceBuilder WithStatus(InvoiceStatus status)
    { _status = status; return this; }

    public InvoiceBuilder WithLineItem(string description, Money amount)
    {
        _lineItems.Add(new InvoiceLineItem(description, amount));
        return this;
    }

    public Invoice Build()
    {
        var invoice = Invoice.Create(_subscriptionId, _invoiceDate, _amount);
        foreach (var item in _lineItems)
            invoice.AddLineItem(item.Description, item.Amount);
        return invoice;
    }
}

public class PlanBuilder
{
    private string _name = "Professional";
    private Money _monthlyPrice = Money.EUR(49.99m);
    private Money _annualPrice = Money.EUR(499.99m);
    private int _maxUsers = 10;

    public PlanBuilder WithName(string name)
    { _name = name; return this; }

    public PlanBuilder WithMonthlyPrice(Money price)
    { _monthlyPrice = price; return this; }

    public Plan Build()
    {
        return Plan.Create(PlanId.New(), _name, _monthlyPrice,
            _annualPrice, _maxUsers);
    }
}

var subscription = new SubscriptionBuilder()
    .WithPlan(PlanId.Annual)
    .WithPrice(Money.EUR(499.99m))
    .WithStatus(SubscriptionStatus.Active)
    .Build();

[Fact]
public void Domain_ShouldNotReference_Infrastructure()
{
    var result = Types
        .InAssembly(typeof(Subscription).Assembly)
        .ShouldNot()
        .HaveDependencyOn("Microsoft.EntityFrameworkCore")
        .GetResult();

    result.IsSuccessful.Should().BeTrue(
        string.Join(", ", result.FailingTypeNames ?? Array.Empty<string>()));
}

[Fact]
public void Domain_ShouldNotReference_AspNetCore()
{
    var result = Types
        .InAssembly(typeof(Subscription).Assembly)
        .ShouldNot()
        .HaveDependencyOn("Microsoft.AspNetCore")
        .GetResult();

    result.IsSuccessful.Should().BeTrue();
}

[Fact]
public void DomainEvents_ShouldBeSealed_Records()
{
    var result = Types
        .InAssembly(typeof(Subscription).Assembly)
        .That()
        .ImplementInterface(typeof(IDomainEvent))
        .Should()
        .BeSealed()
        .GetResult();

    result.IsSuccessful.Should().BeTrue(
        $"Domain events must be sealed. Violations: " +
        string.Join(", ", result.FailingTypeNames ?? Array.Empty<string>()));
}

[Fact]
public void Aggregates_ShouldNotHave_PublicSetters()
{
    var aggregateTypes = Types
        .InAssembly(typeof(Subscription).Assembly)
        .That()
        .Inherit(typeof(AggregateRoot<>))
        .GetTypes();

    foreach (var type in aggregateTypes)
    {
        var publicSetters = type.GetProperties()
            .Where(p => p.SetMethod?.IsPublic == true)
            .Select(p => p.Name)
            .ToList();

        publicSetters.Should().BeEmpty(
            $"Aggregate {type.Name} has public setters: " +
            string.Join(", ", publicSetters));
    }
}

[Fact]
public void BillingContext_ShouldNotReference_SubscriptionDomain()
{
    var result = Types
        .InAssembly(typeof(Invoice).Assembly)
        .ShouldNot()
        .HaveDependencyOn("Subscription.Domain")
        .GetResult();

    result.IsSuccessful.Should().BeTrue(
        "Billing context must not directly reference Subscription domain. " +
        "Use events or shared kernel types.");
}

// Domain tests -- no trait needed, they are the default
[Fact]
public void Money_Add_SameCurrency_ReturnsSum() { ... }

// Integration tests
[Fact]
[Trait("Category", "Integration")]
public async Task InvoiceRepository_Save_PersistsToDatabase() { ... }

// E2E tests
[Fact]
[Trait("Category", "E2E")]
public async Task ChangePlan_FullPipeline_Returns200() { ... }

# Every commit
dotnet test --filter "Category!=Integration&Category!=E2E"

# Pull request
dotnet test --filter "Category=Integration"

# Merge to main
dotnet test --filter "Category=E2E"

// In your CI script or .runsettings
// Domain libraries: 90% minimum. They're pure logic -- there's no excuse.
// Application libraries: 80% minimum. Handlers are tested via integration tests too.
// Infrastructure libraries: 60% minimum. Some code is adapter boilerplate.

# Collect coverage
dotnet test --collect:"XPlat Code Coverage" --results-directory ./coverage

# Fail if domain coverage drops below 90%
dotnet reportgenerator -reports:./coverage/**/coverage.cobertura.xml \
  -targetdir:./coverage/report -reporttypes:TextSummary

# Parse and enforce (simplified -- use a script or quality gate tool)
DOMAIN_COV=$(grep "Subscriptions.Domain" ./coverage/report/Summary.txt | awk '{print $NF}')
if (( $(echo "$DOMAIN_COV < 90" | bc -l) )); then
  echo "❌ Domain coverage $DOMAIN_COV% < 90% threshold"
  exit 1
fi

# Fail if any test is skipped
SKIPPED=$(dotnet test --logger "trx" 2>&1 | grep -c "Skipped")
if [ "$SKIPPED" -gt 0 ]; then
  echo "❌ $SKIPPED skipped tests. Fix or remove them."
  exit 1
fi

public class QueryCountingInterceptor : DbCommandInterceptor
{
    public int QueryCount { get; private set; }

    public void Reset() => QueryCount = 0;

    public override InterceptionResult<DbDataReader> ReaderExecuting(
        DbCommand command, CommandEventData eventData, InterceptionResult<DbDataReader> result)
    {
        QueryCount++;
        return result;
    }
}

// In your integration test
[Fact]
[Trait("Category", "Integration")]
public async Task LoadSubscription_ExecutesExactlyOneQuery()
{
    var counter = _fixture.GetService<QueryCountingInterceptor>();
    counter.Reset();

    var subscription = await _repository.GetByIdAsync(subscriptionId);

    Assert.Equal(1, counter.QueryCount); // Not 1 + N child queries
}

[Fact]
[Trait("Category", "E2E")]
public async Task ChangePlan_RespondsWithin200ms()
{
    var stopwatch = Stopwatch.StartNew();

    var response = await _client.PostAsJsonAsync(
        $"/api/subscriptions/{_subscriptionId}/change-plan",
        new { PlanId = "annual" });

    stopwatch.Stop();
    Assert.True(response.IsSuccessStatusCode);
    Assert.True(stopwatch.ElapsedMilliseconds < 200,
        $"ChangePlan took {stopwatch.ElapsedMilliseconds}ms, expected < 200ms");
}

public class PlanChangeAcceptanceTests : IClassFixture<ApiFixture>
{
    [Fact]
    [Trait("Category", "Acceptance")]
    public async Task Given_ActiveSubscription_When_PlanChanged_Then_ProratedInvoiceGenerated()
    {
        // Given: an active monthly subscription at €49/month, mid-cycle
        var subscriptionId = await _fixture.CreateSubscription(
            plan: "monthly", price: Money.EUR(49m),
            period: new SubscriptionPeriod(
                new DateOnly(2026, 3, 1), new DateOnly(2026, 3, 31)));

        // When: the customer upgrades to annual at €399/year on March 16
        var response = await _client.PostAsJsonAsync(
            $"/api/subscriptions/{subscriptionId}/change-plan",
            new { PlanId = "annual" });

        // Then: a prorated invoice is generated
        response.EnsureSuccessStatusCode();

        var invoice = await _fixture.GetLatestInvoice(subscriptionId);
        Assert.NotNull(invoice);

        // Credit for remaining 15 days of monthly: -€23.71
        // Charge for annual plan prorated to remaining period: proportional
        Assert.True(invoice.LineItems.Count >= 2, "Expected credit + charge line items");
        Assert.Contains(invoice.LineItems, li => li.Amount.Amount < 0); // credit
        Assert.Contains(invoice.LineItems, li => li.Amount.Amount > 0); // charge
    }

    [Fact]
    [Trait("Category", "Acceptance")]
    public async Task Given_CancelledSubscription_When_PlanChanged_Then_Rejected()
    {
        // Given: a cancelled subscription
        var subscriptionId = await _fixture.CreateSubscription(plan: "monthly");
        await _client.PostAsync($"/api/subscriptions/{subscriptionId}/cancel", null);

        // When: someone tries to change the plan
        var response = await _client.PostAsJsonAsync(
            $"/api/subscriptions/{subscriptionId}/change-plan",
            new { PlanId = "annual" });

        // Then: the request is rejected with a clear error
        Assert.Equal(HttpStatusCode.UnprocessableEntity, response.StatusCode);
        var error = await response.Content.ReadFromJsonAsync<ProblemDetails>();
        Assert.Contains("cancelled", error!.Detail, StringComparison.OrdinalIgnoreCase);
    }

    [Fact]
    [Trait("Category", "Acceptance")]
    public async Task Given_FailedPayment_When_ThreeRetries_Then_SubscriptionSuspended()
    {
        // Given: an active subscription with a failing payment method
        var subscriptionId = await _fixture.CreateSubscription(plan: "monthly");
        _fixture.GetService<FakeStripeAdapter>().SimulatePaymentFailure();

        // When: three payment attempts fail
        for (int i = 0; i < 3; i++)
        {
            await _fixture.TriggerBillingCycle(subscriptionId);
        }

        // Then: the subscription is suspended
        var subscription = await _client.GetFromJsonAsync<SubscriptionDto>(
            $"/api/subscriptions/{subscriptionId}");
        Assert.Equal("Suspended", subscription!.Status);
    }
}

# Merge to main
dotnet test --filter "Category=E2E|Category=Acceptance"

// In Subscriptions.Infrastructure
public class SubscriptionsHealthCheck : IHealthCheck
{
    private readonly SubscriptionsDbContext _db;

    public SubscriptionsHealthCheck(SubscriptionsDbContext db) => _db = db;

    public async Task<HealthCheckResult> CheckHealthAsync(
        HealthCheckContext context, CancellationToken ct = default)
    {
        try
        {
            await _db.Database.CanConnectAsync(ct);
            return HealthCheckResult.Healthy("Subscriptions DB reachable");
        }
        catch (Exception ex)
        {
            return HealthCheckResult.Unhealthy("Subscriptions DB unreachable", ex);
        }
    }
}

// In Program.cs
builder.Services
    .AddHealthChecks()
    .AddCheck<SubscriptionsHealthCheck>("subscriptions-db")
    .AddCheck<BillingHealthCheck>("billing-db")
    .AddCheck<StripeHealthCheck>("stripe-api");

#!/bin/bash
# smoke-test.sh — run after deployment

BASE_URL="${1:-https://subscriptionhub.example.com}"
FAILED=0

check() {
  local name="$1" url="$2" expected_status="${3:-200}"
  STATUS=$(curl -s -o /dev/null -w "%{http_code}" "$url")
  if [ "$STATUS" -eq "$expected_status" ]; then
    echo "  ✓ $name ($STATUS)"
  else
    echo "  ✗ $name (expected $expected_status, got $STATUS)"
    FAILED=1
  fi
}

echo "Smoke testing $BASE_URL..."
check "Health"          "$BASE_URL/health"
check "Subscriptions"   "$BASE_URL/api/subscriptions?limit=1"
check "Invoices"        "$BASE_URL/api/invoices?limit=1"
check "Plans"           "$BASE_URL/api/plans"

exit $FAILED

[Fact]
[Trait("Category", "Smoke")]
public async Task StranglerFigParity_OldAndNewPaths_ReturnSameShape()
{
    // Force old path
    _fixture.SetFeatureFlag("UseNewSubscriptionAggregate", false);
    var oldResponse = await _client.GetAsync($"/api/subscriptions/{_id}");
    var oldJson = await oldResponse.Content.ReadAsStringAsync();

    // Force new path
    _fixture.SetFeatureFlag("UseNewSubscriptionAggregate", true);
    var newResponse = await _client.GetAsync($"/api/subscriptions/{_id}");
    var newJson = await newResponse.Content.ReadAsStringAsync();

    // Same HTTP status
    Assert.Equal(oldResponse.StatusCode, newResponse.StatusCode);

    // Same JSON structure (ignoring values that may differ like timestamps)
    var oldKeys = JsonDocument.Parse(oldJson).RootElement.EnumerateObject()
        .Select(p => p.Name).OrderBy(n => n);
    var newKeys = JsonDocument.Parse(newJson).RootElement.EnumerateObject()
        .Select(p => p.Name).OrderBy(n => n);
    Assert.Equal(oldKeys, newKeys);
}