RepletoryLib.Testing 1.0.0

RepletoryLib.Testing

Unit testing infrastructure with mock services, assertion extensions, and in-memory database factory.

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

Overview

RepletoryLib.Testing provides a TestBase class and pre-built mock implementations for unit testing applications built with the RepletoryLib ecosystem. It includes mocks for caching, messaging, user context, tenant context, and date/time, plus FluentAssertions extensions for the Result<T> pattern and an EF Core in-memory database factory.

Key Features

• TestBase -- Base class with pre-configured DI container and all mocks ready
• MockCacheService -- In-memory cache with call tracking (GetCalls, SetCalls, RemoveCalls)
• MockMessagePublisher -- Records published messages with type-safe querying
• MockCurrentUserService -- Configurable user context (ID, name, roles, permissions, tenant)
• MockCurrentTenantService -- Configurable tenant context
• MockDateTimeProvider -- Controllable time with Advance() and SetUtcNow()
• ResultAssertionExtensions -- FluentAssertions for Result<T> (BeSuccess(), BeFailure(), etc.)
• InMemoryDbContextFactory<T> -- Creates isolated in-memory EF Core databases per test

Installation

dotnet add package RepletoryLib.Testing

Dependencies

Quick Start

using RepletoryLib.Testing;

public class OrderServiceTests : TestBase
{
    [Fact]
    public async Task CreateOrder_publishes_event_and_caches_result()
    {
        Setup();
        Services.AddTransient<OrderService>();

        var provider = BuildServiceProvider();
        var service = provider.GetRequiredService<OrderService>();

        var result = await service.CreateOrderAsync(new Order { Total = 100m });

        result.Should().BeSuccess();
        MockPublisher.GetPublished<OrderCreatedEvent>().Should().HaveCount(1);
        MockCache.SetCalls.Should().HaveCount(1);
    }
}

Usage Examples

TestBase Setup

TestBase provides a ServiceCollection, mock instances, and a BuildServiceProvider() method:

public class MyServiceTests : TestBase
{
    [Fact]
    public async Task My_test()
    {
        Setup(); // Initialize mocks and service collection

        // Configure mocks
        MockUser.UserId = "user-123";
        MockUser.Permissions.Add("orders.create");
        MockTenant.TenantId = Guid.NewGuid();
        MockDateTime.SetUtcNow(new DateTime(2025, 1, 1));

        // Register your services
        Services.AddTransient<MyService>();

        // Build and resolve
        var provider = BuildServiceProvider();
        var service = provider.GetRequiredService<MyService>();

        // Act and assert
        var result = await service.DoWorkAsync();
        result.Should().BeSuccess();
    }
}

MockCacheService

[Fact]
public async Task Service_caches_result()
{
    Setup();
    Services.AddTransient<ProductService>();
    var provider = BuildServiceProvider();
    var service = provider.GetRequiredService<ProductService>();

    // Pre-populate cache
    await MockCache.SetAsync("product:123", new Product { Name = "Widget" });

    var result = await service.GetProductAsync(Guid.Parse("...123..."));

    // Assert cache interactions
    MockCache.GetCalls.Should().Contain("product:123");
    MockCache.SetCalls.Should().HaveCount(0); // Cache hit, no new set

    // Reset for next test
    MockCache.Reset();
}

MockMessagePublisher

[Fact]
public async Task Order_creation_publishes_event()
{
    Setup();
    Services.AddTransient<OrderService>();
    var provider = BuildServiceProvider();
    var service = provider.GetRequiredService<OrderService>();

    await service.CreateOrderAsync(new Order { Id = Guid.NewGuid(), Total = 500m });

    // Query by message type
    var events = MockPublisher.GetPublished<OrderCreatedEvent>();
    events.Should().HaveCount(1);
    events.First().Total.Should().Be(500m);

    // Query by type and exchange
    var notifications = MockPublisher.GetPublished<OrderNotification>("notifications");
    notifications.Should().HaveCount(1);

    // Total count
    MockPublisher.PublishedCount.Should().Be(2);
}

MockCurrentUserService

[Fact]
public async Task Admin_can_delete_orders()
{
    Setup();
    MockUser.UserId = "admin-001";
    MockUser.UserName = "Admin";
    MockUser.Permissions.Add("orders.delete");
    MockUser.RolesSet.Add("Admin");
    MockUser.TenantId = Guid.NewGuid();

    Services.AddTransient<OrderService>();
    var provider = BuildServiceProvider();
    var service = provider.GetRequiredService<OrderService>();

    // HasPermission("orders.delete") returns true
    var result = await service.DeleteOrderAsync(orderId);
    result.Should().BeSuccess();
}

MockDateTimeProvider

[Fact]
public async Task Subscription_expires_correctly()
{
    Setup();
    MockDateTime.SetUtcNow(new DateTime(2025, 1, 1));

    Services.AddTransient<SubscriptionService>();
    var provider = BuildServiceProvider();
    var service = provider.GetRequiredService<SubscriptionService>();

    var sub = await service.CreateTrialAsync();
    sub.ExpiresAt.Should().Be(new DateTime(2025, 1, 31));

    // Advance time by 32 days
    MockDateTime.Advance(TimeSpan.FromDays(32));

    var isValid = await service.IsValidAsync(sub.Id);
    isValid.Should().BeFalse();
}

Result Assertion Extensions

[Fact]
public async Task Returns_not_found_for_missing_order()
{
    Setup();
    Services.AddTransient<OrderService>();
    var provider = BuildServiceProvider();
    var service = provider.GetRequiredService<OrderService>();

    var result = await service.GetOrderAsync(Guid.NewGuid());

    result.Should().BeFailure()
        .And.HaveStatusCode(404)
        .And.HaveError("not found");
}

[Fact]
public async Task Returns_order_on_success()
{
    // ...
    var result = await service.GetOrderAsync(existingId);

    result.Should().BeSuccess()
        .And.HaveData(expectedOrder);
}

InMemoryDbContextFactory

[Fact]
public async Task Repository_persists_entity()
{
    var factory = new InMemoryDbContextFactory<AppDbContext>();
    var context = factory.Create(); // Unique isolated DB each call

    context.Products.Add(new Product { Name = "Widget", Price = 9.99m });
    await context.SaveChangesAsync();

    var found = await context.Products.FirstOrDefaultAsync();
    found.Should().NotBeNull();
    found!.Name.Should().Be("Widget");
}

API Reference

TestBase Members

Result Assertions

Integration with Other RepletoryLib Packages

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.