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 :

```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": "<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`
  ```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 <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` :

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

## 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