What does a web-layer slice test that boots the router and hooks with services replaced prove that a direct handler call cannot?

## What a slice actually boots A web-layer **slice** is a partial start-up of the framework: enough of it to serve a request end to end through the HTTP machinery, and no more. Typically that means the route table, the request-binding layer, the hook or middleware chain, error translation, and the response writer — while the services the handler depends on are replaced with test doubles. Frameworks differ in how the boundary is drawn: some let you name a single handler and load only what it needs, others start the whole application and swap components inside it, and the narrower the slice, the faster it starts and the more of the real chain it omits. The test then feeds a request into that machinery and asserts on the **response**, not on a returned value. That single change of subject is what buys the extra evidence. ## What the slice proves and the direct call cannot - **Route matching** — this path template and this method reach this handler, and win against any overlapping route. - **Binding** — a path value, a query value, a header, and a body payload arrive as the arguments the handler declares, with the right types and the right treatment of absent values. - **Declarative validation** — rules applied before the body is entered actually reject what they claim to reject, producing the rejection response rather than an entry into the handler. - **The hook chain** — the hooks configured for this route run, in order, and contribute what they are supposed to contribute. - **Status mapping** — the handler's result becomes the intended status code, including the difference between a created resource, an empty result and a domain error. - **Headers** — content type, caching, location, and anything a hook attaches. - **Serialisation** — the payload's field names, nesting and omissions as a client would parse them, which is the part most likely to drift from the contract silently. A compact way to say it: the direct call tests the code you **wrote**, and the slice tests the code you **declared**. Route templates, binding rules, validation constraints and response metadata are declarations, and only something that reads them can prove them. ## The price | Tier | What starts | Typical assertions | Dominant cost | |---|---|---|---| | Direct handler call | Nothing | Returned value, raised error | A function call | | Router-and-hooks slice | Routing, binding, hooks, response writing | Status, headers, serialised body | One framework start per configuration | | Full stack on real wiring | The whole application graph | The same, plus that the real graph builds | A full start, plus real resources | The slice's cost is **fixed per configuration, not per test**. One booted slice usually serves every test in a class or suite, so the second hundred tests are nearly free while the first one is not. That is why churn in the slice's configuration — a different set of replaced services per test — is the thing that actually makes a suite slow: each distinct configuration is another start-up. ## What the slice still cannot see The replacement that makes the slice fast is also its blind spot. Below the double there is nothing: no real implementation, no configuration it would have read, and crucially **no proof that a real implementation is registered at all**. A slice is perfectly happy to supply a collaborator the real application has never been able to build. It also proves nothing about behaviour that only appears when several components interact for real — a transaction that must span two of them, a serialiser configured globally at start-up in a way the slice did not reproduce. ## Choosing the assertions 1. Assert the **contract**, not the plumbing: status, the headers a client acts on, and the payload's shape. Those are what break other people's code. 2. Assert **one** route's behaviour per test, so a failure names the route. 3. Keep the number of distinct slice configurations small, because each one is a start-up. 4. Resist re-testing branch logic here; those cases belong one tier down, where they cost nothing. The slice is the tier that earns its keep on most services: it is the cheapest place where the request looks like a request and the response looks like a response, which is exactly where HTTP-layer defects live.