Testing .NET In Depth

// UNIT — isolate one class, mock dependencies (milliseconds)
//   PricingService.CalculateDiscount(...)

// INTEGRATION — real DI, real HTTP pipeline, maybe real DB (seconds)
//   WebApplicationFactory + Testcontainers SQL

// E2E — browser or Postman collections against deployed env (minutes)
//   Playwright, k6 load tests — keep count low

// Rule of thumb: 70% unit · 25% integration · 5% E2E
// Fast feedback loop → run unit tests on every save (dotnet watch test)

src/
  Api/                    // ASP.NET Core host
  Application/            // Handlers, services
  Domain/
  Infrastructure/         // EF Core, external APIs
tests/
  Api.UnitTests/
  Application.UnitTests/
  Api.IntegrationTests/   // WebApplicationFactory lives here

// dotnet new xunit -n Api.UnitTests
// dotnet add reference ../src/Application/Application.csproj
// dotnet add package Moq
// dotnet add package FluentAssertions

public class DiscountCalculatorTests
{
    private readonly DiscountCalculator _sut = new();  // System Under Test

    [Fact]
    public void ApplyTenPercent_ReducesTotalByTenPercent()
    {
        // Arrange
        decimal total = 100m;

        // Act
        decimal result = _sut.Apply(total, percent: 10);

        // Assert
        Assert.Equal(90m, result);
    }

    [Theory]
    [InlineData(0, 0)]
    [InlineData(50, 5)]
    [InlineData(100, 10)]
    public void Apply_CalculatesCorrectly(decimal total, decimal expected)
        => Assert.Equal(expected, _sut.Apply(total, percent: 10));
}

// Shared expensive setup — implement IAsyncLifetime
public sealed class DatabaseFixture : IAsyncLifetime
{
    public AppDbContext Db { get; private set; } = null!;

    public async Task InitializeAsync()
    {
        // spin up Testcontainers — see section 6
    }

    public Task DisposeAsync() => Task.CompletedTask;
}

// Collection fixture — one DB for all tests in collection
[CollectionDefinition("db")]
public class DbCollection : ICollectionFixture<DatabaseFixture> { }

// Skip flaky test until fixed
[Fact(Skip = "Flaky on CI — issue #142")]
public void SometimesFails() { }

public sealed class OrderServiceTests
{
    private readonly Mock<IOrderRepository> _repo = new();
    private readonly Mock<IEmailSender> _email = new();
    private readonly OrderService _sut;

    public OrderServiceTests()
        => _sut = new OrderService(_repo.Object, _email.Object);

    [Fact]
    public async Task PlaceOrder_SavesAndSendsConfirmation()
    {
        _repo.Setup(r => r.AddAsync(It.IsAny<Order>(), It.IsAny<CancellationToken>()))
             .ReturnsAsync((Order o, CancellationToken _) => o);

        var result = await _sut.PlaceOrderAsync(new PlaceOrderRequest(1, []), CancellationToken.None);

        Assert.NotNull(result.OrderNumber);
        _repo.Verify(r => r.AddAsync(It.Is<Order>(o => o.CustomerId == 1), It.IsAny<CancellationToken>()), Times.Once);
        _email.Verify(e => e.SendAsync(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<CancellationToken>()), Times.Once);
    }
}

// ✅ Mock — external HTTP, email, clock, random, file system
// ✅ Mock — repository when testing service logic in isolation

// ❌ Don't mock — value objects, DTOs, pure functions
// ❌ Don't mock — DbContext (use in-memory or Testcontainers instead)
// ❌ Don't mock — the class you're testing

// Prefer interfaces for testability (see SOLID — Dependency Inversion)
public interface IOrderRepository
{
    Task<Order> AddAsync(Order order, CancellationToken ct);
}

using FluentAssertions;

[Fact]
public void Customer_HasExpectedDefaults()
{
    var customer = new Customer { Name = "Ada" };

    customer.Name.Should().Be("Ada");
    customer.Orders.Should().BeEmpty();
    customer.IsActive.Should().BeTrue();
}

