Cursor rule

1---
2description: "Test-driven development with red-green-refactor loop using vertical slices. Use for features (epic tasks) or bugs (specs/bugs/BUG-*.md)."
3alwaysApply: false
4---
5 
6# Develop TDD
7 
8> **HARD GATE** — Do NOT proceed if on `main` or `master`. Run `kickoff-branch` first to create a feature branch or worktree.
9>
10> **HARD GATE** — Do NOT write code before you have a plan. New feature: `plan-work` → epic capsule tasks. Bug: `investigate-bug` → `specs/bugs/BUG-*.md` (or use `fix-bug` orchestrator).
11>
12> **RECURSIVE DISCIPLINE** — This lifecycle applies to EVERY task, including updating these skills. Never skip planning because a task is "meta" or "just documentation."
13 
14## Philosophy
15 
16Tests verify behavior through public interfaces, not implementation details. A good test reads like a specification. See [REFERENCE.md](REFERENCE.md) for the horizontal-slice anti-pattern and TDD phase detail.
17 
18## Red Flags
19 
20If you catch yourself thinking these, stop and reconsider — you are likely deviating from production-grade craft.
21 
22| Red Flag | Reality |
23| :--- | :--- |
24| "This is too simple to need tests." | Simple code is where bugs hide. If it's simple, the test is cheap. |
25| "I'll refactor this later." | "Later" is when technical debt becomes bankruptcy. Refactor while Green. |
26| "The tests are already comprehensive." | If you're adding behavior, you need a new test. Coverage ≠ Correctness. |
27| "I'm just fixing a small bug." | Small bugs often indicate deep interface flaws. Investigate root cause. |
28| "I need to mock this internal class." | Mocking internals couples tests to implementation. Mock only I/O. |
29| "This refactor is out of scope." | Leave the code cleaner than you found it (Boy Scout Rule). |
30| "Preflight failed but it's unrelated." | **Always Green:** any reproducible gate failure routes **quick-fix → fix-bug** before forward work. Session boundaries do not waive Preflight. |
31| "I'll note the red gate and continue." | Narrating a failure is banned. fix-or-log is mandatory per CONVENTIONS § Discovered Defects. |
32 
33## Workflow
34 
35> **Timing:** `bash scripts/bp-timing.sh start develop-tdd` at invocation; `bash scripts/bp-timing.sh end develop-tdd` before handoff.
36 
37### 1. Planning
38 
39- [ ] Read active `specs/epics/*/epic.yaml` story tasks or `specs/bugs/BUG-*.md` — understand verify steps
40- [ ] If `specs/tech-architecture/eNN-TEST_PLAN_LATEST.md` exists for the active epic, read it before writing the first test. Implement P0 scenarios (`SC-*-P0-*`) before P1. P2/P3 scenarios are optional per time budget.
41- [ ] Confirm interface changes and behaviors to test (prioritize)
42- [ ] Design interfaces for testability — identify [deep modules](deep-modules.md) opportunities
43- [ ] Get user approval on the plan
44 
45Apply the **enforce-first** F.I.R.S.T rubric: Fast, Independent, Repeatable, Self-Validating, Timely.
46 
47### 2. Tracer Bullet
48 
49Write ONE test that confirms ONE thing about the system:
50 
51```
52RED:    Write test for first behavior → test fails → commit: test(<scope>): ...  (test-only; red in CI)
53GREEN:  Write minimal code to pass → test passes → commit: feat(<scope>): ...   (fix commit; green)
54REFACTOR (optional): clean up → commit: refactor(<scope>): ...
55```
56 
57> **Two-commit red/green policy (HARD GATE — e45s08)** — Each behavior cycle requires **two separate commits**: (1) test-only commit that fails in CI (RED), then (2) implementation commit that makes it pass (GREEN). Never combine test + fix in one commit. Before proceeding, run the mechanical RED isolation check:
58 
59```bash
60bash scripts/verify-tdd-red-commit.sh
61```
62 
63Show `git log -2 --oneline` **and** the script output as evidence. If the test-only commit passes in isolation, the RED gate is violated — stop and fix before GREEN.
64 
65> **tasks.yaml ledger (e45s06)** — After each task's `verify:` exits 0, update `eNNsYY-tasks.yaml`: set that task's `status: passing`. Story-level `status: passing` only when all tasks pass.
66 
67### 3. Incremental Loop
68 
69> **Snapshot-before-transition (e45s34):** Before each RED → GREEN or GREEN → REFACTOR transition, create a checkpoint so a failed transition can be rolled back cleanly:
70 
71```bash
72bash scripts/bp-yaml-snapshot.sh specs/state.yaml   # if state changed this cycle
73git stash push -m &quot;tdd-checkpoint-$(git rev-parse --short HEAD)-red&quot; --keep-index 2&gt;/dev/null || true
74```
75 
76After GREEN passes and is committed, drop the stash (`git stash drop` if empty). Never refactor while RED.
77 
78For each remaining behavior: RED → GREEN → REFACTOR (optional). One test at a time. **Two commits per behavior** (test-only RED, then fix GREEN). Commit after every GREEN phase.
79 
80### 4. Visual Slices (UI alternate workflow)
81 
82For UI components where behavioral unit testing is brittle: extract logic into a Controller/ViewModel/Hook (pure TDD), then use Visual Slices for the View layer. See [REFERENCE.md](REFERENCE.md) for the full Visual Slices procedure.
83 
84### 5. Refactor
85 
86After all tests pass: extract duplication, deepen modules, apply SOLID principles. **Never refactor while RED.**
87 
88### 6. Verify
89 
90After every behavior cycle, run the verify command from the active epic task. Show evidence before declaring the step done.
91 
92### 7. Manual Verification Handover
93 
94Once all tests pass: locate the Verification Script in the active epic capsule, present it to the user step-by-step, and wait for confirmation of behavioral correctness.
95 
96 
97### 6a. CI dry-run sub-step
98 
99If this cycle modified files in `.github/workflows/`, run the CI dry-run procedure documented in [REFERENCE.md](REFERENCE.md#ci-dry-run).
100 
101## Checklist Per Cycle
102 
103```
104[ ] Test describes behavior, not implementation
105[ ] No test is ignored without an explicit ambiguity note (T4)
106[ ] Boundary conditions tested: empty, max, min, off-by-one (T5)
107[ ] Tests verify behavior through public interface only — no private methods (T8)
108[ ] Test would survive internal refactor
109[ ] Code is minimal for this test
110[ ] No speculative features added
111[ ] Every new abstraction has an explicit "Reason for Depth" justification
112[ ] Progress committed (Conventional Commits)
113[ ] verify: command passes
114```
115 
116 
117 
118## Handoff
119 
120Gate: READY -> next: verify-work
121Writes: state.yaml handoff.next_skill = verify-work
122 
123## BCP Plus Integration
124 
125At story completion, if the story was sized with BCP Plus (13-dimension breakdown), log the `bcp_plus.total` alongside the standard `bcps:` count in the story's tasks.yaml. The breakdown is available from the epic capsule's `bcp_plus_breakdown` field. See `docs/references/bcp-plus.md` for the full methodology and NFR Gate pattern.
126 
127## Verify
128 
129→ verify: `test -x scripts/verify-tdd-red-commit.sh && bash scripts/verify-tdd-red-commit.sh --self-test && grep -q 'verify-tdd-red-commit' skills/develop-tdd/SKILL.md && echo OK`
130 
131 
132<!-- story: e02s04 -->
133 
134---
135 
136# Develop TDD — Reference
137 
138## Anti-Pattern: Horizontal Slices
139 
140**DO NOT write all tests first, then all implementation.** This is "horizontal slicing" — treating RED as "write all tests" and GREEN as "write all code."
141 
142This produces **crap tests**:
143- Tests written in bulk test _imagined_ behavior, not _actual_ behavior
144- You end up testing the _shape_ of things rather than user-facing behavior
145- Tests become insensitive to real changes
146 
147**Correct approach**: Vertical slices via tracer bullets. One test → one implementation → repeat.
148 
149```
150WRONG (horizontal):
151  RED:   test1, test2, test3, test4, test5
152  GREEN: impl1, impl2, impl3, impl4, impl5
153 
154RIGHT (vertical):
155  RED→GREEN: test1→impl1
156  RED→GREEN: test2→impl2
157  RED→GREEN: test3→impl3
158  ...
159```
160 
161> The Red Flags table lives in [SKILL.md](SKILL.md#red-flags) — it is core behavioral guidance, not reference detail.
162 
163## TDD Phases (Detail)
164 
165### Red Phase
166 
167Write a failing test first:
168- Test describes the desired observable behavior through the public interface
169- Run the test to confirm it fails for the right reason (not a syntax error, not a typo)
170- Commit: `git commit -m "test(<scope>): <description>"`
171 
172### Green Phase
173 
174Write the minimum code to make the test pass:
175- No extra logic, no anticipated future cases, no premature optimization
176- Focus only on making the current test pass
177- Commit: `git commit -m "feat(<scope>): <description>"` or `"fix(<scope>): <description>"`
178 
179### Refactor Phase
180 
181Improve structure without changing behavior:
182- Extract duplication, apply SOLID principles where natural, deepen modules
183- Run tests after each refactor step to ensure behavior is preserved
184- Commit: `git commit -m "refactor(<scope>): <description>"`
185- Apply the Boy Scout Rule: leave the code cleaner than you found it
186 
187## Visual Slices (UI Alternate Workflow)
188 
189For UI components (SwiftUI, React, Flutter) where behavioral unit testing is brittle or low-signal:
190 
1911. **Test-First Logic**: Extract logic (state transitions, formatting, validation) into a Controller, ViewModel, or Hook. This logic MUST follow pure TDD.
1922. **Visual Verification**: For the View/Component itself:
193   - **RED**: Write the component signature and a basic preview/snapshot that fails (or displays placeholder).
194   - **GREEN**: Implement the UI and verify visually via manual run, preview, or snapshot test.
195   - **REFINE**: Adjust styling and layout until it matches the design.
1963. **COMMIT**: `git commit -m "feat(ui): <component name> visual slice verified"`
197 
198---
199 
200# Deep Modules
201 
202From "A Philosophy of Software Design":
203 
204**Deep module** = small interface + lots of implementation
205 
206```
207┌─────────────────────┐
208│   Small Interface   │  ← Few methods, simple params
209├─────────────────────┤
210│                     │
211│                     │
212│  Deep Implementation│  ← Complex logic hidden
213│                     │
214│                     │
215└─────────────────────┘
216```
217 
218**Shallow module** = large interface + little implementation (avoid)
219 
220```
221┌─────────────────────────────────┐
222│       Large Interface           │  ← Many methods, complex params
223├─────────────────────────────────┤
224│  Thin Implementation            │  ← Just passes through
225└─────────────────────────────────┘
226```
227 
228When designing interfaces, ask:
229 
230- Can I reduce the number of methods?
231- Can I simplify the parameters?
232- Can I hide more complexity inside?
233 
234---
235 
236# Interface Design for Testability
237 
238Good interfaces make testing natural:
239 
2401. **Accept dependencies, don't create them**
241 
242```typescript
243   // Testable
244   function processOrder(order, paymentGateway) {}
245 
246   // Hard to test
247   function processOrder(order) {
248     const gateway = new StripeGateway();
249   }
250```
251 
2522. **Return results, don't produce side effects**
253 
254```typescript
255   // Testable
256   function calculateDiscount(cart): Discount {}
257 
258   // Hard to test
259   function applyDiscount(cart): void {
260     cart.total -= discount;
261   }
262```
263 
2643. **Small surface area**
265   - Fewer methods = fewer tests needed
266   - Fewer params = simpler test setup
267 
268---
269 
270# When to Mock
271 
272Mock at **system boundaries** only:
273 
274- External APIs (payment, email, etc.)
275- Databases (sometimes - prefer test DB)
276- Time/randomness
277- File system (sometimes)
278 
279Don't mock:
280 
281- Your own classes/modules
282- Internal collaborators
283- Anything you control
284 
285## Designing for Mockability
286 
287At system boundaries, design interfaces that are easy to mock:
288 
289**1. Use dependency injection**
290 
291Pass external dependencies in rather than creating them internally:
292 
293```typescript
294// Easy to mock
295function processPayment(order, paymentClient) {
296  return paymentClient.charge(order.total);
297}
298 
299// Hard to mock
300function processPayment(order) {
301  const client = new StripeClient(process.env.STRIPE_KEY);
302  return client.charge(order.total);
303}
304```
305 
306**2. Prefer SDK-style interfaces over generic fetchers**
307 
308Create specific functions for each external operation instead of one generic function with conditional logic:
309 
310```typescript
311// GOOD: Each function is independently mockable
312const api = {
313  getUser: (id) => fetch(`/users/${id}`),
314  getOrders: (userId) => fetch(`/users/${userId}/orders`),
315  createOrder: (data) => fetch('/orders', { method: 'POST', body: data }),
316};
317 
318// BAD: Mocking requires conditional logic inside the mock
319const api = {
320  fetch: (endpoint, options) => fetch(endpoint, options),
321};
322```
323 
324The SDK approach means:
325- Each mock returns one specific shape
326- No conditional logic in test setup
327- Easier to see which endpoints a test exercises
328- Type safety per endpoint
329 
330---
331 
332# Refactor Candidates
333 
334After TDD cycle, look for:
335 
336- **Duplication** → Extract function/class
337- **Long methods** → Break into private helpers (keep tests on public interface)
338- **Shallow modules** → Combine or deepen
339- **Feature envy** → Move logic to where data lives
340- **Primitive obsession** → Introduce value objects
341- **Existing code** the new code reveals as problematic
342 
343---
344 
345# Good and Bad Tests
346 
347## Good Tests
348 
349**Integration-style**: Test through real interfaces, not mocks of internal parts.
350 
351```typescript
352// GOOD: Tests observable behavior
353test("user can checkout with valid cart", async () => {
354  const cart = createCart();
355  cart.add(product);
356  const result = await checkout(cart, paymentMethod);
357  expect(result.status).toBe("confirmed");
358});
359```
360 
361Characteristics:
362 
363- Tests behavior users/callers care about
364- Uses public API only
365- Survives internal refactors
366- Describes WHAT, not HOW
367- One logical assertion per test
368 
369## Bad Tests
370 
371**Implementation-detail tests**: Coupled to internal structure.
372 
373```typescript
374// BAD: Tests implementation details
375test("checkout calls paymentService.process", async () => {
376  const mockPayment = jest.mock(paymentService);
377  await checkout(cart, payment);
378  expect(mockPayment.process).toHaveBeenCalledWith(cart.total);
379});
380```
381 
382Red flags:
383 
384- Mocking internal collaborators
385- Testing private methods
386- Asserting on call counts/order
387- Test breaks when refactoring without behavior change
388- Test name describes HOW not WHAT
389- Verifying through external means instead of interface
390 
391```typescript
392// BAD: Bypasses interface to verify
393test("createUser saves to database", async () => {
394  await createUser({ name: "Alice" });
395  const row = await db.query("SELECT * FROM users WHERE name = ?", ["Alice"]);
396  expect(row).toBeDefined();
397});
398 
399// GOOD: Verifies through interface
400test("createUser makes user retrievable", async () => {
401  const user = await createUser({ name: "Alice" });
402  const retrieved = await getUser(user.id);
403  expect(retrieved.name).toBe("Alice");
404});
405```
406 
407## Clean Test Heuristics (Uncle Bob, Ch 17)
408 
409Apply these specific heuristics to maintain a high-quality suite:
410 
411- **T1: Insufficient Tests**: A test suite should test everything that could possibly break. Don't stop at "it seems to work."
412- **T4: Ignored Tests**: Never ignore a test without documenting the ambiguity. An ignored test is a silent warning of a gap in understanding.
413- **T5: Test Boundary Conditions**: Most bugs happen at the edges. Test the exact boundaries (e.g., empty strings, max integers, off-by-one indices).
414- **T6: Exhaustively Test Near Bugs**: Bugs congregate. If you find one, there are likely others nearby; test that area thoroughly.
415- **T9: Tests Should Be Fast**: Slow tests don't get run. Keep them fast so they remain part of the core developer loop.
416