rpa_vision_v3/docs/guides/SERVER_TESTING_GUIDE.md

# Guide de Test - Serveur RPA Vision V3

**Guide complet pour tester le système serveur (API + Dashboard + Pipeline)**

## 🎯 Vue d'ensemble

Le système serveur comprend 3 composants principaux:

1. **API Upload** (port 8000) - Reçoit les sessions chiffrées de l'agent
2. **Dashboard Web** (port 5001) - Interface de monitoring et gestion
3. **Pipeline de traitement** - Transforme les sessions en données exploitables

## 📋 Prérequis

```bash
# Activer l'environnement virtuel
source venv_v3/bin/activate

# Installer les dépendances serveur
pip install -r server/requirements_server.txt
pip install -r web_dashboard/requirements.txt

# Vérifier l'installation
python -c "import fastapi, flask, cryptography; print('✅ Dépendances OK')"
```

## 🚀 Démarrage Rapide

### Option 1: Script automatique (recommandé)

```bash
# Démarrer API + Dashboard
./server/start_all.sh
```

**Sortie attendue:**
```
========================================
RPA Vision V3 - Démarrage Complet
========================================

✅ API démarrée (PID: 12345)
✅ Dashboard démarré (PID: 12346)

🌐 URLs:
  API:       http://localhost:8000
  Dashboard: http://localhost:5001
```

### Option 2: Démarrage manuel

**Terminal 1 - API:**
```bash
cd server
python api_upload.py
```

**Terminal 2 - Dashboard:**
```bash
cd web_dashboard
python app.py
```

## ✅ Tests Unitaires

### 1. Test du module de chiffrement/déchiffrement

```bash
# Créer un fichier de test
echo "test data" > /tmp/test.txt
zip /tmp/test.zip /tmp/test.txt

# Chiffrer (depuis agent_v0)
cd agent_v0
python storage_encrypted.py /tmp/test.zip test_password

# Déchiffrer (depuis server)
cd ../server
python storage_encrypted.py /tmp/test.zip.enc test_password

# Vérifier
unzip -l /tmp/test.zip
```

**Résultat attendu:**
```
✅ Chiffrement réussi: /tmp/test.zip.enc
✅ Déchiffrement réussi: /tmp/test.zip
```

### 2. Test du pipeline de traitement

```bash
# Lancer les tests d'intégration
pytest tests/integration/test_server_pipeline.py -v
```

**Tests exécutés:**
- ✅ Chiffrement/déchiffrement round-trip
- ✅ Déchiffrement avec mauvais mot de passe (doit échouer)
- ✅ Pipeline de traitement basique
- ✅ Gestion des erreurs (session manquante, JSON corrompu)

### 3. Test de l'API

```bash
# Test 1: Status de l'API
curl http://localhost:8000/api/traces/status

# Résultat attendu:
# {
#   "status": "online",
#   "version": "1.0.0",
#   "upload_dir": "...",
#   "encryption_enabled": false
# }

# Test 2: Liste des sessions
curl http://localhost:8000/api/traces/sessions

# Résultat attendu:
# {
#   "sessions": [],
#   "total": 0
# }
```

### 4. Test du Dashboard

```bash
# Ouvrir dans un navigateur
xdg-open http://localhost:5001

# Ou avec curl
curl http://localhost:5001/api/system/status
```

**Interface attendue:**
- 📊 Vue d'ensemble (statut système)
- 📦 Sessions Agent (liste des sessions)
- 🧪 Tests (lancer les tests)
- 📝 Logs (voir les logs)

## 🔄 Test du Flux Complet

### Scénario: Upload d'une session depuis l'agent

**1. Créer une session de test avec l'agent:**

```bash
cd agent_v0

# Enregistrer une session de test (10 secondes)
python agent_v0.py --duration 10 --label "test_workflow"

# Résultat: session_YYYYMMDD_HHMMSS.zip.enc
```

**2. Uploader vers le serveur:**

```bash
# Méthode 1: Avec curl
SESSION_FILE="session_20251125_143022.zip.enc"
SESSION_ID="session_20251125_143022"

curl -X POST http://localhost:8000/api/traces/upload \
  -F "file=@$SESSION_FILE" \
  -F "session_id=$SESSION_ID"

# Méthode 2: Avec l'agent (si configuré)
# L'agent uploade automatiquement si server_url est configuré
```

**Résultat attendu:**
```json
{
  "status": "success",
  "session_id": "session_20251125_143022",
  "events_count": 42,
  "screenshots_count": 15,
  "user": {"id": "user123", "label": "Test User"},
  "received_at": "2025-11-25T14:30:45.123456"
}
```

**3. Vérifier dans le Dashboard:**

```bash
# Ouvrir le dashboard
xdg-open http://localhost:5001

# Aller dans l'onglet "📦 Sessions Agent"
# La session devrait apparaître dans la liste
```

**4. Traiter la session:**

Dans le Dashboard:
1. Cliquer sur "⚙️ Traiter" pour la session
2. Le pipeline va:
   - Construire les ScreenStates
   - Générer les embeddings (si CLIP disponible)
   - Détecter les UI (si modèles disponibles)
   - Construire le workflow

**5. Vérifier les logs:**

```bash
# Logs API
tail -f logs/api.log

# Logs Dashboard
tail -f logs/dashboard.log

# Ou dans le Dashboard, onglet "📝 Logs"
```

## 🧪 Tests Automatisés

### Suite complète de tests

```bash
# Tous les tests d'intégration serveur
pytest tests/integration/test_server_pipeline.py -v

# Avec couverture
pytest tests/integration/test_server_pipeline.py --cov=server --cov-report=html

# Ouvrir le rapport
xdg-open htmlcov/index.html
```

