test-driven-development

Files (1)

• SKILL.md

SKILL.md (first lines)

# Test-Driven Development (TDD)

Write the test first. Watch it fail. Write minimal code to pass.

## When to Use

**Always:**

- New features
- Bug fixes
- Refactoring
- Behavior changes

**Exceptions (ask first):**

- Throwaway prototypes
- Generated code
- Configuration files

Thinking "skip TDD just this once"? Stop. That's rationalization.

---

## The Iron Law

```
NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST
```

Write code before the test? Delete it. Start over.

**No exceptions:**

- Don't keep it as "reference"
- Don't "adapt" it while writing tests
- Don't look at it
- Delete means delete

Implement fresh from tests. Period.

---

## Red-Green-Refactor Cycle

```
┌─────────────────────────────────────────────────────────────┐
│                                                              │
│   RED ──────────► GREEN ──────────► REFACTOR                │
│    │                │                   │                    │
│    │                │                   │                    │
│    ▼                ▼                   ▼                    │
│  Write           Minimal            Clean up                │
│  failing         code to            (tests stay             │
│  test            pass               green)                  │
│    │                │                   │                    │
│    └────────────────┴───────────────────┘                   │
│                     │                                        │
│                     ▼                                        │
│                   NEXT                                       │
│                   TEST                                       │
└─────────────────────────────────────────────────────────────┘
```

### RED - Write Failing Test

Write one minimal test showing what should happen.

**Good:**

```rust
#[test]
fn retries_failed_operations_3_times() {
    let attempts = AtomicUsize::new(0);
    let operation = || {
        let count = attempts.fetch_add(1, Ordering::SeqCst);
        if count < 2 {
            Err(anyhow!("fail"))
        } else {
            Ok("success")
        }
    };

    let result = retry_operation(operation, 3);

    assert_eq!(result.unwrap(), "success");
    assert_eq!(attempts.load(Ordering::SeqCst), 3);
}
```

Clear name, tests real behavior, one thing.

**Bad:**

```rust
#[test]
fn retry_works() {
    let mock = MockFn::new()
        .returning_err(anyhow!("fail"))
        .returning_err(anyhow!("fail"))
        .returning_ok("success");
    retry_operation(mock, 3);
    assert_eq!(mock.call_count(), 3);
}
```

Vague name, tests mock not code.

**Requirements:**

- One behavior
- Clear name
- Real code (no mocks unless unavoidable)

### Verify RED - Watch It Fail

**MANDATORY. Never skip.**

```bash
cargo test retry_operation -- --nocapture

From 5DLabsInc/cto, AGPL-3.0.

More from 5DLabsInc/cto