Skill: TDD Implementation

When to use this skill

• •Implementing new features
• •Major refactoring
• •Complex bug fixes

Available templates

TDD Workflow (Test-Driven Development)

Phase 1: Understand

1. •

   Read existing documentation

   • •GLOBAL_APP_DESCRIPTION.md for global context
   • •docs/STRATEGIES.md if related to trading
2. •

   Identify affected modules

   • •Which DDD layer? (domain/application/infrastructure)
   • •Which existing files will be impacted?
3. •

   Verify architecture

   code

   domain/         → Pure business logic, no I/O
   application/    → Orchestration, services, use cases
   infrastructure/ → I/O, external APIs, persistence
   

Phase 2: Write tests FIRST

Fundamental rule: Tests are written BEFORE implementation code.

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

    #[test]
    fn test_new_feature_basic_case() {
        // Arrange
        let input = ...;
        
        // Act
        let result = new_feature(input);
        
        // Assert
        assert_eq!(result, expected);
    }

    #[test]
    fn test_new_feature_edge_case() {
        // Test edge cases
    }

    #[test]
    fn test_new_feature_error_case() {
        // Test error cases
    }
}

Tests MUST fail at this stage (red phase).

Phase 3: Implement

1. •Minimal code to make tests pass
2. •Respect DDD architecture
3. •No .unwrap() in production code
4. •Use Decimal for amounts

// ❌ Avoid
fn process(value: f64) -> f64 {
    some_operation(value).unwrap()
}

// ✅ Prefer
fn process(value: Decimal) -> Result<Decimal, ProcessError> {
    some_operation(value).map_err(ProcessError::from)
}

Phase 4: Refactor

1. •

   Clean the code

   • •Remove duplicate code
   • •Improve variable names
   • •Simplify complex expressions
2. •

   Add documentation

   • •Rustdoc on public functions
   • •Comments for complex logic
3. •

   Verify with clippy

   bash

   cargo clippy --all-targets -- -D warnings
   

Phase 5: Validate

1. •

   Invoke the testing skill

   • •cargo fmt
   • •cargo clippy
   • •cargo test
2. •

   Invoke the documentation skill

   • •Update GLOBAL_APP_DESCRIPTION.md
   • •Add entry in GLOBAL_APP_DESCRIPTION_VERSIONS.md
   • •Increment version

Complete example

// 1. First the test
#[test]
fn test_calculate_position_size() {
    let capital = Decimal::from(10000);
    let risk_pct = Decimal::from_str("0.02").unwrap();
    let stop_loss = Decimal::from_str("0.05").unwrap();
    
    let size = calculate_position_size(capital, risk_pct, stop_loss);
    
    assert_eq!(size, Decimal::from(4000)); // 2% risk, 5% stop = 40% position
}

// 2. Then the implementation
pub fn calculate_position_size(
    capital: Decimal,
    risk_percentage: Decimal,
    stop_loss_percentage: Decimal,
) -> Decimal {
    let risk_amount = capital * risk_percentage;
    risk_amount / stop_loss_percentage
}

Anti-patterns to avoid