Integration Testing

Doing it the right way

A comprehensive guide to effective integration testing

Welcome

This presentation will guide you through best practices for integration testing

🚀 Ready to learn?

My Story

How I came to Integration Testing

A personal journey through challenges and solutions

The Starting Point

📊 Integration Testing against central infrastructure

Example: Elasticsearch

  • Central test infrastructure for all teams
  • Shared Elasticsearch instance
  • All developers use the same environment

The Success

✅ Automated Integration Tests

Complete functionality ensured

  • Tests against central test infrastructure
  • High confidence in functionality
  • Automated validation of all features

The Problems

⚠️ Increasing load and latency

  • Local Development: Every developer tests against central infrastructure
  • Pull Requests: CI/CD pipeline increases load
  • UI Tests: Frontend tests add additional load

🚨 Result: High latencies and unstable tests

The Quest for Solutions

🔍 How can the load be reduced?

This question led to a comprehensive analysis of integration testing strategies...

→ That's the reason for this presentation!

What We'll Cover

  • Understanding Integration Testing
  • Best Practices & Strategies
  • Tools & Frameworks
  • Real-world Examples
  • Common Pitfalls to Avoid

Testing Types Overview

Let's explore different types of testing and how they fit together

Understanding the landscape helps us make better testing decisions

Unit Testing

🔬 Definition

Testing individual components or functions in isolation

📝 Characteristics

  • Fast execution (milliseconds)
  • No external dependencies
  • High test coverage possible
  • Easy to debug failures

✅ When to Use

Business logic, algorithms, data transformations, utility functions

Integration Testing

🔗 Definition

Testing the interaction between integrated components or services

📝 Characteristics

  • Moderate execution time (seconds)
  • Tests component boundaries
  • Verifies data flow between modules
  • Can use test doubles or real dependencies

✅ When to Use

API integrations, database interactions, message queues, service boundaries

System Testing

🏗️ Definition

Testing the complete integrated system against requirements

📝 Characteristics

  • Tests entire application flow
  • Production-like environment
  • All components working together
  • Performance and reliability focus

✅ When to Use

Complete workflows, system requirements validation, performance testing

End-to-End Testing

🌐 Definition

Testing complete user scenarios from start to finish

📝 Characteristics

  • User perspective testing
  • Real environment simulation
  • Cross-system interactions
  • Longest execution time

✅ When to Use

Critical user journeys, business process validation, acceptance testing

UI Testing

🎨 Definition

Testing user interface behavior and visual elements

📝 Characteristics

  • Browser/device specific
  • Visual and interaction testing
  • Can be brittle and slow
  • Covers user experience

✅ When to Use

User interface flows, accessibility, responsive design, visual regression

The Testing Pyramid

🏔️ Classic Approach

Testing Pyramid

💡 Key Principles

  • Many Unit Tests: Fast, cheap, reliable foundation
  • Some Integration Tests: Verify component interactions
  • Few E2E Tests: Cover critical user journeys

The Testing Diamond

💎 Modern Alternative

Testing Diamond

🎯 Focus Areas

  • Integration Tests: Primary focus for microservices
  • Contract Testing: Service boundary verification
  • Balanced Approach: Adapts to architecture

Alternative Approaches

🔄 Testing Trophy

Emphasizes integration tests for web applications

⚖️ Testing Honeycomb

Flexible approach based on context and risk

🎯 Key Insight

Choose the approach that fits your architecture, team, and risk profile

Integration Testing in Context

🎯 Where Integration Testing Shines

  • Microservices: Service-to-service communication
  • APIs: Contract validation and data flow
  • Databases: Data persistence and retrieval
  • Third-party Services: External integrations

⚡ Benefits

  • Catches interface mismatches
  • Validates assumptions between components
  • Faster feedback than E2E tests
  • More realistic than unit tests

TestContainers.NET

🐳 What is TestContainers.NET?

A .NET library that provides lightweight, throwaway instances of common databases, message brokers, and other services wrapped in Docker containers.

✨ Key Benefits

  • Isolation: Each test gets a fresh environment
  • Consistency: Same environment across all machines
  • Realistic: Tests against real dependencies

Setting Up TestContainers.NET

📦 1. Install NuGet Package


# Core package
dotnet add package Testcontainers

# Database-specific packages
dotnet add package Testcontainers.PostgreSql
dotnet add package Testcontainers.MsSql
dotnet add package Testcontainers.Redis

⚙️ 2. Basic Configuration

TestContainers requires Docker to be running on your machine. It automatically manages container lifecycle during tests.

Code Example

🧪 PostgreSQL Integration Test


[Test]
public async Task DatabaseIntegrationTest()
{
    // Arrange
    await using var container = new PostgreSqlBuilder()
        .WithImage("postgres:15-alpine")
        .WithDatabase("testdb")
        .WithUsername("testuser")
        .WithPassword("testpass")
        .WithPortBinding(5432, true)
        .Build();

    await container.StartAsync();

    var connectionString = container.GetConnectionString();
    
    // Act
    await using var connection = new NpgsqlConnection(connectionString);
    await connection.OpenAsync();
    
    var command = new NpgsqlCommand("SELECT 1", connection);
    var result = await command.ExecuteScalarAsync();

    // Assert
    Assert.That(result, Is.EqualTo(1));
}

Advanced Example

🏗️ Test Fixture with Setup


public class DatabaseTestFixture : IAsyncLifetime
{
    private PostgreSqlContainer _container;
    public string ConnectionString { get; private set; }

    public async Task InitializeAsync()
    {
        _container = new PostgreSqlBuilder()
            .WithImage("postgres:15-alpine")
            .WithDatabase("testdb")
            .WithUsername("testuser")
            .WithPassword("testpass")
            .WithWaitStrategy(Wait.ForUnixContainer()
                .UntilPortIsAvailable(5432))
            .Build();

        await _container.StartAsync();
        ConnectionString = _container.GetConnectionString();
        
        // Run database migrations
        await RunMigrations();
    }

    public async Task DisposeAsync()
    {
        await _container.DisposeAsync();
    }
    
    private async Task RunMigrations() { /* ... */ }
}

Key Considerations

⚡ Build Agent Resources

  • • Ensure Docker is available on CI/CD agents
  • • Allocate sufficient memory (containers + tests)
  • • Consider parallel test execution limits
  • • Monitor disk space for container images

🐳 Docker Environment

  • • Use lightweight images (alpine variants)
  • • Configure wait strategies for container readiness
  • • Set appropriate timeouts for slow environments
  • • Clean up containers after test completion

TestContainers.NET Best Practices

💡 Optimization Tips

  • Share Containers: Use test fixtures for expensive setups
  • Fast Images: Prefer Alpine or minimal base images
  • Wait Strategies: Implement proper readiness checks
  • Cleanup: Always dispose containers properly

✅ Result: Isolated, reliable, and maintainable integration tests

Best Practices

🎯 Strategic Guidelines

  • Start with Unit Tests: Build a solid foundation
  • Focus on Integration: Test the boundaries that matter
  • Minimize E2E: Only for critical user journeys
  • Adapt to Context: Architecture drives testing strategy

💡 Remember

The goal is confidence in your system, not perfect test coverage

Thank You!

Questions & Discussion