Dosaic.Testing.NUnit 1.2.9

Dosaic.Testing.NUnit

A batteries-included meta-package for testing Dosaic-based services. Instead of tracking down individual testing dependencies for every project, add this single package and get a complete, pre-configured testing setup.

Installation

dotnet add package Dosaic.Testing.NUnit

Included Packages

The package also carries transitive project references to Dosaic.Hosting.Abstractions (core plugin interfaces) and Dosaic.DevTools.Seeding (EF Core fake data seeder).

Test Helpers

Usage

FakeLogger<T>

Capture and assert on log entries without a real logging infrastructure.

using Dosaic.Testing.NUnit.Assertions;
using Microsoft.Extensions.Logging;

var logger = new FakeLogger<MyService>();
var service = new MyService(logger);

service.DoSomething();

logger.Entries.Should().ContainSingle(e =>
    e.Level == LogLevel.Information &&
    e.Message.Contains("expected message"));

TestMetricsCollector

Listen to a named System.Diagnostics.Metrics instrument and verify emitted measurements.

using Dosaic.Testing.NUnit;

using var metricsCollector = new TestMetricsCollector("my-metric-name");
metricsCollector.CollectedMetrics.Should().BeEmpty();

// exercise the code under test
await service.ProcessAsync();

metricsCollector.Instruments.Should().Contain("my-metric-name");

// assert a measurement with value 1
metricsCollector.CollectedMetrics.Should().ContainsMetric(1);

// assert with a specific tag
metricsCollector.CollectedMetrics.Should().ContainsMetric(1, "status", "ok");

// assert with multiple tags
metricsCollector.CollectedMetrics.Should().ContainsMetric(
    1,
    new[] { new KeyValuePair<string, string>("status", "ok") });

// sum all measurements (useful for gauges triggered via RecordObservableInstruments)
metricsCollector.RecordObservableInstruments();
metricsCollector.GetSum().Should().Be(42);

ActivityTestBootstrapper

Enable Activity recording in tests (call once, e.g. in [OneTimeSetUp]).

using Dosaic.Testing.NUnit;
using NUnit.Framework;

[SetUpFixture]
public class TestBootstrap
{
    [OneTimeSetUp]
    public void Setup() => ActivityTestBootstrapper.Setup();
}

TestingDefaults

Get a pre-wired ServiceCollection or ServiceProvider including logging and Chronos date-time providers.

using Dosaic.Testing.NUnit;

// obtain a ServiceProvider with defaults
var sp = TestingDefaults.ServiceProvider();

// or start from the collection and register additional services
var sc = TestingDefaults.ServiceCollection();
sc.AddSingleton<IMyService, MyService>();
var provider = sc.BuildServiceProvider();

CustomConfiguration

Build an IConfiguration from key/value pairs without touching the file system.

using Dosaic.Testing.NUnit;

var config = CustomConfiguration.Create()
    .Add("Database:Host", "localhost")
    .Add("Database:Port", "5432")
    .Build();

// use the empty singleton where no config values are needed
IConfiguration empty = CustomConfiguration.Empty;

PluginServiceConfigurationAssertions

Verify that a plugin registers the expected services into the DI container.

using Dosaic.Testing.NUnit.Assertions;

var plugin = new MyPlugin(/* dependencies */);

plugin.ShouldHaveServices(new Dictionary<Type, Type>
{
    { typeof(IMyService), typeof(MyService) },
    { typeof(IMyRepository), null }, // null = only check that it is registered
});

PluginEndpointConfigurationAssertions

Verify that a plugin registers the expected routes and HTTP methods.

using System.Net.Http;
using Dosaic.Testing.NUnit.Assertions;

var plugin = new MyEndpointsPlugin(/* dependencies */);

plugin.ShouldHaveEndpoints(new Dictionary<string, HttpMethod[]>
{
    { "/api/items", new[] { HttpMethod.Get, HttpMethod.Post } },
    { "/api/items/{id}", new[] { HttpMethod.Get, HttpMethod.Put, HttpMethod.Delete } },
});

// retrieve a single endpoint for further assertions
var endpoint = plugin.GetEndpoint(HttpMethod.Get, "/api/items");
endpoint.Should().NotBeNull();

EF Core Assertions (EntityTypeAssertions / DbContextAssertions)

Assert EF Core entity mappings, migration state, and seed data.

using AwesomeAssertions;
using Dosaic.Testing.NUnit.Assertions;

// entity type mapping assertions
var entityType = dbContext.Model.FindEntityType(typeof(Customer))!;

entityType.Should().BeOnTable("public", "customers");
entityType.Should().HavePrimaryKey<Guid>("Id");
entityType.Should().HaveProperty<string>("Name", isNullable: false, maxLength: 200);
entityType.Should().HaveProperty<int>("Age");
entityType.Should().HaveIndex("Email", isUnique: true);
entityType.Should().HaveForeignKey("OrderId", typeof(Order));
entityType.Should().HasCheckConstraint("chk_age", "age > 0");
entityType.Should().HaveData(new[] { new Customer { Id = Guid.Parse("..."), Name = "Seed" } });

// migration assertions (no pending model changes)
dbContext.Should().MatchMigrations<MyDbContext>();

// compiled model assertion
dbContext.Should().MatchCompiledModel(MyCompiledModel.Instance);

TracingAssertions

Verify that a TracerProvider (built during plugin configuration) has registered the correct sources and instrumentations.

using Dosaic.Testing.NUnit.Assertions;

var sc = TestingDefaults.ServiceCollection();
// configure plugin which adds OpenTelemetry tracing
plugin.ConfigureServices(sc);
var sp = sc.BuildServiceProvider();

sp.Should().RegisterSources("MyService.ActivitySource");
sp.Should().RegisterSources(new[] { "Source1", "Source2" });
sp.Should().RegisterInstrumentation<HttpClientInstrumentation>();
sp.Should().RegisterInstrumentation("AspNetCoreInstrumentation");

ArgExt (NSubstitute argument matching with AwesomeAssertions)

Use fluent assertion lambdas as NSubstitute argument matchers.

using Dosaic.Testing.NUnit.Extensions;
using NSubstitute;

var repository = Substitute.For<IOrderRepository>();

await service.PlaceOrderAsync(new Order { CustomerId = 42, Total = 99.99m });

await repository.Received(1).SaveAsync(
    ArgExt.Is<Order>(order =>
    {
        order.CustomerId.Should().Be(42);
        order.Total.Should().Be(99.99m);
    }));

ArchitectureExtensions

Load an Architecture from the calling assembly or a set of specific assemblies for use with ArchUnitNET.

using ArchUnitNET.Fluent;
using ArchUnitNET.Loader;
using Dosaic.Testing.NUnit.Extensions;
using NUnit.Framework;

[TestFixture]
public class ArchitectureTests
{
    private static readonly Architecture _architecture =
        new ArchLoader().FromCurrentAssembly();

    [Test]
    public void ServicesShouldNotDependOnControllers()
    {
        var services = ArchRuleDefinition.Classes()
            .That().ResideInNamespace("MyApp.Services");

        var controllers = ArchRuleDefinition.Classes()
            .That().ResideInNamespace("MyApp.Controllers");

        services.Should().NotDependOnAny(controllers).Check(_architecture);
    }
}

ObjectExtensions

Read private or internal fields and properties by name via reflection (useful when testing internal state without exposing it).

using Dosaic.Testing.NUnit.Extensions;

var service = new MyService();
// access a private field named "_cache"
var cache = service.GetInaccessibleValue<Dictionary<string, object>>("_cache");
cache.Should().BeEmpty();