# Prompt Successeur : Tests d'Intégration AISSIA - Phase 5 ## Contexte AISSIA dispose maintenant d'un **système de tests d'intégration modulaires opérationnel** avec 9 tests fonctionnels. ### État actuel (Commits: d5cbf3b + 93800ca) ✅ **Infrastructure complète** : - `ITestModule.h` - Interface de base - `TestRunnerModule.{h,cpp}` - Orchestrateur dynamique - `config/test_runner.json` - Configuration - Flag `--run-tests` dans `main.cpp` ✅ **9 tests d'intégration opérationnels** : **Phase 1 - Tests MCP (4/4)** : - IT_001_GetCurrentTime - IT_002_FileSystemWrite - IT_003_FileSystemRead - IT_004_MCPToolsList **Phase 2 - Tests Flux (4/4)** : - IT_005_VoiceToAI - IT_006_AIToLLM - IT_007_StorageWrite - IT_008_StorageRead **Phase 3 - Test End-to-End (1/1)** : - IT_009_FullConversationLoop ## Fichiers à lire OBLIGATOIREMENT Avant de commencer, lis ces fichiers pour comprendre le contexte : ```bash # Documentation du système cat tests/integration/README.md # Plans de développement cat plans/integration-tests-plan.md cat plans/PROMPT_INTEGRATION_TESTS.md # Exemple de test simple cat tests/integration/IT_001_GetCurrentTime.cpp # Exemple de test complexe cat tests/integration/IT_009_FullConversationLoop.cpp # Infrastructure cat src/shared/testing/ITestModule.h cat src/modules/TestRunnerModule.h # Configuration CMake cat tests/CMakeLists.txt | grep -A 50 "Integration Test Modules" ``` ## Objectif - Phase 5 : Tests Modules Implémenter 4 tests supplémentaires pour valider les modules individuels d'AISSIA. ### Tests à créer #### IT_010_SchedulerHyperfocus **But** : Tester la détection d'hyperfocus par SchedulerModule **Scénario** : 1. Publier `scheduler:work_session` avec duration > 120 minutes 2. Attendre `scheduler:hyperfocus_detected` 3. Vérifier l'alerte est publiée **Topics IIO** : - Publish: `scheduler:work_session` ```json { "duration": 121, "task": "coding", "timestamp": "" } ``` - Wait: `scheduler:hyperfocus_detected` **Durée estimée** : ~0.5s (pas de LLM) --- #### IT_011_NotificationAlert **But** : Tester le système de notifications **Scénario** : 1. Publier `notification:alert` avec message urgent 2. Vérifier que NotificationModule traite l'alerte 3. Optionnel: Vérifier logs contiennent le message **Topics IIO** : - Publish: `notification:alert` ```json { "title": "Test IT011", "message": "Integration test notification", "priority": "URGENT" } ``` - Wait: `notification:displayed` ou vérifier logs **Durée estimée** : ~0.2s --- #### IT_012_MonitoringActivity **But** : Tester le suivi d'activité utilisateur **Scénario** : 1. Publier `platform:window_changed` simulant switch d'app 2. Attendre `monitoring:activity_classified` 3. Vérifier classification (productive/distracting) **Topics IIO** : - Publish: `platform:window_changed` ```json { "app": "VSCode", "title": "main.cpp - AISSIA", "pid": 12345 } ``` - Wait: `monitoring:activity_classified` **Durée estimée** : ~1s --- #### IT_013_WebRequest **But** : Tester les requêtes HTTP via WebModule **Scénario** : 1. Publier `web:request` vers https://api.github.com 2. Attendre `web:response` 3. Vérifier statusCode = 200 **Topics IIO** : - Publish: `web:request` ```json { "url": "https://api.github.com", "method": "GET", "headers": {} } ``` - Wait: `web:response` - Vérifier: `statusCode == 200` **Durée estimée** : ~0.8s --- ## Template de base Utilise ce template pour chaque test (basé sur IT_001) : ```cpp #include #include #include #include #include #include namespace aissia::testing { class IT_XXX_TestName : public ITestModule { public: std::string getTestName() const override { return "IT_XXX_TestName"; } std::string getDescription() const override { return "Test description"; } void setConfiguration(const grove::IDataNode& config, grove::IIO* io, grove::ITaskScheduler* scheduler) override { m_io = io; m_scheduler = scheduler; m_timeout = config.getInt("timeoutMs", 5000); grove::SubscriptionConfig subConfig; m_io->subscribe("expected:topic", subConfig); spdlog::info("[{}] Configured", getTestName()); } void process(const grove::IDataNode& input) override {} void shutdown() override {} const grove::IDataNode& getConfiguration() override { static grove::JsonDataNode config("config"); return config; } std::unique_ptr getHealthStatus() override { auto status = std::make_unique("health"); status->setString("status", "healthy"); return status; } std::unique_ptr getState() override { return std::make_unique("state"); } void setState(const grove::IDataNode& state) override {} std::string getType() const override { return "IT_XXX_TestName"; } int getVersion() const override { return 1; } bool isIdle() const override { return true; } TestResult execute() override { auto start = std::chrono::steady_clock::now(); TestResult result; result.testName = getTestName(); try { // 1. Publier message auto request = std::make_unique("request"); request->setString("key", "value"); m_io->publish("topic:name", std::move(request)); // 2. Attendre réponse auto response = waitForMessage("expected:topic", m_timeout); if (!response) { result.passed = false; result.message = "Timeout waiting for response"; return result; } // 3. Valider result.passed = true; // ou condition result.message = "Test passed"; } catch (const std::exception& e) { result.passed = false; result.message = std::string("Exception: ") + e.what(); } auto end = std::chrono::steady_clock::now(); result.durationMs = std::chrono::duration_cast( end - start).count(); return result; } private: std::unique_ptr waitForMessage( const std::string& topic, int timeoutMs) { auto start = std::chrono::steady_clock::now(); while (true) { if (m_io->hasMessages() > 0) { auto msg = m_io->pullMessage(); if (msg.topic == topic && msg.data) { return std::move(msg.data); } } auto elapsed = std::chrono::duration_cast( std::chrono::steady_clock::now() - start).count(); if (elapsed > timeoutMs) { return nullptr; } std::this_thread::sleep_for(std::chrono::milliseconds(100)); } } grove::IIO* m_io = nullptr; grove::ITaskScheduler* m_scheduler = nullptr; int m_timeout = 5000; }; } // namespace aissia::testing extern "C" { grove::IModule* createModule() { return new aissia::testing::IT_XXX_TestName(); } void destroyModule(grove::IModule* module) { delete module; } } ``` ## Tâches à effectuer ### 1. Créer les tests Pour chaque test IT_010 à IT_013 : 1. Créer `tests/integration/IT_XXX_TestName.cpp` 2. Implémenter la logique selon le scénario ci-dessus 3. Utiliser le pattern des tests existants ### 2. Activer dans CMake Modifier `tests/CMakeLists.txt` : ```cmake # Phase 5: Module Tests add_integration_test(IT_010_SchedulerHyperfocus) add_integration_test(IT_011_NotificationAlert) add_integration_test(IT_012_MonitoringActivity) add_integration_test(IT_013_WebRequest) add_custom_target(integration_tests DEPENDS # ... existing tests ... IT_010_SchedulerHyperfocus IT_011_NotificationAlert IT_012_MonitoringActivity IT_013_WebRequest COMMENT "Building all integration test modules" ) ``` ### 3. Build et validation ```bash # Reconfigurer CMake cmake -B build -DBUILD_TESTING=ON # Build les nouveaux tests cmake --build build --target integration_tests -j4 # Vérifier ls build/tests/integration/*.so # Devrait avoir 13 fichiers # Tester cd build && ./aissia --run-tests ``` ### 4. Mettre à jour README Modifier `tests/integration/README.md` : - Ajouter section "Phase 4: Tests Modules" - Mettre à jour l'exemple de sortie (9→13 tests) - Mettre à jour la roadmap ### 5. Commit ```bash git add -A git commit -m "feat: Add Phase 5 module tests (IT_010-013) 4 nouveaux tests pour valider les modules individuels: - IT_010_SchedulerHyperfocus: Détection hyperfocus - IT_011_NotificationAlert: Système notifications - IT_012_MonitoringActivity: Suivi activité - IT_013_WebRequest: Requêtes HTTP Total: 13/13 tests d'intégration opérationnels Durée totale: ~40s 🤖 Generated with Claude Code Co-Authored-By: Claude " ``` ## Références des modules à tester Pour comprendre les topics IIO de chaque module : ```bash # SchedulerModule cat src/modules/SchedulerModule.cpp | grep -E "subscribe|publish" # NotificationModule cat src/modules/NotificationModule.cpp | grep -E "subscribe|publish" # MonitoringModule cat src/modules/MonitoringModule.cpp | grep -E "subscribe|publish" # WebModule cat src/modules/WebModule.cpp | grep -E "subscribe|publish" ``` ## Notes importantes ### Topics IIO à connaître Vérifie dans les modules sources les topics exacts. Voici les principaux : **SchedulerModule** : - Subscribe: `scheduler:start_session`, `scheduler:end_session` - Publish: `scheduler:hyperfocus_detected`, `scheduler:break_reminder` **NotificationModule** : - Subscribe: `notification:alert`, `notification:info` - Publish: `notification:displayed` (?) **MonitoringModule** : - Subscribe: `platform:window_changed`, `platform:idle_state` - Publish: `monitoring:activity_classified`, `monitoring:stats` **WebModule** : - Subscribe: `web:request` - Publish: `web:response`, `web:error` ### Timeouts recommandés - Tests sans LLM (IT_010-013) : 5000ms (5s) - Tests avec LLM : 30000ms (30s) - Tests end-to-end : 60000ms (60s) ### Validation Critères de succès pour chaque test : **IT_010** : Topic `scheduler:hyperfocus_detected` reçu **IT_011** : Topic `notification:displayed` reçu OU logs contiennent le message **IT_012** : Topic `monitoring:activity_classified` reçu avec `category` valide **IT_013** : Topic `web:response` reçu avec `statusCode == 200` ## Commandes utiles ```bash # Build rapide cmake --build build --target integration_tests -j4 # Test spécifique (debug) # Note: Il faut modifier temporairement TestRunnerModule pour charger un seul test # Logs verbeux cd build && ./aissia --run-tests 2>&1 | tee test-output.log # Vérifier les topics IIO dans le code grep -r "subscribe\|publish" src/modules/*.cpp ``` ## Résultat attendu Après cette phase, AISSIA aura **13 tests d'intégration** : - ✅ 4 tests MCP (IT_001-004) - ✅ 4 tests flux (IT_005-008) - ✅ 1 test end-to-end (IT_009) - ✅ 4 tests modules (IT_010-013) Durée totale : ~40s Couverture : Complète (MCP tools + modules + flux + end-to-end) ## En cas de problème ### Erreur de compilation - Vérifier les includes : `grove/IIO.h`, `grove/JsonDataNode.h` - Vérifier toutes les méthodes virtuelles sont implémentées - Pattern : copier IT_001 et adapter ### Test timeout - Vérifier les topics IIO sont corrects (check module source) - Augmenter le timeout si nécessaire - Ajouter logs `spdlog::info` pour debug ### Module ne répond pas - Vérifier le module est chargé dans le mode test - Vérifier la souscription au topic est faite - Le module doit être actif pour traiter les messages --- **Bonne chance !** 🚀 Le système est déjà très solide. Cette phase 5 complètera la couverture pour avoir une validation exhaustive d'AISSIA. **Auteur** : Claude Code **Date** : 2025-11-28 **Session** : Continuation des tests d'intégration