[Fact]
public void InvalidOrder_ThrowsValidationException()
{
    var act = () => OrderValidator.Validate(new PlaceOrderRequest(-1, []));

    act.Should().Throw<ValidationException>()
       .WithMessage("*CustomerId*");
}

// Collection assertions
orders.Should().HaveCount(3)
      .And.OnlyContain(o => o.Total > 0)
      .And.BeInAscendingOrder(o => o.OrderDate);

// Object equivalence — ignore volatile fields
actual.Should().BeEquivalentTo(expected, opts => opts
    .Excluding(x => x.CreatedAt)
    .Excluding(x => x.Id));

// HttpResponseMessage (integration tests)
response.StatusCode.Should().Be(HttpStatusCode.Created);
response.Headers.Location.Should().NotBeNull();

// Package: Microsoft.AspNetCore.Mvc.Testing

public sealed class ApiFactory : WebApplicationFactory<Program>
{
    protected override void ConfigureWebHost(IWebHostBuilder builder)
    {
        builder.UseEnvironment("Testing");
        builder.ConfigureServices(services =>
        {
            // Replace real email with fake
            services.RemoveAll<IEmailSender>();
            services.AddSingleton<IEmailSender, FakeEmailSender>();
        });
    }
}

public class CustomersEndpointTests(ApiFactory factory) : IClassFixture<ApiFactory>
{
    private readonly HttpClient _client = factory.CreateClient();

    [Fact]
    public async Task GetCustomers_ReturnsOk()
    {
        var response = await _client.GetAsync("/api/customers");
        response.StatusCode.Should().Be(HttpStatusCode.OK);
    }
}

// Expose Program for WebApplicationFactory (.NET 6+ top-level statements)
// At bottom of Program.cs:
public partial class Program { }

// Authenticate as test user
_client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", TestJwtHelper.CreateToken(userId: "test-user"));

// Or bypass auth in Testing environment
builder.ConfigureServices(services =>
{
    services.AddAuthentication("Test")
        .AddScheme<AuthenticationSchemeOptions, TestAuthHandler>("Test", _ => { });
});

// Package: Testcontainers.MsSql

public sealed class SqlContainerFixture : IAsyncLifetime
{
    private readonly MsSqlContainer _container = new MsSqlBuilder()
        .WithImage("mcr.microsoft.com/mssql/server:2022-latest")
        .Build();

    public string ConnectionString => _container.GetConnectionString();

    public Task InitializeAsync() => _container.StartAsync();
    public Task DisposeAsync() => _container.DisposeAsync().AsTask();
}

// Wire into WebApplicationFactory
builder.ConfigureServices(services =>
{
    services.RemoveAll<DbContextOptions<AppDbContext>>();
    services.AddDbContext<AppDbContext>(opts =>
        opts.UseSqlServer(_fixture.ConnectionString));
});

// Apply migrations once per fixture
await using var scope = factory.Services.CreateAsyncScope();
var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
await db.Database.MigrateAsync();

// Seed baseline data
await db.Customers.AddAsync(new Customer { Name = "Test Corp" });
await db.SaveChangesAsync();

// Isolate: transaction rollback or Respawn library between tests
// Respawn — fast DB reset without recreating container

public record CreateCustomerCommand(string Name) : IRequest<int>;

public sealed class CreateCustomerHandler(IAppDbContext db) : IRequestHandler<CreateCustomerCommand, int>
{
    public async Task<int> Handle(CreateCustomerCommand request, CancellationToken ct)
    {
        var customer = new Customer { Name = request.Name };
        db.Customers.Add(customer);
        await db.SaveChangesAsync(ct);
        return customer.Id;
    }
}

