aissia/plans/PROMPT_NEXT_INTEGRATION_TESTS.md

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 :

# 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

  {
    "duration": 121,
    "task": "coding",
    "timestamp": "<now>"
  }
  

• 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

  {
    "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

  {
    "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

  {
    "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) :

#include <shared/testing/ITestModule.h>
#include <grove/JsonDataNode.h>
#include <grove/IIO.h>
#include <spdlog/spdlog.h>
#include <chrono>
#include <thread>

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<grove::IDataNode> getHealthStatus() override {
        auto status = std::make_unique<grove::JsonDataNode>("health");
        status->setString("status", "healthy");
        return status;
    }

    std::unique_ptr<grove::IDataNode> getState() override {
        return std::make_unique<grove::JsonDataNode>("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<grove::JsonDataNode>("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<std::chrono::milliseconds>(
            end - start).count();

        return result;
    }

private:
    std::unique_ptr<grove::IDataNode> 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::milliseconds>(
                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 :

# 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

# 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

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 <noreply@anthropic.com>"

Références des modules à tester

Pour comprendre les topics IIO de chaque module :

# 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

# 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