Rust TDD Command

This command enforces test-driven development methodology for Rust code using #[test], rstest, proptest, and mockall.

What This Command Does

• Define Types/Traits: Scaffold function signatures with todo!()
• Write Tests: Create comprehensive test module (RED)
• Run Tests: Verify tests fail for the right reason
• Implement Code: Write minimal code to pass (GREEN)
• Refactor: Improve while keeping tests green
• Check Coverage: Ensure 80%+ coverage with cargo-llvm-cov

When to Use

Use /rust-test when:

• Implementing new Rust functions, methods, or traits
• Adding test coverage to existing Rust code
• Fixing bugs (write failing test first)
• Building critical business logic
• Learning TDD workflow in Rust

TDD Cycle

RED     -> Write failing test first
GREEN   -> Implement minimal code to pass
REFACTOR -> Improve code, tests stay green
REPEAT  -> Next test case

Example Session

User: /rust-test I need a function to validate user registration
Agent:
TDD Session: Registration Validator
Step 1: Define Interface

Step 2: Write Tests (RED)

Step 3: Run Tests — Verify FAIL

Tests fail as expected (todo! panic).
Step 4: Implement Minimal Code (GREEN)

Step 5: Run Tests — Verify PASS

All tests passing!
Step 6: Check Coverage

Coverage: 100%
TDD Complete!

Test Patterns

Unit Tests

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn adds_two_numbers() {
        assert_eq!(add(2, 3), 5);
    }
    #[test]
    fn handles_error() -> Result<(), Box<dyn std::error::Error>> {
        let result = parse_config(r#"port = 8080"#)?;
        assert_eq!(result.port, 8080);
        Ok(())
    }
}

Parameterized Tests with rstest

use rstest::{rstest, fixture};
#[rstest]
#[case("hello", 5)]
#[case("", 0)]
#[case("rust", 4)]
fn test_string_length(#[case] input: &str, #[case] expected: usize) {
    assert_eq!(input.len(), expected);
}

Async Tests

#[tokio::test]
async fn fetches_data_successfully() {
    let client = TestClient::new().await;
    let result = client.get("/data").await;
    assert!(result.is_ok());
}

Property-Based Tests

use proptest::prelude::*;
proptest! {
    #[test]
    fn encode_decode_roundtrip(input in ".*") {
        let encoded = encode(&input);
        let decoded = decode(&encoded).unwrap();
        assert_eq!(input, decoded);
    }
}

Coverage Commands

# Summary report
cargo llvm-cov
HTML report
cargo llvm-cov --html
Fail if below threshold
cargo llvm-cov --fail-under-lines 80
Run specific test
cargo test test_name
Run with output
cargo test -- --nocapture
Run without stopping on first failure
cargo test --no-fail-fast

Coverage Targets

| Code Type | Target | |-----------|--------| | Critical business logic | 100% | | Public API | 90%+ | | General code | 80%+ | | Generated / FFI bindings | Exclude |

TDD Best Practices

DO:

• Write test FIRST, before any implementation
• Run tests after each change
• Use assert_eq! over assert! for better error messages
• Use ? in tests that return Result for cleaner output
• Test behavior, not implementation
• Include edge cases (empty, boundary, error paths)

• Write implementation before tests
• Skip the RED phase
• Use #[should_panic] when Result::is_err() works
• Use sleep() in tests — use channels or tokio::time::pause()
• Mock everything — prefer integration tests when feasible

Related Commands

• /rust-build - Fix build errors
• /rust-review - Review code after implementation
• /verify - Run full verification loop

Related

• Skill: skills/rust-testing/
• Skill: skills/rust-patterns/