4NK_IA_back/scripts/test-integration.sh

#!/bin/bash
# Script de test d'intégration pour 4NK IA Backend
# Usage: ./scripts/test-integration.sh

set -e

# Couleurs pour les messages
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Configuration
API_BASE_URL="http://localhost:8000"
TEST_DOCUMENT="test-document.pdf"
TEST_DOCUMENT_ID=""

# Fonction pour afficher les messages
log_info() {
    echo -e "${BLUE}[INFO]${NC} $1"
}

log_success() {
    echo -e "${GREEN}[SUCCESS]${NC} $1"
}

log_warning() {
    echo -e "${YELLOW}[WARNING]${NC} $1"
}

log_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

# Compteur de tests
TESTS_PASSED=0
TESTS_FAILED=0

# Fonction pour exécuter un test
run_test() {
    local test_name="$1"
    local test_command="$2"
    
    log_info "Test: $test_name"
    
    if eval "$test_command" > /dev/null 2>&1; then
        log_success "✅ $test_name"
        ((TESTS_PASSED++))
    else
        log_error "❌ $test_name"
        ((TESTS_FAILED++))
    fi
}

# Fonction pour créer un document de test
create_test_document() {
    log_info "Création d'un document de test..."
    
    # Créer un PDF simple avec du texte
    cat > test-document.txt << EOF
ACTE DE VENTE

Entre les soussignés :
- Vendeur : Jean DUPONT, né le 15/05/1980 à Paris
- Acheteur : Marie MARTIN, née le 22/03/1985 à Lyon

Il est convenu ce qui suit :

Article 1 - Objet de la vente
Le vendeur vend à l'acheteur l'appartement situé :
123 Rue de la Paix, 75001 Paris
Surface : 75 m²
Référence cadastrale : 1234567890AB

Article 2 - Prix
Le prix de vente est fixé à la somme de 250 000 euros.

Article 3 - Conditions
La vente est conclue sous condition suspensive d'obtention du prêt.

Fait à Paris, le 15 janvier 2024

Signatures :
Jean DUPONT                    Marie MARTIN
EOF
    
    # Convertir en PDF si possible
    if command -v enscript > /dev/null 2>&1; then
        enscript -p "$TEST_DOCUMENT" test-document.txt
    else
        # Créer un fichier PDF simple
        cp test-document.txt "$TEST_DOCUMENT"
    fi
    
    rm test-document.txt
}

# Fonction pour tester le workflow complet
test_complete_workflow() {
    log_info "=== Test du workflow complet ==="
    
    # 1. Upload du document
    log_info "Étape 1: Upload du document"
    local upload_response=$(curl -s -X POST "$API_BASE_URL/api/notary/upload" \
        -F "file=@$TEST_DOCUMENT" \
        -F "id_dossier=INTEGRATION-001" \
        -F "etude_id=ETUDE-001" \
        -F "utilisateur_id=USER-001")
    
    if echo "$upload_response" | grep -q "document_id"; then
        TEST_DOCUMENT_ID=$(echo "$upload_response" | grep -o '"document_id":"[^"]*"' | cut -d'"' -f4)
        log_success "✅ Document uploadé avec l'ID: $TEST_DOCUMENT_ID"
        ((TESTS_PASSED++))
    else
        log_error "❌ Échec de l'upload du document"
        ((TESTS_FAILED++))
        return
    fi
    
    # 2. Attendre le traitement
    log_info "Étape 2: Attente du traitement du document"
    local max_attempts=30
    local attempt=0
    
    while [ $attempt -lt $max_attempts ]; do
        local status_response=$(curl -s "$API_BASE_URL/api/notary/documents/$TEST_DOCUMENT_ID")
        
        if echo "$status_response" | grep -q '"status":"completed"'; then
            log_success "✅ Document traité avec succès"
            ((TESTS_PASSED++))
            break
        elif echo "$status_response" | grep -q '"status":"failed"'; then
            log_error "❌ Échec du traitement du document"
            ((TESTS_FAILED++))
            return
        else
            log_info "Traitement en cours... (tentative $((attempt + 1))/$max_attempts)"
            sleep 2
            ((attempt++))
        fi
    done
    
    if [ $attempt -eq $max_attempts ]; then
        log_warning "⚠️ Timeout du traitement du document"
        ((TESTS_FAILED++))
    fi
    
    # 3. Extraction des données
    log_info "Étape 3: Extraction des données"
    local extract_response=$(curl -s "$API_BASE_URL/api/documents/$TEST_DOCUMENT_ID/extract")
    
    if echo "$extract_response" | grep -q "identities"; then
        log_success "✅ Extraction des données réussie"
        ((TESTS_PASSED++))
    else
        log_error "❌ Échec de l'extraction des données"
        ((TESTS_FAILED++))
    fi
    
    # 4. Analyse du document
    log_info "Étape 4: Analyse du document"
    local analyze_response=$(curl -s "$API_BASE_URL/api/documents/$TEST_DOCUMENT_ID/analyze")
    
    if echo "$analyze_response" | grep -q "credibilityScore"; then
        log_success "✅ Analyse du document réussie"
        ((TESTS_PASSED++))
    else
        log_error "❌ Échec de l'analyse du document"
        ((TESTS_FAILED++))
    fi
    
    # 5. Contexte du document
    log_info "Étape 5: Récupération du contexte"
    local context_response=$(curl -s "$API_BASE_URL/api/documents/$TEST_DOCUMENT_ID/context")
    
    if echo "$context_response" | grep -q "cadastreData"; then
        log_success "✅ Contexte du document récupéré"
        ((TESTS_PASSED++))
    else
        log_error "❌ Échec de la récupération du contexte"
        ((TESTS_FAILED++))
    fi
    
    # 6. Conseil du document
    log_info "Étape 6: Génération du conseil"
    local conseil_response=$(curl -s "$API_BASE_URL/api/documents/$TEST_DOCUMENT_ID/conseil")
    
    if echo "$conseil_response" | grep -q "recommendations"; then
        log_success "✅ Conseil généré avec succès"
        ((TESTS_PASSED++))
    else
        log_error "❌ Échec de la génération du conseil"
        ((TESTS_FAILED++))
    fi
}

