Rust TDD Workflow

Three Laws of TDD

1. Do NOT write production code without a failing test
2. Write only enough test to fail (including compilation failure)
3. Write only enough production code to pass the failing test

Red-Green-Refactor Steps

1. Write test in #[cfg(test)] mod tests of the SAME file
2. cargo test MODULE::tests::test_name  -- must FAIL (red)
3. Implement the minimum in the function
4. cargo test MODULE::tests::test_name  -- must PASS (green)
5. Refactor if needed, re-run cargo test (still green)
6. cargo fmt && cargo clippy --all-targets && cargo test  (final gate)

Idiomatic Rust Test Patterns

assert_eq!

assert!

assert!(result.is_err())

Result<()>

?

#[should_panic]

tempfile::NamedTempFile

Patterns by Code Type

assert_eq!(truncate("hello", 3), "...")

assert!(filter(raw).contains("expected"))

assert!(!is_valid("../etc/passwd"))

is_err()

assert!(parse("garbage").is_err())

assert_eq!(from_str(to_str(x)), x)

Naming Convention

test_{function}_{scenario}
test_{function}_{input_type}

test_truncate_edge_case

test_parse_invalid_input

test_filter_empty_string

When NOT to Use Pure TDD

• Functions calling

  Command::new()

  -> test the parser, not the execution

• std::process::exit()

  -> refactor to

  Result

  first, then test the Result
• Direct I/O (SQLite, network) -> use tempfile/mock or test the pure logic separately
• Main/CLI wiring -> covered by integration/smoke tests

Pre-Commit Gate

cargo fmt --all --check
cargo clippy --all-targets
cargo test

#[allow(...)]