# Instructions de Test Final - Lions User Manager

**Date**: 2025-12-05
**Statut**: Toutes les corrections appliquées ✅

---

## 🎯 Résumé des Corrections Appliquées

### ✅ Problème 1: Rôles Keycloak Manquants
- Créé 5 rôles métier: admin, user_manager, user_viewer, auditor, sync_manager
- Assigné tous les rôles à testuser
- Script: `create-roles-and-assign.sh`

### ✅ Problème 2: KeycloakTestUserConfig - Erreur bruteForceStrategy
- Désactivé la configuration automatique
- Fichier: `KeycloakTestUserConfig.java:62-68`

### ✅ Problème 3: Extraction des Rôles depuis ID Token
- Configuré extraction depuis access_token
- Propriété: `quarkus.oidc.roles.source=accesstoken`
- Fichier frontend: `application.properties:64`

### ✅ Problème 4: Propagation du Token JWT
- Créé `AuthHeaderFactory` pour injection automatique du token
- Enregistré sur tous les REST Clients
- Fichiers: `AuthHeaderFactory.java` + 4 REST Clients

### ✅ Problème 5: Vérification de l'Audience JWT
- Configuré backend pour accepter audience "account"
- Propriété: `quarkus.oidc.token.audience=account`
- Fichier backend: `application-dev.properties:25`

---

## 🚀 Test Complet - Étape par Étape

### Prérequis

1. **Keycloak** doit être démarré sur port 8180
2. **Backend** doit être démarré sur port 8081
3. **Frontend** doit être démarré sur port 8080

Si ce n'est pas le cas, suivre les instructions de démarrage ci-dessous.

---

### Démarrage des Services

#### 1. Keycloak (si nécessaire)
```bash
cd /path/to/keycloak
bin/kc.sh start-dev --http-port=8180
```

Vérifier: http://localhost:8180 → Console admin accessible

#### 2. Backend
```bash
cd lions-user-manager-server-impl-quarkus
mvn clean compile quarkus:dev
```

**Attendre les logs suivants**:
```
✓ Configuration automatique de Keycloak DÉSACTIVÉE
✓ Client Keycloak initialisé (connexion lazy)
✓ Listening on: http://localhost:8081
```

**NE PAS voir**:
```
❌ ERROR UnrecognizedPropertyException: bruteForceStrategy
```

#### 3. Frontend
```bash
cd lions-user-manager-client-quarkus-primefaces-freya
mvn clean compile quarkus:dev
```

**Attendre les logs suivants**:
```
✓ Listening on: http://localhost:8080
```

---

### Test 1: Authentification OIDC

#### Étape 1.1: Se Déconnecter (Important!)
**Pourquoi?** Pour obtenir un nouveau token avec les nouveaux rôles et la nouvelle configuration.

1. Accéder à http://localhost:8080
2. Si déjà connecté, cliquer sur le bouton de déconnexion
3. Ou accéder directement à: http://localhost:8080/q/oidc/logout

#### Étape 1.2: Se Reconnecter
1. Accéder à http://localhost:8080
2. Vous devez être redirigé vers Keycloak
3. Entrer les identifiants:
   - **Username**: `testuser`
   - **Password**: `test123`
4. Cliquer sur "Sign In"
5. Vous devez être redirigé vers http://localhost:8080

**✅ Résultat attendu**: Connexion réussie, page d'accueil affichée

**❌ Échec possible**:
- Si Keycloak ne redirige pas → Vérifier configuration OIDC frontend
- Si "Invalid credentials" → Vérifier que testuser existe dans Keycloak

#### Étape 1.3: Vérifier le Token JWT (optionnel)
1. Ouvrir DevTools (F12)
2. Onglet **Network**
3. Cocher "Preserve log"
4. Rafraîchir la page (F5)
5. Chercher une requête vers `/q/oidc/callback` ou `/token`
6. Copier le paramètre `access_token` depuis la réponse
7. Aller sur https://jwt.io
8. Coller le token dans le décodeur
9. Vérifier les claims:
```json
{
  "realm_access": {
    "roles": [
      "admin",
      "user_manager",
      "user_viewer",
      "auditor",
      "sync_manager",
      "offline_access",
      "uma_authorization",
      "default-roles-lions-user-manager"
    ]
  },
  "aud": "account",
  "iss": "http://localhost:8180/realms/lions-user-manager"
}
```

**✅ Résultat attendu**: Token contient les 5 rôles métier + rôles par défaut

---

### Test 2: Appel Backend - Liste des Utilisateurs

