xUnit.net

public class PricingTests
{
    [Fact]
    public void An_empty_basket_costs_nothing()
    {
        Assert.Equal(0, new Basket().TotalCents);
    }

    // A theory is a parameterised test; each row is reported separately.
    [Theory]
    [InlineData(12_000, 2_400)]
    [InlineData(10_000, 2_000)]   // the boundary
    [InlineData(9_999, 0)]
    public void Discount_applies_at_or_above_the_threshold(int subtotal, int expected)
    {
        var result = Pricing.ApplyDiscount(new Order(subtotal), new DiscountPolicy(10_000, 20));

        Assert.Equal(expected, result.DiscountCents);
    }

    // MemberData when the cases are not compile-time constants.
    public static IEnumerable<object[]> ShippingCases =>
    [
        [CustomerTier.Standard, 395],
        [CustomerTier.Gold, 0]
    ];

    [Theory]
    [MemberData(nameof(ShippingCases))]
    public void Shipping_depends_on_tier(CustomerTier tier, int expectedCents)
    {
        Assert.Equal(expectedCents, Shipping.For(new Customer(tier)).Cents);
    }
}

public class OrderRepositoryTests : IAsyncLifetime
{
    private NpgsqlConnection _connection = null!;
    private NpgsqlTransaction _transaction = null!;

    public async Task InitializeAsync()
    {
        _connection = new NpgsqlConnection(TestDatabase.ConnectionString);
        await _connection.OpenAsync();
        _transaction = await _connection.BeginTransactionAsync();
    }

    // Rolled back, never committed: perfect isolation, no cleanup code.
    public async Task DisposeAsync() => await _transaction.RollbackAsync();
}

// One container for the whole class.
public sealed class PostgresFixture : IAsyncLifetime
{
    private readonly PostgreSqlContainer _container =
        new PostgreSqlBuilder().WithImage("postgres:16-alpine").Build();

    public string ConnectionString => _container.GetConnectionString();

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

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

public class OrderRepositoryTests(PostgresFixture fixture) : IClassFixture<PostgresFixture>
{
    [Fact]
    public async Task Round_trips_money_without_losing_precision() { /* ... */ }
}

// One container shared by many classes.
[CollectionDefinition("database")]
public class DatabaseCollection : ICollectionFixture<PostgresFixture>;

[Collection("database")]
public class CustomerRepositoryTests(PostgresFixture fixture) { }

// Opt a set of classes into running sequentially by naming a collection.
[Collection("Sequential")]
public class MigrationTests { }

<!-- xunit.runner.json / csproj -->
<PropertyGroup>
  <ParallelizeTestCollections>true</ParallelizeTestCollections>
  <MaxParallelThreads>4</MaxParallelThreads>
</PropertyGroup>

// xUnit built-in
Assert.Equal(2_400, result.DiscountCents);
Assert.Contains(order.Lines, l => l.Sku == "book-1");
await Assert.ThrowsAsync<InsufficientStockException>(() => service.ReserveAsync(order));

// FluentAssertions — better failure messages, worth the dependency
result.DiscountCents.Should().Be(2_400);
order.Lines.Should().ContainSingle(l => l.Sku == "book-1");
await service.Invoking(s => s.ReserveAsync(order))
             .Should().ThrowAsync<InsufficientStockException>()
             .WithMessage("*book-1*");

// Skip with a reason — it shows up in the report rather than vanishing.
[Fact(Skip = "ENG-4412: flaky under parallel load, owner @sam, review 2026-10-15")]

// Traits for filtering: dotnet test --filter "Category=Integration"
[Trait("Category", "Integration")]

// Output that appears in the test report, not the console.
public class MyTests(ITestOutputHelper output)
{
    [Fact] public void Thing() => output.WriteLine("diagnostic");
}