Helpers Tested, Entry Point Untested

What goes wrong

Every helper function has unit tests, but nothing ever runs the entry point — the route, the main function, the component, or the pipeline definition — that calls them together in production. The call can be deleted, its arguments swapped, or its exit code lost while all helper tests stay green.

Example

The date-parsing hook has twenty tests, but the component that should call it was refactored and no longer does; the suite is green.

Not to be confused with

The untested part is the connection between tested pieces; a test that never reaches its branch is Unreached Branch Test, and raw SQL never executed is Raw SQL Never Executed In Tests.

Discovered by

@sks24git GitHub

Field notes · 89

@sks24git2026-11-06

A header middleware was tested on a fresh toy app, never on the real one. Delete the one line that mounts it and every test stays green while each response loses its no-index and referrer rules.

Test wiring on the real app. A middleware unit test proves the function, not that anything calls it.
Cover every branch of an allow-list. One untested branch can drop a section from search.

@sks24git2026-11-05

A guard function had unit tests, but the one line that called it at startup had none. Delete that line and every test stays green while the guard never runs.

Test the wiring, not only the function. A green unit test says nothing about whether the check runs.
Drive one real run through the real entry point. That is the test a deleted call breaks.

@sks24git2026-11-04

A fix moved a count into a pure helper and tested only the helper, not the screen that calls it. Put the old count back at the call site and every test stays green while the screen shows the wrong number.

Aim the mutant at the line users see. A green helper test says nothing about the call site.
Compare two rules value by value. Equal totals hide different sets.

@sks24git2026-11-03beat 1 review round

A check held two constants to the CI limits, but nothing held the wait loop to those constants. Put a literal back in the loop and the real wait shrinks while every check stays green.

Pin the use, not just the value. A guard on a constant proves nothing once the code that should read it stops reading it.

@sks24git2026-11-03beat 3 review rounds

A fix for a request that crashed on a dropped database link was tested by calling the error helper directly. A regression on the real path, where cleanup touches the dead link again, stays green.

Test a crash fix at the layer that crashed. The helper passing alone says nothing about the teardown around it.

@sks24git2026-11-02beat 2 review rounds

A race fix moved a check under the row lock, and its test called the locked helper directly. Put the early read back in the request handler and every test stays green while the race reopens.

Test a race fix through the entry point users hit. A test of the helper proves the helper, not the caller.
Keep a guard's test on the layer that owns it.

@sks24git2026-10-31beat 4 review rounds

Tests fed a page a hand-made open-on-load flag, so the route code that reads it from the address never ran. Break that route glue and the chat button lands on a page with the form closed, while every test stays green.

Test the entry point, not a stand-in for it. A hand-built context hides the code that builds it.
Name tests after what they really run. A test named for the address must load the address.

@sks24git2026-10-31

A new setting was read at one layer and passed down a call chain, but each test checked a single hop on its own. Drop the value at the middle hop and every test stays green while the setting changes nothing.

Test the whole path once. One test that sets the value at the top and reads it at the bottom catches a dropped hop.

@sks24git2026-10-29beat 3 review rounds

The shutdown fix is tested only through helpers each test wires by hand; nothing checks that the real entry file calls them. Delete that one call and every test stays green while deploys drop connections again.

Pin the entry-file call, not just the helper. A helper test proves the helper, never that production uses it.

@sks24git2026-10-29

A fix moved one admin page onto its own capped connection pool, but the pool came in as an optional argument that fell back to the old one. Revert the line that passes it and every test stays green.

Test the wiring, not only the parts. A default argument hides a missing hand-off.
Give every factory the same guard test. A second constructor skips what the first has.

@sks24git2026-10-28beat 2 review rounds

A feature's only delivery point to the user was one join in the runner, and every test stopped at the dict one layer above it. Delete the join and the feature vanishes with the suite still green.

Test the last hop, not the data that feeds it. A test that stops a layer short proves the plumbing, not the delivery.

@sks24git2026-10-27

A new screen's deep link ran through a route param, but every test rendered the screen with a ready id instead of opening the route. Break the hand-off and the suite stays green while the link shows a placeholder.

Test the entry, not just the room. Helpers stay covered while the route to them is not.
Copy the sibling's router tests. A cloned route needs the cloned test lines.

@sks24git2026-10-25

A new watchdog flagged any change request as stuck after an hour without a commit, but review and automated fix steps in the same pipeline take longer than that by design. Every healthy request would raise a paid alert.

Calibrate a stall threshold against the pipeline's own timeouts. Shorter than a normal step means false alarms.
Exclude known-busy states before timing silence. Quiet is not stuck.

@sks24git2026-10-25beat 1 review round

A list check ran one slow remote call per item, in a row, under one short deadline, and a timed-out check read as "no access". Big lists lost the very items the user could open, and the page called itself complete.

Keep "said no" apart from "did not answer". Folding a timeout into a refusal hides data and lies about it.
Price the loop against its deadline. Serial calls times items must fit the budget.

@sks24git2026-10-25

A list helper cut each source to its first thirty items and never said it had cut anything. A member who could read only items past the cut saw an empty list with no note, as if nothing were installed.

Return the cut with the data. A cap the caller cannot see turns "truncated" into "empty".
Filter after you page, not before. Capping before the access check hides exactly what passes it.

@sks24git2026-10-23

A new pause setting silenced a reminder on one response, but the same reminder rode a second response that never read the setting. The user paused it and kept seeing it after every confirmed result.

List every place a message shows before you add a switch for it. A switch on one of two places is a bug.
Test each place with the switch on. Only one was driven.

@sks24git2026-10-23

A new node that cannot reach the shared store sets up an empty local one, and that leaves behind the very file the join check skips on. Every later boot skips the join, and the node idles for good.

Never let a fallback write the flag that gates the retry. Check for what you need, not a side effect.
On a fresh node, exit and retry, don't improvise. A restart retries; a fallback sticks.

@sks24git2026-10-23

A new route with a fixed path segment sat where an older route takes a path parameter. The older route registers first, so every call to the new path lands in the wrong handler and is refused.

Check new paths against parameter routes of the same shape. The router takes the first match.
Spec the rounding rule. Rounded lines rarely sum to the rounded total.

@sks24git2026-10-21

A test double answered every request by its path alone and never read the body it was sent. A renamed field or a flipped sign on a debt balance passed every test, and only the real server would have refused it.

Make a fake reject what the real server rejects. A double that accepts any body hides contract drift until production.

@sks24git2026-10-21

Tests drove a retry worker by hand and only checked its captured flag in one state. Drop the worker's start hook or hardcode the flag, and every test stays green while records stop retrying.

Start the real background loop in one test. Driving a worker by hand never proves it runs.
Test every value of a flag you capture. One state lets a hardcoded default pass.