#### Étape 2.1: Naviguer vers la Liste des Utilisateurs
1. Une fois connecté sur http://localhost:8080
2. Naviguer vers: http://localhost:8080/pages/user-manager/users/list.xhtml

**✅ Résultat attendu**:
- Page se charge sans erreur
- Liste des utilisateurs s'affiche (peut être vide si aucun utilisateur dans le realm)
- Aucun message d'erreur 401 Unauthorized

**❌ Échec possible**:
- Erreur 401 → Vérifier logs backend et frontend (voir section Debugging)
- Page blanche → Vérifier logs JSF dans le frontend
- Timeout → Vérifier que le backend est démarré

#### Étape 2.2: Vérifier les Logs Frontend
Chercher dans la console du frontend (terminal où mvn quarkus:dev tourne):

**✅ Logs attendus**:
```
FINE Token Bearer ajouté au header Authorization
DEBUG Chargement de X utilisateurs
```

**❌ Logs problématiques**:
```
WARNING Token JWT non disponible ou vide
SEVERE Erreur lors du chargement des utilisateurs: Received: 'Unauthorized, status code 401'
```

#### Étape 2.3: Vérifier les Logs Backend
Chercher dans la console du backend:

**✅ Logs attendus**:
```
DEBUG [io.qu.oi.ru.BearerAuthenticationMechanism] Starting a bearer access token authentication
DEBUG [io.qu.oi.ru.OidcIdentityProvider] Starting creating SecurityIdentity
DEBUG [io.qu.oi.ru.OidcIdentityProvider] Token verification succeeded
DEBUG Recherche d'utilisateurs avec critères: UserSearchCriteriaDTO(realmName=master, ...)
INFO Found X users in realm master
```

**❌ Logs problématiques**:
```
ERROR Bearer access token is not available
ERROR Audience (aud) claim [account] doesn't contain an acceptable identifier
ERROR Token verification has failed
```

---

### Test 3: Opérations CRUD

#### Étape 3.1: Rechercher un Utilisateur
1. Sur la page `/pages/user-manager/users/list.xhtml`
2. Entrer un terme de recherche dans le champ "Rechercher"
3. Cliquer sur "Rechercher"

**✅ Résultat attendu**: Liste filtrée affichée sans erreur

#### Étape 3.2: Activer/Désactiver un Utilisateur
1. Cliquer sur le bouton "Activer" ou "Désactiver" d'un utilisateur
2. Vérifier le message de succès

**✅ Résultat attendu**: Message "Utilisateur activé/désactivé avec succès"

#### Étape 3.3: Supprimer un Utilisateur (optionnel)
**⚠️ Attention**: Ne supprimez PAS testuser!

1. Cliquer sur le bouton "Supprimer" d'un utilisateur
2. Confirmer la suppression

**✅ Résultat attendu**: Message "Utilisateur supprimé avec succès"

---

### Test 4: Vérifier les Rôles et Autorisations

#### Étape 4.1: Accès aux Pages Protégées
1. Tester l'accès à différentes pages:
   - http://localhost:8080/pages/user-manager/users/list.xhtml
   - http://localhost:8080/pages/user-manager/roles/list.xhtml
   - http://localhost:8080/pages/user-manager/audit/list.xhtml

**✅ Résultat attendu**: Toutes les pages accessibles (testuser a tous les rôles)

#### Étape 4.2: Test avec un Utilisateur sans Rôles (optionnel)
1. Via Keycloak Admin Console, créer un nouvel utilisateur sans rôles
2. Se déconnecter de testuser
3. Se connecter avec le nouvel utilisateur
4. Essayer d'accéder aux pages protégées

**✅ Résultat attendu**: Accès refusé ou 403 Forbidden (selon configuration)

---

## 🐛 Debugging - Problèmes Courants

### Problème 1: "Token JWT non disponible ou vide"

**Cause**: `JsonWebToken` non injecté dans le contexte CDI

**Solutions**:
1. Vérifier que l'utilisateur est connecté
2. Se déconnecter et reconnecter
3. Redémarrer le frontend:
   ```bash
   # Arrêter (Ctrl+C)
   cd lions-user-manager-client-quarkus-primefaces-freya
   mvn clean compile quarkus:dev
   ```

### Problème 2: "Bearer access token is not available"

**Cause**: Token pas envoyé au backend OU AuthHeaderFactory pas actif

**Solutions**:
1. Vérifier que `AuthHeaderFactory` est compilé:
   ```bash
   cd lions-user-manager-client-quarkus-primefaces-freya
   mvn compile
   ```
