Component Testing

// C#, xUnit + WebApplicationFactory. The real app, real middleware,
// real routing, real DI — with the outbound gateway swapped for a stub.
public class OrdersApiTests : IClassFixture<ApiFactory>
{
    private readonly HttpClient _client;
    private readonly FakePaymentGateway _payments;

    public OrdersApiTests(ApiFactory factory)
    {
        _payments = factory.Payments;
        _client = factory.CreateClient();
    }

    [Fact]
    public async Task Placing_an_order_persists_it_and_returns_its_location()
    {
        var response = await _client.PostAsJsonAsync("/orders",
            new { sku = "book-1", quantity = 2, cardToken = "tok_ok" });

        Assert.Equal(HttpStatusCode.Created, response.StatusCode);
        Assert.NotNull(response.Headers.Location);

        // Read it back through the API, not the database: the test asserts
        // on the contract, so an internal schema change does not break it.
        var order = await _client.GetFromJsonAsync<OrderView>(response.Headers.Location);
        Assert.Equal(2, order!.Quantity);
        Assert.Equal("reserved", order.Status);
    }

    [Fact]
    public async Task A_declined_card_returns_402_and_leaves_no_order()
    {
        _payments.DeclineNext();     // the failure a real gateway will not give you

        var response = await _client.PostAsJsonAsync("/orders",
            new { sku = "book-1", quantity = 1, cardToken = "tok_declined" });

        Assert.Equal(HttpStatusCode.PaymentRequired, response.StatusCode);
        Assert.Empty(await _client.GetFromJsonAsync<OrderView[]>("/orders"));
    }
}

public class ApiFactory : WebApplicationFactory<Program>, IAsyncLifetime
{
    private readonly PostgreSqlContainer _db =
        new PostgreSqlBuilder().WithImage("postgres:16-alpine").Build();

    public FakePaymentGateway Payments { get; } = new();

    public Task InitializeAsync() => _db.StartAsync();

    protected override void ConfigureWebHost(IWebHostBuilder builder) =>
        builder.ConfigureTestServices(services =>
        {
            services.RemoveAll<IPaymentGateway>();
            services.AddSingleton<IPaymentGateway>(Payments);   // only the boundary is faked
            services.Configure<DbOptions>(o => o.ConnectionString = _db.GetConnectionString());
        });
}

# Python, pytest + FastAPI. Same shape: real app, stubbed boundary.
@pytest.fixture
def client(postgres_url, monkeypatch):
    monkeypatch.setenv("DATABASE_URL", postgres_url)
    app.dependency_overrides[get_payment_gateway] = lambda: FakeGateway()
    with TestClient(app) as client:
        yield client
    app.dependency_overrides.clear()

def test_placing_an_order_returns_201_and_a_location(client):
    response = client.post("/orders", json={"sku": "book-1", "quantity": 2})

    assert response.status_code == 201
    assert client.get(response.headers["location"]).json()["status"] == "reserved"

// TypeScript, supertest + Express/Fastify. No listening port needed.
import request from 'supertest';

it('rejects an order for a SKU that does not exist', async () => {
  await request(app)
    .post('/orders')
    .send({ sku: 'nope', quantity: 1 })
    .expect(422)
    .expect(({ body }) => expect(body.error).toMatch(/unknown sku/i));
});