ASP.NET Web API (.NET Framework) · Quality & Delivery

Integration Testing

Unit tests check pieces; integration tests check the whole request pipeline — routing, model binding, validation, filters and JSON — exactly as a client sees it. OWIN’s TestServer runs it all in memory.

Advanced 6 min Lesson 31 of 36Covers ASP.NET Web API 2.2 on .NET Framework 4.8.

Before you start:Unit Testing

0/36 in ASP.NET Web API

On this page · 6 min · Advanced

Interview questions

Learning objectives#

Host Web API 2 in memory with Microsoft.Owin.Testing
Send real HTTP requests from tests
Check status codes and JSON bodies
Decide what belongs in integration vs unit tests

Explanation#

Install Microsoft.Owin.Testing and Microsoft.AspNet.WebApi.Owin in the test project. TestServer.Create<Startup>() builds the OWIN pipeline in memory — no ports, no IIS.

The test Startup creates an HttpConfiguration, calls your real WebApiConfig.Register (or the same steps) and app.UseWebApi(config).

_server.HttpClient sends real HTTP requests through routing, model binding, Data Annotations validation, filters and formatters.

ReadAsAsync<T>() and PostAsJsonAsync() (from Microsoft.AspNet.WebApi.Client) make JSON easy in tests.

Point data access at a test database (LocalDB, a Docker SQL Server) or swap repositories for in-memory ones via your DI container. Reset data between tests so they stay independent.

Integration tests are slower than unit tests; use them for the contract (URLs, status codes, JSON shape), and unit tests for detailed logic.

Syntax#

C# Illustrative

1using (var server = TestServer.Create<TestStartup>())
2{
3    var response = await server.HttpClient.GetAsync("/api/products/1");
4    Assert.Equal(HttpStatusCode.OK, response.StatusCode);
5}

Code example: In-memory tests through the full pipeline#

C#ProductsApiTests.cs Illustrative

1using System;
2using System.Collections.Generic;
3using System.ComponentModel.DataAnnotations;
4using System.Net;
5using System.Net.Http;
6using System.Threading.Tasks;
7using System.Web.Http;
8using Microsoft.Owin.Testing;
9using Owin;
10using Xunit;
11using ShopApi.Models;
12

13// ── API code ──
14public class CreateProductRequest
15{
16    [Required] public string Name { get; set; }
17    [Range(1, 100000)] public decimal Price { get; set; }
18}
19

20public class ProductsController : ApiController
21{
22    private static readonly Dictionary<int, ProductDto> Store = new Dictionary<int, ProductDto>
23    {
24        [1] = new ProductDto { Id = 1, Name = "Pen", Price = 20m },
25    };
26

27    [HttpGet, Route("api/products/{id:int}")]
28    public IHttpActionResult Get(int id)
29    {
30        ProductDto product;
31        return Store.TryGetValue(id, out product) ? (IHttpActionResult)Ok(product) : NotFound();
32    }
33

34    [HttpPost, Route("api/products")]
35    public IHttpActionResult Post(CreateProductRequest request)
36    {
37        if (request == null || !ModelState.IsValid) return BadRequest(ModelState);
38        return Created("api/products/2", new ProductDto { Id = 2, Name = request.Name, Price = request.Price });
39    }
40}
41

42// ── Test host ──
43public class TestStartup
44{
45    public void Configuration(IAppBuilder app)
46    {
47        var config = new HttpConfiguration();
48        config.MapHttpAttributeRoutes();     // in a real project: WebApiConfig.Register(config);
49        app.UseWebApi(config);
50    }
51}
52

53// ── Tests ──
54public class ProductsApiTests : IDisposable
55{
56    private readonly TestServer _server = TestServer.Create<TestStartup>();
57

58    public void Dispose() => _server.Dispose();
59

60    [Fact]
61    public async Task Get_ExistingProduct_Returns200WithJson()
62    {
63        var response = await _server.HttpClient.GetAsync("/api/products/1");
64

65        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
66        var product = await response.Content.ReadAsAsync<ProductDto>();
67        Assert.Equal("Pen", product.Name);
68    }
69

70    [Fact]
71    public async Task Get_NonNumericId_Returns404FromRouting()
72    {
73        var response = await _server.HttpClient.GetAsync("/api/products/abc");
74        Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
75    }
76

77    [Fact]
78    public async Task Post_MissingName_Returns400FromValidation()
79    {
80        var response = await _server.HttpClient.PostAsJsonAsync("/api/products", new { Price = 10 });
81        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
82    }
83

84    [Fact]
85    public async Task Post_Valid_Returns201WithLocation()
86    {
87        var response = await _server.HttpClient.PostAsJsonAsync("/api/products", new { Name = "Bag", Price = 650 });
88        Assert.Equal(HttpStatusCode.Created, response.StatusCode);
89        Assert.EndsWith("api/products/2", response.Headers.Location.ToString());
90    }
91}

