Testing the HTTP Layer

An in-process test client builds a request in memory and hands it to the framework's dispatcher, then captures the response as an object. No socket and no port: the call is an ordinary method call in the test process.

Call the hook directly with a hand-built request and a recording stub in place of the next element. The stub captures whether it was invoked and with which request, so the test can assert delegation without starting a server.

It proves only the handler body: its branches, its return value, its exceptions. Route matching, request binding, the hook chain, response serialisation and status or header mapping never run, because no framework was started.

Contribute a replacement registration for that boundary into the configuration the container reads, so the graph is built with the stand-in. Constructing it by hand affects only your own object, not the one the framework injects into handlers.

Injecting a test principal hands the request an identity directly, skipping credential extraction, decoding, signature and expiry checks. Tests whose subject is one of those steps must send a real credential through the chain instead.

Everything below the dispatcher: connection setup and reuse, TLS, byte-level request parsing and response framing, listener-enforced timeouts, socket backpressure, and whatever a proxy in front adds. A server bound to an ephemeral port runs all of it.

Assert that the stub standing in for the next element recorded zero invocations, that the headers the chosen status implies are present, and that no downstream side effect ran. A status alone does not prove the chain stopped.

A slice runs the real routing, binding, hook chain and response mapping, so it proves the route matches, the request binds, and the status, headers and serialised body match the contract. A direct call touches none of that.

Because wiring mostly resolves once. Single-instance dependencies are constructed and handed to their consumers while the graph is built, so a later edit to the registry changes only lookups that still happen, not references already injected.

Several layers can produce that status: an identity that never attached, a missing fixture, an overlapping route, or a broad error mapper flattening an unrelated failure. Pin the body's error code and pair the case with a positive control.

Send requests that deliberately miss the routing table: a path no template matches, and a known path with an undeclared method. Assert the exact status for each, the contracted error body, and the header the protocol requires.

In-process clients normally collect the whole response and return when the handler finishes, so flush boundaries, time-to-first-byte and backpressure are invisible, and a listener-enforced timeout has no connection to fire on. The assertion passes without the behaviour existing.

Assemble the chain through the application's own registration code, ending it with an element that only returns an empty success, and have each hook append a label before and after delegating. Compare the recorded sequence with the expected one.

A profile is a named run mode that gates registrations. Under it the fake's registration is a candidate and the real one is conditioned out, so the graph builds with the fake — provided the run truly activated that profile.

Force the failure at a replaced collaborator so a handler throws something nothing maps, then assert the response: the contracted status, the published error body with its code and correlation identifier, and no exception type, message or stack anywhere in it.

Because an in-process test supplies the connection facts itself, it only confirms your assumption about the deployment. Reproduce over a real listener configured the way production is, with the terminator in front, and assert on what an external client sees.

The stand-in for the rest of the chain returns without writing anything, so the hook's late header write always succeeds. Make it write a status and body before returning, as the real downstream does, and the test reproduces the loss.

The slice supplied a test double where production must build a real collaborator, so that collaborator's construction, configuration and registration were never exercised. Add a test that boots the whole application on real wiring, faking only true externals.

The replacement outlived the test that asked for it — usually a cached graph built with one test's overrides handed to later tests, or a registry mutated at runtime and never restored. Scope replacements to a wiring; reset stand-in state.

Harnesses cache a booted graph keyed by its configuration, and each distinct override set is a distinct key, so a unique set per test forces a boot per test. Collapse onto a few shared wirings instead.

Put the bulk in-process, where cases cost fractions of a millisecond, and reserve wire tests for fault classes only a connection can reveal - framing, TLS, timing, cancellation, proxy trust - one case per class rather than per route.

Treat each replacement as a piece of the real graph the suite stops exercising. Budget them, review additions like production configuration, and keep at least one tier that boots the unmodified wiring so startup faults still have somewhere to surface.

Push case volume down to handler calls, which cost nothing; assert each route's contract once in a slice, whose cost is per configuration; spend the full stack on proving the real graph builds. Steer by which faults escape.