RepletoryLib.Testing.Fixtures 1.0.0

RepletoryLib.Testing.Fixtures

Integration testing infrastructure with Testcontainers for SQL Server, PostgreSQL, Redis, and RabbitMQ.

Part of the RepletoryLib ecosystem -- standalone, reusable .NET 10 libraries with zero business logic.

Overview

RepletoryLib.Testing.Fixtures provides Testcontainer-based fixtures for integration testing. Each fixture manages a real Docker container (SQL Server, PostgreSQL, Redis, or RabbitMQ) and exposes the connection string for use in tests. The FullStackFixture starts all containers in parallel for full-stack integration testing.

Key Features

• SqlServerFixture -- SQL Server 2022 container
• PostgresFixture -- PostgreSQL 16 container
• RedisFixture -- Redis 7 container
• RabbitMqFixture -- RabbitMQ 3 container with management UI
• FullStackFixture -- All containers started in parallel
• IntegrationTestBase -- Combines TestBase mocks with real infrastructure
• xUnit integration -- IAsyncLifetime for automatic container lifecycle

Installation

dotnet add package RepletoryLib.Testing.Fixtures

Dependencies

Prerequisites

• Docker must be running on the host machine

Usage Examples

Single Fixture (SQL Server Only)

using RepletoryLib.Testing.Fixtures;

public class OrderRepositoryTests : IClassFixture<SqlServerFixture>
{
    private readonly SqlServerFixture _fixture;

    public OrderRepositoryTests(SqlServerFixture fixture) => _fixture = fixture;

    [Fact]
    public async Task Can_persist_and_retrieve_order()
    {
        var options = new DbContextOptionsBuilder<AppDbContext>()
            .UseSqlServer(_fixture.ConnectionString)
            .Options;

        using var context = new AppDbContext(options);
        await context.Database.EnsureCreatedAsync();

        context.Orders.Add(new Order { Total = 100m });
        await context.SaveChangesAsync();

        var orders = await context.Orders.ToListAsync();
        orders.Should().HaveCount(1);
    }
}

Full Stack Integration Test

using RepletoryLib.Testing.Fixtures;

public class OrderWorkflowTests : IntegrationTestBase, IClassFixture<FullStackFixture>
{
    public OrderWorkflowTests(FullStackFixture fixture) : base(fixture) { }

    protected override void ConfigureServices(IServiceCollection services)
    {
        services.AddDbContext<AppDbContext>(options =>
            options.UseSqlServer(SqlServerConnectionString));
    }

    [Fact]
    public async Task Complete_order_workflow()
    {
        MockUser.UserId = "user-001";
        MockDateTime.SetUtcNow(new DateTime(2025, 6, 15));

        var provider = BuildServiceProvider();
        var db = provider.GetRequiredService<AppDbContext>();
        await db.Database.EnsureCreatedAsync();

        // Test against real SQL Server, mocked cache/messaging
        db.Orders.Add(new Order { Total = 250m });
        await db.SaveChangesAsync();

        var count = await db.Orders.CountAsync();
        count.Should().Be(1);
    }
}

Available Connection Strings in IntegrationTestBase

Individual Fixtures

// Redis only
public class CacheTests : IClassFixture<RedisFixture>
{
    public CacheTests(RedisFixture fixture) { }
}

// PostgreSQL only
public class PgTests : IClassFixture<PostgresFixture>
{
    public PgTests(PostgresFixture fixture) { }
}

// RabbitMQ only
public class MessagingTests : IClassFixture<RabbitMqFixture>
{
    public MessagingTests(RabbitMqFixture fixture) { }
}

Container Images

API Reference

FullStackFixture

All containers start in parallel via Task.WhenAll() and stop in parallel during disposal.

Integration with Other RepletoryLib Packages

Troubleshooting

License

This project is licensed under the MIT License.

Copyright (c) 2024-2026 Repletory.

For complete documentation, infrastructure setup, and configuration reference, see the RepletoryLib main repository.