Implementation Stubbed Everywhere

What goes wrong

Every test that would reach a piece of code — an API client, a database writer, a mapper — replaces it with a mock or hand-written output, so the real body (its URL, its field mapping, its filter) is executed by no test at all and can do something else while every test stays green.

Example

The HTTP client is mocked in every test; the real client has a typo in the payments URL and the first request to hit it is in production.

Not to be confused with

The component itself has no test that runs it; not components that are tested with only their wiring untested (Helper Only Wiring Proof), not raw SQL never executed (SQL Without Executing Proof), and not an expected value copied from the code under test (Self Derived Expected Value).

Discovered by

@sks24git GitHub

Field notes · 9

@sks24git2026-10-30beat 1 review round

A process scan matches on a name column that the system cuts short when more columns follow. The check finds no processes at all, so the guard it feeds never fires, and every test stays green on a fake list.

Run each detector once on the real machine. A seam can hide a probe that sees nothing.
Print what a guard found, not just its verdict. Zero matches should look odd.

@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-23

Tests swapped the real rule modules for stand-ins; the real ones landed later with other parameter keys and a required hook. The suite stayed green while one client type was always blocked and the other crashed.

Retire a stand-in the day the real module lands. A stub keeps passing after the contract it copied moves.
Run each seam once against the real callee. One real call catches drift no stub can.

@sks24git2026-10-15

A helper that computes a diff base was replaced by a stub in every test, so its real logic never ran. A regression to the wrong base would pass the suite and feed the reviewer a wrong diff.

Run each stubbed helper for real at least once. A stub in every test proves the callers, not the helper.

@sks24git2026-09-11beat 1 review round

A 14-day sum was computed inline beside its 30-day twin, and the test only checked that a 20-day-old row was absent. Any window from 14 to 19 days passed, and the ≥ marker and the unknown branch ran under no test at all.

Pin a window on both edges. A row on the last covered day and one on the first uncovered day kill every off-by-N.
Extract a rule used twice and test it pure. Inline copies drift and hide.

@sks24git2026-09-10beat 1 review round

One job took the same lock twice while the test counted a single wait. Worst-case waits summed past the job timeout, so the cleanup half could be cut off by the very lock it was waiting for.

Sum every wait on the path against the timeout, not the longest one.
A test that counts one occurrence cannot see the second.

@sks24git2026-09-08

A form serializer test drove only the checked arm of a new checkbox, and the unchecked arm silently dropped the field. Every save with the box off wrote the old value back while the tests stayed green.

Drive both arms of every boolean through the serializer. The arm nobody tests is the one that ships wrong.

@sks24git2026-09-08beat 2 review rounds

Labels were asserted on rows the test inserted by hand. That pins the reader's mapping and never the statements that CHOOSE the label, so swapping one leaves every test green.

Drive a label through the path that writes it. A hand-seeded row tests your reader, never your writer.
Assert where a wrong answer differs — at zero, every wrong formula passes.

@sks24git2026-09-02beat 1 review round

A watcher had two reasons to stop a run and reported both through one callback with no argument, so the caller wrote one label for either. A run killed for sitting idle was then explained as a spend ceiling.

If a function knows the reason, it must hand it over. "Obvious from context" is one call site away from a lie.
Pin the line that writes a label, not only the one that reads it.