aissia/docs/03-implementation/testing-strategy.md

Testing Strategy - Warfactory

Philosophy : Testing optimisé pour développement Claude Code avec modules autonomes

Points 42-44 : Testing & Validation Strategy

Point 42 : Unit Tests Intégrés (#ifdef TESTING)

Validation autonome intégrée aux modules :

class TankModule : public IModule {
    json process(const json& input) override {
        // Core tank logic
        auto result = processTankBehavior(input);

        #ifdef TESTING
        // Validation autonome intégrée
        validateInputs(input);
        validateState();
        validateOutputs(result);
        #endif

        return result;
    }

    #ifdef TESTING
    void runSelfTests() {
        // Tests unitaires intégrés au module
        testMovement();
        testTargeting();
        testCombat();
    }

private:
    void validateInputs(const json& input) {
        assert(input.contains("position"));
        assert(input.contains("target"));
        assert(input["health"].get<float>() >= 0.0f);
    }

    void validateState() {
        assert(currentHealth >= 0.0f);
        assert(position.isValid());
        assert(ammunition >= 0);
    }

    void validateOutputs(const json& output) {
        assert(output.contains("status"));
        assert(output.contains("position"));
        assert(output.contains("actions"));
    }
    #endif
};

Build integration :

# Debug builds enable testing
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
    target_compile_definitions(tank PRIVATE TESTING)
endif()

# Test executable
add_executable(tank-test tests/tank_test.cpp src/TankModule.cpp)
target_compile_definitions(tank-test PRIVATE TESTING)

Point 43 : Standalone Testing

Test modules sans engine complet :

// tests/tank_test.cpp
#include "../src/TankModule.h"

int main() {
    TankModule tank;

    // Initialize with test config
    json config = {
        {"health", 100},
        {"ammunition", 50},
        {"position", {10, 20}}
    };
    tank.initialize(config);

    // Run self-tests
    #ifdef TESTING
    tank.runSelfTests();
    #endif

    // Test specific behaviors
    json input = {
        {"command", "move"},
        {"target_position", {15, 25}},
        {"health", 100}
    };

    auto result = tank.process(input);

    // Verify output
    assert(result["status"] == "moving");
    assert(result.contains("position"));

    std::cout << "✅ All tank tests passed!" << std::endl;
    return 0;
}

Execution autonome :

cd modules/tank/
cmake . && make tank-test
./tank-test  # Exécute tests sans infrastructure

Point 44 : Testing Strategy AI-Optimized

Philosophy Claude Code-friendly :

Simple Tests Philosophy

• No complex infrastructure : Tests sans setup lourd
• Minimal dependencies : JSON in/out uniquement
• Quick feedback : <5 secondes pour iteration loops Claude
• Readable by AI : Code test compréhensible par IA

Module Isolation Testing

// ✅ GOOD - Simple, isolated test
void testTankMovement() {
    TankModule tank;
    json input = {{"command", "move"}, {"target", {10, 10}}};
    auto result = tank.process(input);
    assert(result["status"] == "moving");
}

// ❌ BAD - Complex infrastructure required
void testTankInCompleteGameWorld() {
    GameEngine engine;
    MapSystem map;
    NetworkManager network;
    // 100+ lines setup...
}

AI Development Workflow

# Claude Code workflow optimized
1. Edit module → Save
2. Run tests → Instant feedback
3. Iterate → 5-second cycles

# Traditional workflow (avoid)
1. Edit code → Rebuild entire project → Setup test environment → Run tests → 5-10 minutes

Testing Patterns Claude-Friendly

Input/Output Testing :

struct TestCase {
    std::string name;
    json input;
    json expected_output;
};

std::vector<TestCase> tankTests = {
    {"movement", {{"cmd", "move"}}, {{"status", "moving"}}},
    {"combat", {{"cmd", "fire"}}, {{"status", "firing"}}},
    {"damaged", {{"health", 10}}, {{"status", "critical"}}}
};

void runAllTests() {
    for(auto& test : tankTests) {
        auto result = tank.process(test.input);
        assert(result == test.expected_output);
        std::cout << "✅ " << test.name << " passed" << std::endl;
    }
}

Configuration-Driven Testing :

// tests/tank_test_config.json
{
  "test_cases": [
    {
      "name": "basic_movement",
      "input": {"command": "move", "target": [10, 10]},
      "expected": {"status": "moving", "eta": 5}
    },
    {
      "name": "low_health_behavior",
      "input": {"health": 15, "command": "attack"},
      "expected": {"status": "retreating"}
    }
  ]
}

Architecture Benefits

Development Velocity :

• 5-second iteration : Edit → Test → Feedback
• Claude optimization : IA comprend tests facilement
• Zero infrastructure : Pas setup complexe
• Parallel development : Multiple modules testés simultanément

Quality Assurance :

• Module isolation : Bugs localisés, pas cascade
• Autonomous validation : Modules self-validate via #ifdef TESTING
• Quick regression detection : Tests rapides détectent régressions
• AI-readable failures : Error messages clairs pour Claude Code