2. Vérifier que les REST Clients ont `@RegisterClientHeaders(AuthHeaderFactory.class)`
3. Redémarrer le frontend pour forcer le rechargement

### Problème 3: "Audience (aud) claim doesn't contain..."

**Cause**: Backend attend une audience différente

**Solutions**:
1. Vérifier `application-dev.properties:25` du backend:
   ```properties
   quarkus.oidc.token.audience=account
   ```
2. Si modifié, redémarrer le backend:
   ```bash
   # Arrêter (Ctrl+C)
   cd lions-user-manager-server-impl-quarkus
   mvn clean compile quarkus:dev
   ```

### Problème 4: "No claim exists at the path 'realm_access/roles'"

**Cause**: Rôles extraits depuis id_token au lieu de access_token

**Solutions**:
1. Vérifier `application.properties:64` du frontend:
   ```properties
   quarkus.oidc.roles.source=accesstoken
   ```
2. Se déconnecter et reconnecter pour obtenir un nouveau token
3. Vérifier le token sur jwt.io (doit contenir realm_access.roles)

### Problème 5: Hot Reload ne fonctionne pas

**Cause**: Quarkus dev mode n'a pas détecté les changements

**Solution**: Force clean + recompile
```bash
# Frontend
cd lions-user-manager-client-quarkus-primefaces-freya
mvn clean compile quarkus:dev

# Backend
cd lions-user-manager-server-impl-quarkus
mvn clean compile quarkus:dev
```

---

## 📊 Checklist de Validation Complète

### Configuration Keycloak
- [x] Realm `lions-user-manager` existe
- [x] Client `lions-user-manager-client` configuré
- [x] 5 rôles métier créés: admin, user_manager, user_viewer, auditor, sync_manager
- [x] testuser existe avec password `test123`
- [x] testuser possède tous les rôles

### Configuration Backend
- [x] Port 8081
- [x] `KeycloakTestUserConfig` désactivé (pas d'erreur bruteForceStrategy)
- [x] `quarkus.oidc.token.audience=account` configuré
- [x] Démarre sans erreur
- [x] Health check OK: http://localhost:8081/q/health

### Configuration Frontend
- [x] Port 8080
- [x] `AuthHeaderFactory` créé
- [x] Tous les REST Clients annotés avec `@RegisterClientHeaders`
- [x] `quarkus.oidc.roles.source=accesstoken` configuré
- [x] Démarre sans erreur

### Test d'Authentification
- [ ] Déconnexion réussie
- [ ] Reconnexion avec testuser/test123 réussie
- [ ] Token JWT contient les 5 rôles métier
- [ ] Token contient `"aud": "account"`

### Test d'Intégration Frontend ↔ Backend
- [ ] Liste des utilisateurs se charge sans 401
- [ ] Logs frontend: "Token Bearer ajouté au header Authorization"
- [ ] Logs backend: "Token verification succeeded"
- [ ] Pas d'erreur "Bearer access token is not available"
- [ ] Pas d'erreur "Audience (aud) claim..."

### Test des Opérations
- [ ] Recherche d'utilisateurs fonctionne
- [ ] Activation/Désactivation fonctionne
- [ ] Suppression fonctionne (testé sur un utilisateur non-critique)
- [ ] Messages de succès affichés correctement

---

## 🎉 Félicitations!

Si tous les tests passent, votre application Lions User Manager est maintenant pleinement fonctionnelle avec:

✅ Authentification OIDC avec Keycloak
✅ Propagation automatique du token JWT
✅ Gestion des rôles et autorisations
✅ CRUD complet sur les utilisateurs
✅ Intégration frontend-backend sécurisée

---

## 📞 Support

En cas de problème:

1. Consulter les documents:
   - `CORRECTIONS_FINALES.md` - Résumé de toutes les corrections
   - `SOLUTION_PROPAGATION_TOKEN.md` - Détails sur la propagation du token
   - `ETAT_FINAL.md` - État du projet

2. Vérifier les logs:
   - Frontend: Console où `mvn quarkus:dev` tourne
   - Backend: Console où `mvn quarkus:dev` tourne
   - Keycloak: Logs dans `/path/to/keycloak/logs/`

3. Vérifier les ports:
   - Keycloak: http://localhost:8180
   - Backend: http://localhost:8081
   - Frontend: http://localhost:8080

---

**Auteur**: Claude Code
**Date**: 2025-12-05
**Version**: 1.0.0