Integration Tests with WebApplicationFactory

using System.ComponentModel.DataAnnotations;
using Microsoft.AspNetCore.Http.HttpResults;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddProblemDetails();
builder.Services.AddValidation();
builder.Services.AddSingleton<OrderStore>();

var app = builder.Build();
app.UseExceptionHandler();
app.UseStatusCodePages();

var orders = app.MapGroup("/orders");

orders.MapGet("/{id:int}", Results<Ok<OrderResponse>, ProblemHttpResult> (int id, OrderStore store) =>
    store.Find(id) is { } order
        ? TypedResults.Ok(order)
        : TypedResults.Problem(title: "Order not found", statusCode: StatusCodes.Status404NotFound));

orders.MapPost("/", (PlaceOrder request, OrderStore store) =>
{
    var order = store.Add(request.CustomerId, request.Quantity * 34.50m);
    return TypedResults.Created($"/orders/{order.Id}", order);
});

app.Run();

public sealed record PlaceOrder([Required, MinLength(1)] string CustomerId, [Required] string Sku, [Range(1, 20)] int Quantity);
public sealed record OrderResponse(int Id, string CustomerId, decimal Total, string Status);

public sealed class OrderStore
{
    private readonly Dictionary<int, OrderResponse> _orders = new() { [1042] = new(1042, "CUST-17", 69.00m, "Paid") };
    private int _nextId = 2000;

    public OrderResponse? Find(int id)
    {
        lock (_orders) return _orders.GetValueOrDefault(id);
    }

    public OrderResponse Add(string customerId, decimal total)
    {
        lock (_orders)
        {
            var order = new OrderResponse(++_nextId, customerId, total, "Pending");
            _orders[order.Id] = order;
            return order;
        }
    }
}

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <OutputType>Exe</OutputType>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <IsPackable>false</IsPackable>
    <UseMicrosoftTestingPlatformRunner>true</UseMicrosoftTestingPlatformRunner>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="xunit.v3" Version="4.0.2" />
    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="10.0.13" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="..\..\src\Shop.Api\Shop.Api.csproj" />
  </ItemGroup>

</Project>

using System.Net;
using System.Net.Http.Json;
using Microsoft.AspNetCore.Mvc.Testing;
using Microsoft.Extensions.DependencyInjection;
using Xunit;

public sealed class CancelOrderTests(WebApplicationFactory<Program> factory) : IClassFixture<WebApplicationFactory<Program>>
{
    [Fact]
    public async Task Cancelling_a_paid_order_marks_it_cancelled_and_queues_a_refund()
    {
        // Resolve app services from the test host; scoped ones need a scope.
        int orderId;
        using (var scope = factory.Services.CreateScope())
        {
            var store = scope.ServiceProvider.GetRequiredService<IOrderStore>();
            orderId = store.Add(new Order(0, "CUST-17", 129.90m, "Paid"));
        }

        using var client = factory.CreateClient(new WebApplicationFactoryClientOptions { AllowAutoRedirect = false });
        using var response = await client.PostAsync($"/orders/{orderId}/cancel", null, TestContext.Current.CancellationToken);

        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
        var body = await response.Content.ReadFromJsonAsync<Order>(TestContext.Current.CancellationToken);
        Assert.Equal("Cancelled", body!.Status);

        var refunds = factory.Services.GetRequiredService<IRefundQueue>();
        Assert.Contains(refunds.Pending, r => r.OrderId == orderId && r.Amount == 129.90m);
    }
}

public sealed record Order(int Id, string CustomerId, decimal Total, string Status);
public sealed record Refund(int OrderId, decimal Amount);
public interface IOrderStore { int Add(Order order); }
public interface IRefundQueue { IReadOnlyCollection<Refund> Pending { get; } }

// Stand-in so this file compiles on its own. Delete it in a real test project: in .NET 10 the API's
// generated Program is already public, and a Program declared here would shadow it (CS0436).
public partial class Program;