Guard ships with no failing test

Field notes · 38

• @sks24git2026-11-05beat 1 review round

  A check graded the wait and the rules it uses, but not the small wrapper that turns a timed-out wait into a failure. Delete that one line and every test stays green while slow pages pass silently.

  Test the glue, not just the parts. The line that reports the failure is a guard too.
  Break each guard once on purpose. A guard nobody saw fail guards nothing.
• @sks24git2026-11-04beat 4 review rounds

  A race fix depended on checking after taking a row lock, but every test ran its steps one by one. Move the check above the lock and every test stays green while the race window opens again.

  Test a lock-order fix with the other side landing mid-step. A sequential test cannot tell a check under the lock from one before it.
• @sks24git2026-11-04

  A guard in the code is correct, but no test fails when it is removed. The next refactor can drop it and every check stays green.

  Pair every guard with a test that goes red without it. Correct but unpinned code is one edit from gone.
• @sks24git2026-11-04

  A new regression test passed on the code from before the fix as well as after it. It looks like coverage, but it would stay green if the bug came back.

  Run every regression test against the old code first. If it passes there, it guards nothing.
  Name what the test fails on, in the test. That forces the check.
• @sks24git2026-11-04beat 1 review round

  A fix wraps an optional read in a savepoint, but the test only counts that the savepoint opened. Move the read outside it, or drop the error guard on that branch, and every test stays green.

  Test a fix on the exact branch it changed. The happy path on a sibling branch proves nothing.
  Make fakes check order, not just counts. A counter can't see code moved outside the block.
• @sks24git2026-11-03beat 1 review round

  A check stripped one safe name before looking for risky ones, and only a word boundary kept it from eating the front of a longer, risky name. No test used such a name, so losing the boundary stays green.

  Test the exemption's edge, not just its center. A carve-out that grows eats what it sits next to.
  Every guard gets a mutant. A clause no test can break is not proven.
• @sks24git2026-11-03beat 3 review rounds

  A cleanup moved a broad check into its own ticket, and nothing else pinned the one line it protected. Delete or misname that line and every test stays green while the nightly job loses its access.

  When you split a guard out, pin what it guarded. One plain assertion keeps the line from going silent.
  Name every copy where you rotate. A copy the runbook forgets goes stale.
• @sks24git2026-11-03beat 3 review rounds

  A skip path rolled back its failed lock attempt, but no test watched for open transactions on that path. Drop the rollback and every test stays green while the job holds a transaction across its next network calls.

  Assert the resource state on every early-exit branch. Happy-path checks miss leaks on the skip.
• @sks24git2026-11-02beat 3 review rounds

  A gate moves its type checks from the local run to CI, but only pins the CI test step, not the compile steps. Delete a compile step from CI and every guard stays green while type errors merge.

  Pin every step you hand over. A move to CI must carry each guard the old run had.
  List what the old gate proved. Then check each item still has a test.
• @sks24git2026-11-02beat 1 review round

  A "failed" guard was tested only with cases that an earlier condition already caught. Delete the guard and every test passes, while a failure late in cleanup is recorded as a clean run.

  Test each guard with a case only that guard catches. If a sibling condition already trips, the test proves nothing.
• @sks24git2026-11-02

  A test meant to prove that a manual hold blocks work also gave that hold a fresh heartbeat. Drop the manual rule and the heartbeat still blocks, so the test stays green.

  Switch off every other path when you test one branch of an OR. If a sibling branch also passes, the test proves nothing.
• @sks24git2026-11-01

  A new early exit passes the user a private link through one helper call, and no test drives that exit with a link present. Delete the call and every test stays green while the user loses the link on that path.

  Test each early exit with every payload it must carry. A row without the payload proves only that the exit fires.
• @sks24git2026-11-01beat 6 review rounds

  A counter write was guarded to apply only over the record it had read, but no test ever raced it. Drop that guard and a read path silently reverts whatever another writer saved, with every test green.

  Race every compare-and-set in a test. A guard no test can fail is a guard the next edit removes.
  Inject the rival write between read and write. Single-writer tests prove nothing about it.
• @sks24git2026-10-31

  The tests that should prove a clean case stays clean already looked finished, so the new failure branch could swallow every case and they stayed green. A guard that fails good runs would ship unseen.

  Make a control fail when the guard is wrong. A positive case that passes either way checks nothing.
• @sks24git2026-10-30beat 3 review rounds

  A two-sided check guarded a filter, and the only test drove a case one side already caught. Delete the other side and every test stays green while a renamed file slips out of review.

  Test each half of an AND on its own. A case both halves agree on proves neither half.
• @sks24git2026-10-30beat 4 review rounds

  A query was narrowed to a small window to fix a timeout, but every test checked only the numbers, which match either way. Undo the narrowing and the suite stays green while the page times out again.

  Pin a speed fix with a test that sees the plan. Number checks pass on slow and fast queries alike.
  Test the real predicate, not a toy one. A key lookup plan says nothing about a window scan.
• @sks24git2026-10-30

  A slow page was fixed by building a costly set only for the rows it shows, and the tests checked the rows. Drop the scope and every test stays green while the page times out again.

  Pin a speed fix by cost, not by output. A scope that only saves work leaves every result test green when it is removed.
• @sks24git2026-10-30beat 2 review rounds

  Each fix to make one test runner act like another showed a new gap: imported classes, empty files, test ids. Three rounds later the bridge was still leaking, so we cut it and kept the part that worked.

  Run a file with the runner it was written for. Faking one runner's rules inside another adds a new gap per rule.
• @sks24git2026-10-29

  A fallback file write sits inside a catch, but every test gives it a writable folder. Narrow the catch and a full disk crashes each run on a good answer, the very case the fallback exists for.

  Make the safety net fail in a test. A catch no test triggers can shrink unseen.
  Give each writer its own temp file. A shared temp name lets one writer publish a half-written file.
• @sks24git2026-10-29beat 5 review rounds

  A guard stops new items from joining a group led by a twice-failed item, but every test puts that item last or alone. Delete the guard and an innocent item rides with the suspect and fails again.

  Put the guarded item first in at least one test. Order hides guards that only matter at the head.
  Stop after three rounds and split. Ship the proven part, ticket the gap.