[Fact]
public async Task Handle_PersistsCustomer()
{
    var db = new Mock<IAppDbContext>();
    db.Setup(d => d.SaveChangesAsync(It.IsAny<CancellationToken>())).ReturnsAsync(1);
    var handler = new CreateCustomerHandler(db.Object);

    var id = await handler.Handle(new CreateCustomerCommand("Ada"), CancellationToken.None);

    db.Verify(d => d.Customers.Add(It.Is<Customer>(c => c.Name == "Ada")), Times.Once);
}

// Test ValidationBehavior throws before handler runs
services.AddMediatR(cfg => cfg.RegisterServicesFromAssembly(typeof(CreateCustomerCommand).Assembly));
services.AddValidatorsFromAssembly(typeof(CreateCustomerCommand).Assembly);
services.AddTransient(typeof(IPipelineBehavior<,>), typeof(ValidationBehavior<,>));

var mediator = provider.GetRequiredService<IMediator>();

var act = () => mediator.Send(new CreateCustomerCommand(""));

await act.Should().ThrowAsync<ValidationException>();

[Collection("db")]
public sealed class CustomerRepositoryTests(SqlContainerFixture fx)
{
    [Fact]
    public async Task GetByEmail_ReturnsCustomerWhenExists()
    {
        await using var db = CreateContext(fx.ConnectionString);
        var repo = new CustomerRepository(db);

        db.Customers.Add(new Customer { Name = "Ada", Email = "ada@test.com" });
        await db.SaveChangesAsync();

        var found = await repo.GetByEmailAsync("ada@test.com", CancellationToken.None);

        found.Should().NotBeNull();
        found!.Name.Should().Be("Ada");
    }
}

// Quick unit-ish tests — NOT a SQL Server substitute
var options = new DbContextOptionsBuilder<AppDbContext>()
    .UseInMemoryDatabase(Guid.NewGuid().ToString())
    .Options;

// ❌ InMemory ignores FK constraints, raw SQL, transactions
// ❌ Different query translation — false positives
// ✅ Fine for testing pure EF mapping or simple CRUD logic
// ✅ Production path: Testcontainers SQL (section 6)

// Package: Verify.Xunit

[Fact]
public Task SerializeOrder_ReturnsExpectedJson()
{
    var order = new OrderDto(1, "ORD-001", 99.50m, [new LineDto("Widget", 2)]);

    var json = JsonSerializer.Serialize(order, JsonOptions);

    return Verify(json);  // creates *.verified.txt on first run
}

// Update snapshots after intentional change:
// dotnet test -- Verify.DiffTool=VisualStudio

// SKIP snapshot when:
//   • Output contains timestamps, GUIDs, random IDs
//   • Third-party HTML changes frequently
//   • Large binary or file outputs

// Scrub volatile fields before Verify:
var scrubbed = order with { CreatedAt = DateTimeOffset.MinValue };
await Verify(scrubbed);

// Or use [Fact(Skip = "Snapshot — optional for this module")]
[Fact(Skip = "Approval test optional — enable when output stabilizes")]
public Task GenerateReport_MatchesBaseline() => Task.CompletedTask;

# .github/workflows/ci.yml
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-dotnet@v4
        with:
          dotnet-version: "9.0.x"
      - run: dotnet restore
      - run: dotnet build --no-restore -c Release
      - run: dotnet test --no-build -c Release --logger "trx;LogFileName=results.trx"
            --collect:"XPlat Code Coverage"
            --results-directory coverage
      - run: dotnet tool install -g dotnet-reportgenerator-globaltool
      - run: reportgenerator -reports:coverage/**/coverage.cobertura.xml
            -targetdir:coverage/report -reporttypes:Cobertura

// Category traits — run fast unit tests on every push
[Trait("Category", "Unit")]
public class FastTests { }

[Trait("Category", "Integration")]
public class SlowTests { }

// CI: dotnet test --filter "Category=Unit"           # PR checks (< 2 min)
// CI: dotnet test --filter "Category=Integration"    # nightly + Docker

// Coverage gate — fail below threshold (example: 70% line)
// Quality gate: zero failing tests, no skipped without issue link