# Fonction pour tester la persistance des données
test_data_persistence() {
    log_info "=== Test de persistance des données ==="
    
    if [ -n "$TEST_DOCUMENT_ID" ]; then
        # Vérifier que le document est toujours accessible
        run_test "Document accessible après traitement" "curl -f $API_BASE_URL/api/notary/documents/$TEST_DOCUMENT_ID"
        
        # Vérifier que les données extraites sont persistantes
        run_test "Données extraites persistantes" "curl -f $API_BASE_URL/api/documents/$TEST_DOCUMENT_ID/extract"
    else
        log_warning "Aucun document de test disponible pour la persistance"
    fi
}

# Fonction pour tester la performance
test_performance() {
    log_info "=== Test de performance ==="
    
    # Test de charge simple
    local start_time=$(date +%s)
    
    for i in {1..10}; do
        curl -s "$API_BASE_URL/api/health" > /dev/null
    done
    
    local end_time=$(date +%s)
    local total_time=$((end_time - start_time))
    local avg_time=$((total_time / 10))
    
    if [ $avg_time -lt 2 ]; then
        log_success "✅ Performance acceptable: ${avg_time}s par requête"
        ((TESTS_PASSED++))
    else
        log_warning "⚠️ Performance lente: ${avg_time}s par requête"
        ((TESTS_FAILED++))
    fi
}

# Fonction pour tester la robustesse
test_robustness() {
    log_info "=== Test de robustesse ==="
    
    # Test avec des données invalides
    run_test "Gestion des requêtes invalides" "curl -s -X POST $API_BASE_URL/api/notary/upload -F 'file=' | grep -q 'error'"
    
    # Test avec des IDs inexistants
    run_test "Gestion des IDs inexistants" "curl -s $API_BASE_URL/api/documents/invalid-id/extract | grep -q '404'"
}

# Fonction pour nettoyer les fichiers de test
cleanup() {
    log_info "Nettoyage des fichiers de test..."
    rm -f "$TEST_DOCUMENT"
}

# Fonction pour afficher le résumé
show_summary() {
    echo ""
    log_info "=== Résumé des tests d'intégration ==="
    echo ""
    echo "Tests réussis: $TESTS_PASSED"
    echo "Tests échoués: $TESTS_FAILED"
    echo "Total: $((TESTS_PASSED + TESTS_FAILED))"
    echo ""
    
    if [ $TESTS_FAILED -eq 0 ]; then
        log_success "🎉 Tous les tests d'intégration sont passés !"
        echo ""
        echo "Le système est prêt pour la production."
    else
        log_error "❌ Certains tests d'intégration ont échoué."
        echo ""
        echo "Vérifiez les logs et la configuration avant la mise en production."
    fi
}

# Fonction principale
main() {
    echo "🧪 Test d'intégration de 4NK IA Backend"
    echo ""
    
    # Vérifier que l'API est accessible
    if ! curl -f "$API_BASE_URL/api/health" > /dev/null 2>&1; then
        log_error "L'API n'est pas accessible sur $API_BASE_URL"
        log_info "Veuillez démarrer les services avec: ./scripts/quick-start.sh"
        exit 1
    fi
    
    create_test_document
    test_complete_workflow
    test_data_persistence
    test_performance
    test_robustness
    cleanup
    show_summary
}

# Gestion des signaux pour le nettoyage
trap cleanup EXIT

# Exécution
main "$@"