Testing Rust

Rust Testing

Target: $ARGUMENTS

Writes focused, behavior-driven tests following project testing strategy.

Quick Reference

TDD methodology (language-agnostic): See tdd-core plugin (testing-tdd skill)

Rust-specific documentation: references/

• references/testing-strategy.md — Rust tools (cargo test, proptest, insta, mockall)
• references/tdd-best-practices.md — Rust TDD examples (extends tdd-core)

Quick Decision

cargo test (default): Use #[test] for known cases, #[tokio::test] for async. Works at unit/integration levels.

proptest (edge cases): Use for invariants that must hold for ALL inputs.

See references/testing-strategy.md for full methodology comparison.

TDD Essentials (Quick Reference)

Cycle: RED (failing test / compile error) -> GREEN (minimal pass) -> REFACTOR (clean up)

Structure: Arrange-Act-Assert (AAA)

#[test]
fn test_order_calculator_sums_item_prices() {
    // ARRANGE
    let items = vec![Item { price: 10, qty: 2 }, Item { price: 5, qty: 1 }];
    let calculator = OrderCalculator::new();

    // ACT
    let total = calculator.total(&items);

    // ASSERT
    assert_eq!(total, 25);
}

proptest Priorities (Edge Cases within TDD)

What to Test (KISS/DRY/YAGNI)

High-Value: Business logic, error paths, integration points, contracts

Avoid: Compiler behavior, derive implementations, trivial assertions, default values

See references/testing-strategy.md -> "Patterns to Remove" for full list.

Naming Convention

Format: test_{module}_{component}_{behavior}

test_user_service_creates_new_user()
test_order_processor_validates_items()
test_score_always_in_bounds()  // property test

Execution

cargo test                          # All tests
cargo test test_order               # Filter by name
cargo test --lib                    # Unit tests only
cargo test --test integration       # Integration tests only
cargo watch -x test                 # Watch mode (cargo-watch)

Quality Gates

• All tests pass (cargo test)
• TDD Red-Green-Refactor followed
• Arrange-Act-Assert structure used
• Naming convention followed
• Behavior-focused (not implementation)
• No compiler/library behavior tested
• Mocks use mockall with .times() constraints