Fixture never creates the triggering condition

What goes wrong

A branch only runs when the data holds some particular condition, and no fixture ever produces it, so the branch is never executed by any test. The suite passes on the paths around it and is read as covering the rule itself. What is trusted is green tests, when the evidence is only that the condition was never built.

Example

The rule that rejects a record with a missing rate has tests, but every test record carries a rate, so deleting the rejection entirely leaves the suite green.

Not to be confused with

Not Test Data Too Small To Tell, where the data does reach the behaviour but is too thin to distinguish right from wrong answers; here the behaviour is never reached at all.

Discovered by

@sks24git GitHub

Field notes · 28

@sks24git2026-11-06beat 1 review round

A test made the database throw on every read, but the first read swallowed its own error and returned empty. The function quit early, so the guard under test never ran, and deleting it kept the test green.

Fail the read the guard actually wraps. Let earlier reads succeed, then break the one after.
Assert the test reached the guard. A count of calls proves the path ran.

@sks24git2026-11-06beat 5 review rounds

The tests ran on an in-memory database that hands back structured fields as text, while the real one hands them back parsed. Only the text branch was tested; break the other and production reads every field as empty.

Test the shape production sends, not only the fake's. A green fake proves the branch it takes.
Pin the keep case, not just the drop case. A filter that drops everything passes drop-only tests.

@sks24git2026-11-04

A status summary is tested on the full case only: all items present and fresh. The zero-items case and the partly-expired case render through branches no test reaches.

Test zero, one, many and partly stale. Summaries break at the edges, not the middle.

@sks24git2026-11-04

A parser guards against output with no answer line, but every test fixture includes one. The guard branch never runs in tests, so a broken guard ships unnoticed.

Add a fixture for each guard's trigger. A guard no fixture reaches is untested code.

@sks24git2026-11-04

A cache stores a computed number and also remembers when there is nothing to compute. Only the hit is tested, so a change that stops caching the empty case brings back the slow path unnoticed.

Test the cached "nothing" as well as the cached value. Negative caching is half the win.

@sks24git2026-11-04

Code ships behind a switch that is off by default, and its edge rules only run when the switch is on. Reviews find the gaps, but nothing fails until someone flips it in production.

Run the test suite with every new switch on. Off-by-default code is untested code.

@sks24git2026-11-04

A setting adds a branch to a dispatch rule, and no test turns the setting on. Delete the branch and the suite stays green, so the setting can quietly stop working.

Every new setting gets a test that turns it on. Defaults-only suites never reach the branch.
Assert the effect, not the flag. Reading the flag back proves nothing.

@sks24git2026-11-04

A date filter checks the input's shape with a pattern, so a month of 13 passes and becomes an invalid date. Only one later check stops it from crashing the formatter, and no test reaches that check.

Validate dates by parsing, not by shape. A pattern accepts impossible days and months.
Test the guard you rely on with the input it guards. An untested last line of defence gets deleted.

@sks24git2026-11-04

Dead code gets deleted and its tests move onto the live page, but one test guarded a slot that only the old layout reused. On the new page that slot never swaps, so the moved test passes whatever the code does.

Re-read each moved test against the new layout. A guard for a vanished case stays green and proves nothing.

@sks24git2026-11-04

A loop guard falls back to blocking when its storage is unavailable, yet no test ever makes that storage fail. Flip the fallback by mistake and every test stays green while users without storage reload forever.

Test the branch where the guard's own state is missing. That fallback is the only thing between a user and an endless loop.

@sks24git2026-11-02beat 1 review round

A cleanup that closes a half-started job row was tested only by an error raised after the row was already closed. Delete the cleanup and the test stays green, while real early failures leave rows open forever.

Raise the error where the state is still dirty. A test that fails after cleanup already ran proves nothing.
Close records through the shared helper. Ad-hoc updates skip its events.

@sks24git2026-11-02beat 1 review round

A rename was applied to two lists, but the regression test only planted the old name in one of them. Dropping the rename from the second list left every test green.

Plant the bad value in every place the fix touches. A test that seeds one path proves nothing about the rest.

@sks24git2026-11-01beat 1 review round

A page split its check in two: entries already closed were judged up front, and only a race reached the branch for entries closed mid-write. No test hit that branch, so dropping it brought back a silent success.

Send it all to the one locked decider. Two paths to one outcome leave one untested.
Test the outcome, not a race. A branch only a race reaches is not covered.

@sks24git2026-11-01beat 1 review round

A new early gate answered one case before the old code path ran, and the old test of that path kept passing against the gate. Delete the guard deep in the old path and every test stays green.

When you add a gate in front of a path, re-aim the path's tests. A test that stops at the new gate no longer guards the old code behind it.

@sks24git2026-10-30beat 4 review rounds

A brief section was made unconditional, but every test seeded the history that used to trigger it. Gate it on history again and the section quietly vanishes from every first run while the suite stays green.

Test the case a change made new. Old fixtures cover the old path, not the one you opened.
Seed nothing when you test always. A default fixture can hide the bare case.

@sks24git2026-10-28beat 1 review round

A default was switched off, and the tests guarding the other side of the switch kept passing without reaching the gates behind it. Switch it back on and a broken gate floods the user, with every test green.

Pin the switch on in tests of the gated path. A test that never reaches the gate guards nothing.
Run a mutant after a flag flip. It shows which tests went hollow.

@sks24git2026-10-26

A test named for the over-the-cap split left fewer items inside the searched range than the cap, so the split never ran. Drop half of the split and the suite stays green while the sensor silently loses items.

Make the fixture cross the threshold you test. Count what lands in range, not what you generate.
Put the expected hit in the half a mutation would drop. Otherwise the mutation survives.

@sks24git2026-10-25beat 1 review round

A spec promised each rotated alarm links to its predecessor via a helper that only links tickets with the same key. The key is built from the list contents, so it never repeats and no link is ever written.

Trace the helper a SHALL names. A requirement is only as true as that code path.
Grep before you label FACT. A false fact leaves its test without evidence.

@sks24git2026-10-24

A strict expected-failure test reused a shared first step that read one more input than the test sent. It failed on that missing input before reaching the defect it tracked, so fixing the defect would never turn it red.

Make an expected-failure test prove its own reason. Run it once with expected failures off and read the error.
Copy shared fixtures you mutate. A popped list empties what the assertion reads.

@sks24git2026-10-24

A deep link was marked as handled before the lookup ran, so a miss on a stale cached copy used it up. When fresh data arrived with the item, the page kept saying it did not exist.

Mark a request done only on success. A miss on stale data must stay open for the fresh answer.
Test stale-then-fresh renders. Cache-first screens hide bugs a cold start never shows.