Expected output

dotnet test runs the four tests against an in-memory server: Passed! - Failed: 0, Passed: 4, Skipped: 0, Total: 4. The 404 comes from the {id:int} route constraint and the 400 from real Data Annotations validation — neither would be exercised by a unit test.

This example is illustrative. Copy or download it and run it in your own environment; the expected output is shown above.

Step-by-step explanation#

TestStartup configures Web API exactly as the real app does, and UseWebApi plugs it into OWIN.
TestServer.Create<TestStartup>() hosts it in memory; each test class instance gets a fresh server.
GetAsync and PostAsJsonAsync send real HTTP messages through routing, binding and validation.
ReadAsAsync<ProductDto>() deserialises the JSON response, so the test checks the real wire format.
Dispose shuts the server down after each test.

Real-world use case#

Before upgrading Json.NET or Web API packages, a team runs 120 integration tests that pin down every URL, status code and JSON property name. Any accidental contract change fails the build.

Common mistakes#

Sharing state between tests

Tests that depend on data created by earlier tests fail randomly when run in a different order. Reset or isolate data per test.

Testing against production databases

Never. Use LocalDB, a container or in-memory repositories.

Duplicating every unit test as an integration test

Integration tests are slower. Focus them on the HTTP contract and wiring.

Best practices#

Reuse the real WebApiConfig in the test Startup
Assert on status codes, headers and JSON shape
Isolate test data
Run integration tests in CI after unit tests

Remember this#

TestServer.Create<Startup>() = the whole API in memory.

Integration tests check routing, binding, validation and JSON together.

Unit tests for logic; integration tests for the contract.

Practice exercise#

Your task: Add an integration test proving that a request with an Accept: application/json header returns Content-Type application/json.

Need a hint?

Create an HttpRequestMessage, add the Accept header, send with _server.HttpClient.SendAsync, and check response.Content.Headers.ContentType.MediaType.

Show solution

C# Illustrative

1using System.Net.Http;
2using System.Net.Http.Headers;
3using System.Threading.Tasks;
4using System.Web.Http;
5using Microsoft.Owin.Testing;
6using Owin;
7using Xunit;
8

9public class PingController : ApiController
10{
11    [HttpGet, Route("api/ping")]
12    public IHttpActionResult Get() => Ok(new { pong = true });
13}
14

15public class PingStartup
16{
17    public void Configuration(IAppBuilder app)
18    {
19        var config = new HttpConfiguration();
20        config.MapHttpAttributeRoutes();
21        app.UseWebApi(config);
22    }
23}
24

25public class ContentTypeTests
26{
27    [Fact]
28    public async Task Ping_WithJsonAccept_ReturnsJson()
29    {
30        using (var server = TestServer.Create<PingStartup>())
31        {
32            var request = new HttpRequestMessage(HttpMethod.Get, "/api/ping");
33            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
34

35            var response = await server.HttpClient.SendAsync(request);
36

37            Assert.Equal("application/json", response.Content.Headers.ContentType.MediaType);
38        }
39    }
40}

Mini quiz#

Integration Testing quizMultiple choice Question 1 of 3

Which package hosts a Web API 2 pipeline in memory for tests?

Score so far: 0/0

Want more? Practise all ASP.NET Web API MCQs · ASP.NET Web API interview questions

My notes#

Saved in this browser.

Progress is saved in this browser. Sign in to sync.

On this page

Related tutorials

Interview questions

Learning objectives#

Explanation#

Syntax#

Code example: In-memory tests through the full pipeline#

Step-by-step explanation#

Real-world use case#

Common mistakes#

Best practices#

Remember this#

Practice exercise#

Mini quiz#

Related topics#

My notes#