# 🧪 Test Complet Odentas Sign + Vérification + Ledger

## 📋 Prérequis

1. **Serveur Next.js lancé** : `npm run dev`
2. **Variables d'environnement** configurées dans `.env.local` :
   ```bash
   AWS_ACCESS_KEY_ID=...
   AWS_SECRET_ACCESS_KEY=...
   AWS_REGION=eu-west-3
   ODENTAS_SIGN_BUCKET=odentas-sign
   AWS_LAMBDA_SIGN_FUNCTION=odentas-pades-sign
   NEXT_PUBLIC_APP_URL=http://localhost:3000
   ```
3. **PDF de test** : `test-contrat.pdf` à la racine du projet
4. **Migration appliquée** : `20251029_add_signature_metadata_to_signers.sql`

## 🚀 Lancer le test

```bash
node test-odentas-sign-complete.js
```

## 📖 Ce que fait le script

### Étape 1 : Préparation (automatique)
- ✅ Upload du PDF vers S3 (`source/test/TEST-xxx.pdf`)
- ✅ Création de la demande de signature avec 2 signataires

### Étape 2 : Affichage des liens
Le script affiche les 2 liens de signature :
```
1. Employeur - Odentas Paie
   http://localhost:3000/signer/[request-id]/[employeur-id]

2. Salarié - Renaud Breviere
   http://localhost:3000/signer/[request-id]/[salarie-id]
```

### Étape 3 : Signature manuelle (VOUS)

#### 3.1. Ouvrir le premier lien (Employeur)
1. Le navigateur s'ouvre sur la page de vérification OTP
2. Cliquer sur "Envoyer le code"
3. **Récupérer le code OTP dans les logs du serveur** :
   ```
   [OTP] 🔐 CODE OTP GÉNÉRÉ (MODE TEST): 123456
   ```
4. Entrer le code dans l'interface
5. Dessiner la signature
6. Valider

#### 3.2. Ouvrir le second lien (Salarié)
1. Même processus que l'employeur
2. Nouveau code OTP dans les logs
3. Signer et valider

### Étape 4 : Attente automatique
Le script vérifie toutes les 5 secondes si les 2 signatures sont complètes :
```
⏳ Signatures: 0/2 
⏳ Signatures: 1/2 
⏳ Signatures: 2/2 
✅ Toutes les signatures sont complètes !
```

### Étape 5 : Scellement PAdES (automatique)
- 🔒 Appel de l'API `/api/odentas-sign/seal-document`
- 🔒 Invocation de la Lambda `odentas-pades-sign` 2 fois :
  1. Signature Employeur avec `/Name="Odentas Paie"` et `/Reason="Signature employeur"`
  2. Signature Salarié avec `/Name="Renaud Breviere"` et `/Reason="Signature salarié"`
- ✅ PDF final avec 2 signatures PAdES : `signed-pades/TEST-xxx-final.pdf`

### Étape 6 : Création de la preuve (automatique)
- 📜 Appel de l'API `/api/signatures/create-verification`
- 📜 Création du ledger immuable dans S3 Compliance Lock :
  - **Bucket** : `odentas-signatures-ledger`
  - **Clé** : `verifications/[verification-id].json`
  - **Retention** : 10 ans (mode COMPLIANCE)
- 📄 Génération du PDF de preuve avec QR code
- ✅ Enregistrement dans Supabase `signature_verifications`

### Étape 7 : Résultats
```
🎉 TEST COMPLET RÉUSSI !

🔗 LIEN DE VÉRIFICATION PUBLIQUE:
   http://localhost:3000/verify/[verification-id]

🔒 LEDGER IMMUABLE (S3 Compliance Lock):
   Clé S3: verifications/abc-123.json
   Verrouillé jusqu'au: 29/10/2035 14:30:00
   Mode: COMPLIANCE (aucune suppression possible)

📄 PDF DE PREUVE:
   https://odentas-sign.s3.eu-west-3.amazonaws.com/evidence/proofs/...
```

## 🔍 Vérifier les résultats

### 1. Page de vérification publique
Ouvrir le lien affiché : `http://localhost:3000/verify/[id]`

Vous devriez voir :
- ✅ Badge "Signature Électronique Valide"
- ✅ Badges de conformité (PAdES ETSI, RSA 2048, SHA-256)
- ✅ Informations du document
- ✅ Sceau électronique Odentas
- ✅ Horodatage
- ✅ **Section "Preuve Immuable"** avec :
  - Statut du verrouillage (Actif)
  - Intégrité vérifiée
  - Date d'expiration (10 ans)
  - Clé S3 du ledger

### 2. Dans Supabase

