Aspire Integration Testing

Write integration tests for .NET Aspire applications with test containers

Category: development Source: Aaronontheweb/dotnet-skills

Aspire Integration Testing is a development skill for testing .NET Aspire applications, covering test container setup, service validation, and end-to-end verification

What Is This?

Overview

Aspire Integration Testing enables developers to write comprehensive integration tests for .NET Aspire applications using test containers. This skill focuses on validating multi-service architectures by spinning up containerized dependencies in isolated test environments. You learn to verify service interactions, database connections, messaging systems, and API endpoints without manual infrastructure setup.

The approach leverages Testcontainers to manage container lifecycles automatically during test execution. Tests run against real service instances rather than mocks, providing confidence that your distributed application components work together correctly in production-like conditions. This method ensures that your tests are as close to real-world scenarios as possible, catching integration issues that unit tests or mocked environments might miss. By using containers, you can simulate complex environments, including multiple databases, message brokers, and external APIs, all within your test suite.

Who Should Use This

Backend developers building microservices with .NET Aspire, QA engineers automating service validation, and DevOps professionals ensuring application reliability benefit most from this skill. Anyone testing containerized .NET applications will find practical value here. Teams adopting microservices or distributed architectures will especially benefit, as integration points between services are often the source of subtle bugs and failures. This skill is also valuable for developers who want to ensure their code works seamlessly with real infrastructure components, not just in isolated unit tests.

Why Use It?

Problems It Solves

Manual integration testing requires spinning up multiple services, databases, and message brokers before running tests. This creates friction, slows feedback loops, and makes tests unreliable. Aspire Integration Testing automates container orchestration, eliminating setup complexity and ensuring tests run consistently across environments.

Traditional integration tests often depend on shared staging environments, which can be unstable or unavailable. With Aspire Integration Testing, each test run provisions its own isolated environment, reducing flakiness and making tests more deterministic. This approach also helps teams catch configuration drift and environment-specific bugs early in the development cycle, before they reach production.

Core Highlights

Test containers automatically provision and tear down service dependencies for each test run. You validate real service interactions without mocking away critical integration points. Tests execute in isolated environments preventing data pollution and cross test contamination. Integration tests become fast, repeatable, and suitable for continuous integration pipelines.

By using containerized dependencies, you can easily test against different versions of databases or message brokers, ensuring compatibility and smooth upgrades. The automation of environment setup and teardown also means less manual intervention and fewer errors due to misconfigured test environments.

How to Use It?

Basic Usage

[Test]
public async Task ServiceIntegrationTest()
{
    var container = new PostgresBuilder()
        .WithImage("postgres:latest")
        .Build();
    
    await container.StartAsync();
    var connectionString = container.GetConnectionString();
    // Use connectionString to interact with the database in your tests
}

Real-World Examples

Testing a database backed service with Aspire:

[Test]
public async Task ValidateOrderServiceWithDatabase()
{
    var postgres = new PostgresBuilder().Build();
    await postgres.StartAsync();
    
    var orderService = new OrderService(postgres.GetConnectionString());
    var result = await orderService.CreateOrderAsync(new Order { Id = 1 });
    Assert.That(result.Success, Is.True);
}

Testing message broker integration:

[Test]
public async Task ValidateMessagePublishing()
{
    var rabbitmq = new RabbitMqBuilder().Build();
    await rabbitmq.StartAsync();
    
    var publisher = new EventPublisher(rabbitmq.GetConnectionString());
    await publisher.PublishAsync(new OrderCreatedEvent { OrderId = 123 });
    // Optionally, consume the message to verify delivery
}

Advanced Tips

Compose multiple containers in a single test by creating a custom fixture that orchestrates all dependencies together, reducing duplication across test files. Use container wait strategies to ensure services are fully healthy before running assertions, preventing flaky tests from premature execution. You can also use network aliases to simulate real service discovery, and configure environment variables or secrets for your containers to match production setups.

When to Use It?

Use Cases

Validating that your API correctly persists data to PostgreSQL or SQL Server before returning responses to clients. Testing event publishing workflows where services communicate through RabbitMQ or Azure Service Bus. Verifying cache invalidation logic by running Redis alongside your application code. Ensuring database migrations execute successfully and your application handles schema changes gracefully. Aspire Integration Testing is also useful for validating authentication flows, third-party API integrations, and multi-service orchestration logic.