# Rust Tdd

> Test-Driven Development for Rust. Use when creating new functionality, writing tests, or fixing bugs through the Red-Green-Refactor TDD cycle.

- Skill: `majiayu000/rust-tdd` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds add majiayu000/rust-tdd`
- Raw SKILL.md: https://api.skillmd.com/api/skills/majiayu000/rust-tdd/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: majiayu000 (https://skillmd.com/u/majiayu000)
- Updated: 2026-09-09
- Page: https://skillmd.com/skills/majiayu000/rust-tdd

---


# Rust TDD Workflow

## Process (Red-Green-Refactor)

### 1. Red Phase
Write a failing test first that describes the desired behavior:

```rust
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_new_feature() {
        let result = new_function(input);
        assert_eq!(result, expected_output);
    }
}
```

Verify the test fails: `cargo test -p <crate> <test_name>`

### 2. Green Phase
Implement the minimum code to make the test pass:
- Write only enough code to pass the test
- Don't over-engineer or add extra features
- Focus on correctness, not elegance

Verify: `cargo test -p <crate>`

### 3. Refactor Phase
Improve the code while keeping tests green:
- Remove duplication
- Improve naming
- Simplify logic
- Extract functions if needed

After each change: `cargo test -p <crate>`

## Test Commands

```bash
# Run specific test
cargo test -p <crate> <test_name> -- --nocapture

# Run all tests in crate
cargo test -p <crate> --all-features

# Run with output
cargo test -p <crate> -- --nocapture

# Run doc tests
cargo test -p <crate> --doc

# Continuous testing
cargo watch -x "test -p <crate>"
```

## Test Patterns

### Basic Test
```rust
#[test]
fn test_success_case() {
    let result = function_under_test(42);
    assert_eq!(result, 84);
}
```

### Result-returning Test
```rust
#[test]
fn test_with_result() -> Result<(), Box<dyn std::error::Error>> {
    let result = fallible_function()?;
    assert_eq!(result, expected);
    Ok(())
}
```

### Panic Test
```rust
#[test]
#[should_panic(expected = "index out of bounds")]
fn test_panic_case() {
    function_that_panics();
}
```

### Async Test
```rust
#[tokio::test]
async fn test_async_function() {
    let result = async_function().await;
    assert!(result.is_ok());
}
```

### Property-based Test (with proptest)
```rust
use proptest::prelude::*;

proptest! {
    #[test]
    fn test_property(x in 0..100i32) {
        let result = function(x);
        prop_assert!(result >= 0);
    }
}
```

## Final Verification

After completing TDD cycle:
```bash
cargo clippy -p <crate> -- -D warnings
cargo fmt -p <crate> -- --check
cargo test -p <crate> --all-features
```

## Nebula-specific Patterns

- Each crate has its own error type via `thiserror`
- Use `#[tokio::test]` for async tests
- Place unit tests in same file under `#[cfg(test)]` module
- Place integration tests in `tests/` directory of the crate