WeReply: Skill for Claude Code

Testing Strategy Skill

Comprehensive testing guidance for Tauri applications with Rust backend and React frontend.

Overview

This skill provides testing strategies for:

• Rust unit and integration tests
• React component and hook tests
• Tauri command mocking
• Database testing with fixtures
• Test coverage and quality gates
• TDD (Test-Driven Development) workflows

When This Skill Applies

This skill activates when:

• Writing new tests for Rust or TypeScript code
• Implementing test doubles and mocks
• Setting up test infrastructure
• Debugging test failures
• Improving test coverage
• Planning testing strategy for features

Rust Testing

Unit Tests

Location: In the same module as the code being tested

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

    #[test]
    fn test_formula_cost_calculation() {
        let materials = vec![
            FormulaMaterial {
                material_code: "corn".to_string(),
                proportion: 50.0,
                price: 2.5,
            },
            FormulaMaterial {
                material_code: "soybean".to_string(),
                proportion: 50.0,
                price: 3.0,
            },
        ];

        let cost = calculate_total_cost(&materials);
        assert!((cost - 2.75).abs() < 0.01); // Average of 2.5 and 3.0
    }

    #[test]
    fn test_empty_materials() {
        let materials = vec![];
        let cost = calculate_total_cost(&materials);
        assert_eq!(cost, 0.0);
    }

    #[test]
    #[should_panic(expected = "Proportion cannot be negative")]
    fn test_negative_proportion_panics() {
        let material = FormulaMaterial {
            material_code: "test".to_string(),
            proportion: -10.0,
            price: 1.0,
        };
        validate_material(&material);
    }
}

Integration Tests

Location: tests/ directory at project root

// tests/formula_integration_tests.rs
use ca_cr_feed_formula::database::create_pool;
use ca_cr_feed_formula::formula::FormulaService;

#[tokio::test]
async fn test_create_and_retrieve_formula() {
    // Use test database
    let pool = create_pool(":memory:").await.expect("Failed to create pool");
    let service = FormulaService::new(pool);

    // Create formula
    let create_dto = CreateFormulaDto {
        name: "Test Formula".to_string(),
        species_code: "pig".to_string(),
        description: None,
    };

    let formula_id = service.create_formula(create_dto)
        .await
        .expect("Failed to create formula");

    // Retrieve formula
    let formula = service.get_formula(formula_id)
        .await
        .expect("Failed to retrieve formula");

    assert_eq!(formula.name, "Test Formula");
    assert_eq!(formula.species_code, "pig");
}

#[tokio::test]
async fn test_formula_not_found() {
    let pool = create_pool(":memory:").await.expect("Failed to create pool");
    let service = FormulaService::new(pool);

    let result = service.get_formula(99999).await;
    assert!(result.is_err());
}