### Tests individuels

```bash
# Test chiffrement/déchiffrement
pytest tests/integration/test_server_pipeline.py::test_encryption_decryption_roundtrip -v

# Test pipeline
pytest tests/integration/test_server_pipeline.py::test_processing_pipeline_basic -v

# Test gestion erreurs
pytest tests/integration/test_server_pipeline.py::test_processing_pipeline_missing_session -v
```

## 🔒 Test de Sécurité

### 1. Test du chiffrement

```bash
# Créer un fichier avec données sensibles
echo "Données confidentielles: password123" > /tmp/secret.txt
zip /tmp/secret.zip /tmp/secret.txt

# Chiffrer
cd agent_v0
python storage_encrypted.py /tmp/secret.zip "strong_password_2025"

# Vérifier que le fichier .enc n'est pas lisible
cat /tmp/secret.zip.enc
# Devrait afficher du binaire illisible

# Déchiffrer avec bon mot de passe
cd ../server
python storage_encrypted.py /tmp/secret.zip.enc "strong_password_2025"

# Vérifier le contenu
unzip -p /tmp/secret.zip secret.txt
# Devrait afficher: "Données confidentielles: password123"
```

### 2. Test avec mauvais mot de passe

```bash
# Tenter de déchiffrer avec mauvais mot de passe
python storage_encrypted.py /tmp/secret.zip.enc "wrong_password"

# Résultat attendu:
# ❌ Erreur: Erreur déchiffrement (mot de passe incorrect?)
```

### 3. Test de taille de fichier

```bash
# Créer un gros fichier (50 MB)
dd if=/dev/urandom of=/tmp/large.bin bs=1M count=50
zip /tmp/large.zip /tmp/large.bin

# Chiffrer
cd agent_v0
python storage_encrypted.py /tmp/large.zip "test_password"

# Uploader (vérifier que ça passe)
curl -X POST http://localhost:8000/api/traces/upload \
  -F "file=@/tmp/large.zip.enc" \
  -F "session_id=large_test" \
  --max-time 300

# Note: Nginx limite à 100MB par défaut
```

## 📊 Tests de Performance

### 1. Test de charge API

```bash
# Installer Apache Bench
sudo apt install apache2-utils

# Test: 100 requêtes, 10 concurrentes
ab -n 100 -c 10 http://localhost:8000/api/traces/status

# Résultat attendu:
# Requests per second: > 100
# Time per request: < 100ms
```

### 2. Test de traitement de session

```bash
# Mesurer le temps de traitement
time python -c "
from server.processing_pipeline import process_session_async
stats = process_session_async('session_20251125_143022', 'data/training')
print(f'ScreenStates: {stats[\"screen_states_created\"]}')
print(f'Embeddings: {stats[\"embeddings_generated\"]}')
"

# Temps attendu (dépend du matériel):
# - Sans embeddings: < 1s
# - Avec embeddings: 2-5s par screenshot
```

## 🐛 Troubleshooting

### Problème: API ne démarre pas

```bash
# Vérifier le port
netstat -tlnp | grep 8000

# Si occupé, tuer le processus
kill $(lsof -t -i:8000)

# Vérifier les logs
cat logs/api.log
```

### Problème: Dashboard ne démarre pas

```bash
# Vérifier le port
netstat -tlnp | grep 5001

# Vérifier les dépendances
pip list | grep -i flask

# Réinstaller si nécessaire
pip install --force-reinstall Flask
```

### Problème: Déchiffrement échoue

```bash
# Vérifier le mot de passe
echo $ENCRYPTION_PASSWORD

# Tester manuellement
cd server
python storage_encrypted.py /path/to/file.enc "votre_password"

# Vérifier l'intégrité du fichier
file /path/to/file.enc
# Devrait afficher: "data"
```

### Problème: Pipeline échoue

```bash
# Vérifier les dépendances
python -c "import torch, clip, faiss; print('OK')"

# Vérifier les modèles
ls -lh models/

# Voir les logs détaillés
tail -f logs/api.log | grep -i error
```

## 📝 Checklist de Test

Avant de déployer en production:

- [ ] ✅ API démarre sans erreur
- [ ] ✅ Dashboard démarre sans erreur
- [ ] ✅ Test chiffrement/déchiffrement réussi
- [ ] ✅ Upload de session réussi
- [ ] ✅ Pipeline de traitement réussi
- [ ] ✅ Tests unitaires passent (pytest)
- [ ] ✅ Tests d'intégration passent
- [ ] ✅ Test avec mauvais mot de passe échoue correctement
- [ ] ✅ Dashboard affiche les sessions
- [ ] ✅ Logs accessibles et lisibles
- [ ] ✅ Mot de passe de production configuré (pas le défaut!)
- [ ] ✅ Firewall configuré (si production)
- [ ] ✅ HTTPS configuré (si production)

## 🎯 Résultats Attendus

**Après tous les tests:**

```
✅ API fonctionnelle (http://localhost:8000)
✅ Dashboard fonctionnel (http://localhost:5001)
✅ Chiffrement/déchiffrement opérationnel
✅ Pipeline de traitement opérationnel
✅ Tests automatisés passent
✅ Gestion d'erreurs robuste
✅ Logs disponibles et informatifs
```

**Le système est prêt pour:**
- Recevoir des sessions de l'agent
- Les déchiffrer automatiquement
- Les traiter avec le pipeline
- Les afficher dans le dashboard
- Être déployé en production (avec HTTPS)

---

**Besoin d'aide?**
- Logs API: `tail -f logs/api.log`
- Logs Dashboard: `tail -f logs/dashboard.log`
- Tests: `pytest tests/integration/test_server_pipeline.py -v`