```sql
-- Voir la demande
SELECT * FROM sign_requests WHERE ref LIKE 'TEST-%' ORDER BY created_at DESC LIMIT 1;

-- Voir les signataires (avec les nouvelles colonnes)
SELECT 
  role, 
  name, 
  signature_name,    -- ← Nouveau
  signature_reason,  -- ← Nouveau
  signed_at 
FROM signers 
WHERE request_id = '[request_id]';

-- Voir la preuve de vérification
SELECT * FROM signature_verifications ORDER BY created_at DESC LIMIT 1;

-- Vérifier le ledger
SELECT 
  id,
  s3_ledger_key,
  s3_ledger_locked_until,
  s3_ledger_integrity_verified
FROM signature_verifications 
WHERE s3_ledger_key IS NOT NULL
ORDER BY created_at DESC LIMIT 1;
```

### 3. Dans S3

```bash
# Voir le PDF signé final
aws s3 ls s3://odentas-sign/signed-pades/ --recursive | grep TEST

# Voir le ledger immuable
aws s3 ls s3://odentas-signatures-ledger/verifications/ --recursive

# Télécharger le ledger pour inspection
aws s3 cp s3://odentas-signatures-ledger/verifications/[id].json ./ledger-test.json

# Vérifier l'Object Lock
aws s3api head-object \
  --bucket odentas-signatures-ledger \
  --key verifications/[id].json
```

### 4. Dans Adobe Acrobat

1. Télécharger le PDF signé final depuis S3
2. Ouvrir dans Adobe Acrobat Reader
3. Panneau "Signatures" (à gauche) :
   ```
   ✓ Odentas Media SAS
     Nom: Odentas Paie              ← signature_name
     Raison: Signature employeur    ← signature_reason
     
   ✓ Odentas Media SAS
     Nom: Renaud Breviere           ← signature_name
     Raison: Signature salarié      ← signature_reason
   ```

## 🐛 Dépannage

### Le code OTP n'apparaît pas dans les logs
- Vérifier que les emails sont en mode TEST (`paie@odentas.fr` ou `@example.com`)
- Regarder les logs du serveur Next.js dans le terminal

### Erreur "Lambda invocation failed"
- Vérifier que la Lambda `odentas-pades-sign` existe
- Vérifier que les credentials AWS sont corrects
- Vérifier que la Lambda accepte le paramètre `signatureMetadata`

### Erreur "S3 bucket not found"
- Le bucket `odentas-signatures-ledger` doit exister avec Object Lock activé
- Créer avec : 
  ```bash
  aws s3api create-bucket \
    --bucket odentas-signatures-ledger \
    --region eu-west-3 \
    --create-bucket-configuration LocationConstraint=eu-west-3 \
    --object-lock-enabled-for-bucket
  ```

### Le script reste bloqué sur "En attente des signatures"
- Ouvrir les liens de signature dans le navigateur
- Signer manuellement les deux parties
- Le script vérifie toutes les 5 secondes

## 📊 Données de test générées

Après le test, vous aurez :
- `test-complete-info.json` : Infos de la demande de signature
- Entrée dans `sign_requests` (ref: TEST-xxx)
- 2 entrées dans `signers` avec `signature_name` et `signature_reason`
- Entrée dans `sign_assets` (PDF scellé)
- Entrée dans `signature_verifications` (preuve publique)
- Ledger JSON dans S3 Compliance Lock (10 ans de retention)

## 🧹 Nettoyage

```sql
-- Supprimer les données de test
DELETE FROM signature_verifications WHERE document_name LIKE '%Test%';
DELETE FROM sign_requests WHERE ref LIKE 'TEST-%';
```

```bash
# Supprimer les fichiers S3 (attention : le ledger est IMMUTABLE !)
aws s3 rm s3://odentas-sign/source/test/ --recursive
aws s3 rm s3://odentas-sign/signed-pades/ --recursive --exclude "*" --include "TEST-*"

# Le ledger ne peut PAS être supprimé (Compliance Lock activé)
# Il expirera automatiquement après 10 ans
```

## ✅ Critères de succès

Le test est réussi si :
1. ✅ Les 2 liens de signature s'affichent
2. ✅ Les 2 signatures sont enregistrées
3. ✅ Le PDF est scellé avec 2 signatures PAdES
4. ✅ La preuve de vérification est créée
5. ✅ Le ledger S3 Compliance Lock est créé (vérifiable dans S3)
6. ✅ La page de vérification affiche correctement toutes les infos
7. ✅ Le PDF ouvert dans Adobe montre 2 signatures avec les bons noms
8. ✅ Le ledger est verrouillé pour 10 ans (mode COMPLIANCE)

---

**Note** : Ce test utilise des données réelles (vraie Lambda, vrai S3, vraie signature PAdES). Le ledger créé sera **réellement immutable pendant 10 ans**.