faysilalshareef/test-fixtures

Test Fixtures — Fakers, Assertions, Helpers

Core Principles

• CustomConstructorFaker<T> bypasses private constructors for test data
• Bogus library generates realistic random data
• Assertion extensions compare entities field-by-field
• Test helpers reduce boilerplate for common operations
• Fakers are reusable across unit and integration tests

Key Patterns

CustomConstructorFaker Base

namespace {Company}.{Domain}.Tests.Common;

public abstract class CustomConstructorFaker<T> : Faker<T> where T : class
{
    protected CustomConstructorFaker()
    {
        CustomInstantiator(_ =>
            (T)RuntimeHelpers.GetUninitializedObject(typeof(T)));
    }
}

Entity Fakers

namespace {Company}.{Domain}.Tests.Fakers;

public sealed class OrderFaker : CustomConstructorFaker<Order>
{
    public OrderFaker()
    {
        RuleFor(o => o.Id, f => f.Random.Guid());
        RuleFor(o => o.CustomerName, f => f.Person.FullName);
        RuleFor(o => o.Total, f => f.Finance.Amount(10, 10000));
        RuleFor(o => o.Sequence, _ => 1);
        RuleFor(o => o.Status, f => f.PickRandom<OrderStatus>());
    }

    public OrderFaker WithStatus(OrderStatus status)
    {
        RuleFor(o => o.Status, _ => status);
        return this;
    }

    public OrderFaker WithSequence(int sequence)
    {
        RuleFor(o => o.Sequence, _ => sequence);
        return this;
    }
}

public sealed class OrderItemFaker : CustomConstructorFaker<OrderItem>
{
    public OrderItemFaker()
    {
        RuleFor(i => i.Id, f => f.Random.Guid());
        RuleFor(i => i.ProductId, f => f.Random.Guid());
        RuleFor(i => i.ProductName, f => f.Commerce.ProductName());
        RuleFor(i => i.Quantity, f => f.Random.Int(1, 100));
        RuleFor(i => i.UnitPrice, f => f.Finance.Amount(1, 500));
    }
}

Event Data Fakers

namespace {Company}.{Domain}.Tests.Fakers;

public sealed class OrderCreatedDataFaker : Faker<OrderCreatedData>
{
    public OrderCreatedDataFaker()
    {
        CustomInstantiator(f => new OrderCreatedData(
            f.Person.FullName,
            f.Finance.Amount(10, 10000),
            new OrderItemDataFaker().Generate(f.Random.Int(1, 5))));
    }
}

public sealed class OrderItemDataFaker : Faker<OrderItemData>
{
    public OrderItemDataFaker()
    {
        CustomInstantiator(f => new OrderItemData(
            f.Random.Guid(),
            f.Commerce.ProductName(),
            f.Random.Int(1, 20),
            f.Finance.Amount(1, 500)));
    }
}

Assertion Extensions

namespace {Company}.{Domain}.Tests.Assertions;

public static class OrderAssertions
{
    public static void AssertCreatedFrom(
        this Order actual, Event<OrderCreatedData> @event)
    {
        actual.Id.Should().Be(@event.AggregateId);
        actual.CustomerName.Should().Be(@event.Data.CustomerName);
        actual.Total.Should().Be(@event.Data.Total);
        actual.Sequence.Should().Be(@event.Sequence);
    }

    public static void AssertUpdatedFrom(
        this Order actual, Event<OrderUpdatedData> @event, Order before)
    {
        actual.Id.Should().Be(before.Id);
        actual.Total.Should().Be(@event.Data.Total);
        actual.Sequence.Should().Be(@event.Sequence);

        if (@event.Data.CustomerName is not null)
            actual.CustomerName.Should().Be(@event.Data.CustomerName);
        else
            actual.CustomerName.Should().Be(before.CustomerName);
    }
}

Test Helpers

namespace {Company}.{Domain}.Tests.Helpers;

public static class DbContextHelper
{
    public static async Task<T?> QueryAsync<T>(
        IServiceProvider sp, Guid id) where T : class
    {
        var db = sp.GetRequiredService<ApplicationDbContext>();
        return await db.Set<T>().FindAsync(id);
    }

    public static async Task InsertAsync<T>(
        IServiceProvider sp, T entity) where T : class
    {
        var db = sp.GetRequiredService<ApplicationDbContext>();
        db.Set<T>().Add(entity);
        await db.SaveChangesAsync(cancellationToken);
    }
}

public static class EventHelper
{
    public static Event<T> CreateEvent<T>(T data, Guid? aggregateId = null,
        int sequence = 1) where T : IEventData => new()
    {
        AggregateId = aggregateId ?? Guid.NewGuid(),
        Sequence = sequence,
        Type = typeof(T).Name.Replace("Data", ""),
        DateTime = DateTime.UtcNow,
        Version = 1,
        Data = data
    };
}

Anti-Patterns

| Anti-Pattern | Correct Approach | |---|---| | Manual test data construction | Use Bogus fakers for realistic data | | Duplicating assertion logic | Create reusable assertion extensions | | Fakers with hardcoded values | Use Bogus generators for randomness | | Missing builder/fluent API on fakers | Add WithXxx methods for customization |

Detect Existing Patterns

# Find CustomConstructorFaker
grep -r "CustomConstructorFaker" --include="*.cs" tests/

# Find Bogus fakers
grep -r ": Faker<\|: CustomConstructorFaker" --include="*.cs" tests/

# Find assertion extensions
grep -r "AssertCreatedFrom\|AssertEquality\|AssertUpdatedFrom" --include="*.cs" tests/

# Find test helpers
grep -r "DbContextHelper\|EventHelper" --include="*.cs" tests/

Adding to Existing Project

1. Locate CustomConstructorFaker<T> base class and extend it
2. Follow existing faker naming: {Entity}Faker, {EventData}Faker
3. Add assertion extensions in Assertions/ folder
4. Reuse existing test helpers for DB and event operations
5. Add WithXxx fluent methods for test-specific customization