How to Perform Integration Testing in ASP.NET Core Applications?

Introduction

When building modern web applications using ASP.NET Core, testing is a critical part of development. While unit testing checks individual components, it does not guarantee that all parts of the application work correctly together.

This is where Integration Testing comes into the picture.

In simple words, integration testing ensures that multiple components of your ASP.NET Core application (such as controllers, services, databases, and APIs) work together as expected.

In this article, we will understand what integration testing is, why it is important, and how to perform integration testing in ASP.NET Core step by step using simple language and practical examples.

What is Integration Testing?

Integration testing is a type of testing where different parts of an application are tested together as a group.

Instead of testing a single method or class, integration testing checks the flow of the entire system.

Example:

API endpoint → Service layer → Database

All components are tested together.

Simple explanation:

Unit Test → Tests small parts
Integration Test → Tests complete flow

Why is Integration Testing Important?

Integration testing helps ensure that:

APIs return correct responses
Database operations work properly
Dependencies are correctly configured
Real-world scenarios work as expected

Real-world example:

If your login API works in unit testing but fails when connected to the database, integration testing will catch that issue.

Tools Used for Integration Testing in ASP.NET Core

Common tools include:

xUnit (testing framework)
Microsoft.AspNetCore.Mvc.Testing
TestServer (in-memory server)
Entity Framework Core (InMemory or SQLite)

These tools help simulate real application behavior.

Step-by-Step Guide to Integration Testing in ASP.NET Core

Let’s implement integration testing step by step.

Step 1: Create Test Project

Create a new test project in your solution.

Example:

Project Name: MyApp.Tests

Install required packages:

dotnet add package xunit
dotnet add package Microsoft.AspNetCore.Mvc.Testing

Step 2: Use WebApplicationFactory

WebApplicationFactory helps create an in-memory test server.

Example:

using Microsoft.AspNetCore.Mvc.Testing;

public class CustomWebApplicationFactory : WebApplicationFactory<Program>
{
}

This allows you to test your application without running it manually.

Step 3: Write a Basic Integration Test

using System.Net.Http;
using System.Threading.Tasks;
using Xunit;

public class WeatherTests : IClassFixture<CustomWebApplicationFactory>
{
    private readonly HttpClient _client;

    public WeatherTests(CustomWebApplicationFactory factory)
    {
        _client = factory.CreateClient();
    }

    [Fact]
    public async Task GetWeather_ReturnsSuccess()
    {
        var response = await _client.GetAsync("/weatherforecast");

        response.EnsureSuccessStatusCode();
    }
}

This test checks if the API endpoint works correctly.

Step 4: Test with Database

You can use an in-memory database for testing.

Example:

services.AddDbContext<AppDbContext>(options =>
    options.UseInMemoryDatabase("TestDb"));

This ensures tests do not affect real database.

Step 5: Seed Test Data

Add sample data for testing.

Example:

context.Users.Add(new User { Name = "Test User" });
context.SaveChanges();

This helps simulate real scenarios.

Step 6: Validate API Response

[Fact]
public async Task GetUsers_ReturnsData()
{
    var response = await _client.GetAsync("/api/users");
    var content = await response.Content.ReadAsStringAsync();

    Assert.Contains("Test User", content);
}

This ensures correct data is returned.

Real-World Example

Imagine an e-commerce application.

Integration testing checks:

Add to cart API
Payment processing
Order creation

All components work together.

Without integration testing:

APIs may fail in production

With integration testing:

Issues are caught early

Advantages of Integration Testing

Ensures complete system works correctly
Detects real-world issues
Improves application reliability
Builds confidence before deployment

Disadvantages of Integration Testing

Slower than unit tests
Requires setup (database, server)
More complex to write

Best Practices for Integration Testing

Use in-memory database
Keep tests independent
Use realistic test data
Clean up after tests
Run tests in CI/CD pipeline

When Should You Use Integration Testing?

Use integration testing when:

Testing API endpoints
Validating database operations
Checking service interactions

Avoid relying only on unit tests for complete system validation.

Summary

Integration testing in ASP.NET Core is essential for ensuring that all components of your application work together correctly. It helps detect issues that unit tests cannot find and ensures your APIs, services, and database interactions function properly.

By using tools like WebApplicationFactory, TestServer, and in-memory databases, you can write effective integration tests and build reliable, production-ready applications.