Guide d'utilisation du Rejeu combiné

Version du document : 20260729

Versions de l'application prises en charge par ce document :

• iOS : >= 3.13
• Android : >= 1.2.0

Le Rejeu combiné (Combo Replay) permet d'orchestrer plusieurs requêtes HTTP/HTTPS en un seul « flux », exécutées automatiquement en série ou en parallèle selon leurs dépendances. Idéal pour les tests d'intégration d'API, les tests de régression et la validation par lot de différentes entrées pour une même API.

1. Aperçu des fonctionnalités

2. Démarrage rapide

Étape 1 : Capturer d'abord

Les requêtes du Rejeu combiné proviennent de l'historique de capture. Commencez par capturer un lot de requêtes HTTP/HTTPS dans l'application (les requêtes WebSocket ne peuvent pas être ajoutées).

Étape 2 : Créer une règle

1. Ouvrir la liste Rejeu combiné
2. Appuyer sur + pour ajouter une règle de rejeu combiné
3. Saisir un nom de règle (obligatoire ; par défaut, un nom du type Combo Replay 260729)
4. Appuyer sur + en bas à droite pour ajouter des requêtes au canevas
5. Sélectionner les requêtes nécessaires dans la liste

Étape 3 : Exécuter

1. Enregistrer la règle (✓ en haut à droite de l'éditeur)
2. Appuyer sur le nom de la règle dans la liste pour ouvrir la page d'exécution
3. Appuyer sur Exécuter le rejeu

Une fois l'exécution terminée, les nœuds affichent leur statut succès/échec ; appuyez sur un nœud pour voir les détails.

3. Gestion des règles

3.1 Informations de la liste

Chaque carte de règle affiche :

• Nom de la règle
• Nombre de nœuds
• Aperçu des chemins (jusqu'à 3)
• Nombre de dépendances et de mappages de paramètres
• Dernière mise à jour

3.2 Créer / Modifier / Supprimer

Les règles sont stockées localement et seront perdues en cas de désinstallation de l'application ou de suppression des données.

4. Édition des règles combinées

4.1 Ajouter des requêtes

• Appuyer sur le bouton flottant + en bas à droite
• Recherche par URL / Method
• Filtrage par Session, Host, type, code de statut

La même API peut être ajoutée plusieurs fois : par exemple, ajouter 3 nœuds /api/order pour tester un cas normal, une valeur limite et des paramètres invalides.

4.2 Menu du nœud

Appuyer sur un nœud pour ouvrir le menu :

Faire glisser les nœuds pour les repositionner ; appuyer sur une zone vide pour désélectionner ou quitter le mode liaison.

5. Paramètres prédéfinis

Utilisés lors de l'édition de la règle pour fixer les données de test de chaque nœud — particulièrement adaptés aux scénarios « même API, entrées différentes ».

5.1 Étapes

1. Appuyer sur le nœud → Paramètres prédéfinis
2. Modifier Paramètres de requête / En-têtes / Corps
3. Une fois terminé, appuyer sur ✓ en haut à droite de la feuille pour enregistrer dans la règle

5.2 Différence avec « Modifier la requête » sur la page d'exécution

5.3 Exemple : plusieurs scénarios pour une même API

Nœud A : POST /api/login     → body : identifiants valides
Nœud B : POST /api/login     → body : mot de passe incorrect
Nœud C : POST /api/login     → body : mot de passe vide
(3 nœuds sans dépendance → exécution parallèle)

5.4 Prise en charge de l'injection d'expressions

Voir : Section 8, Injection d'expressions

6. Dépendances

6.1 Signification

Une liaison A → B signifie : A dépend de B ; B s'exécute d'abord, A ensuite.

La flèche va du nœud aval (A) vers le nœud amont (B).

6.2 Créer une dépendance

1. Appuyer sur le nœud aval → Définir une dépendance
2. Un message bleu apparaît en haut : « Appuyez sur le nœud cible pour créer une dépendance »
3. Appuyer sur le nœud amont
4. Une ligne de liaison apparaît

6.3 Limites

• Impossible de créer deux fois la même dépendance
• Impossible de former une boucle
• Supprimer une liaison supprime aussi les mappages de paramètres associés

6.4 Ordre d'exécution

        ┌─ Nœud B ─┐
Nœud A ─┤          ├─ Parallèle (même couche)
        └─ Nœud C ─┘
              ↓
           Nœud D (s'exécute après le succès de A et C)

• Même couche (sans dépendance mutuelle) : exécution parallèle
• Couches différentes (avec dépendances) : exécution série, la couche suivante ne démarre qu'après le succès complet de la précédente
• Échec dans une couche : tous les nœuds suivants sont marqués ignorés

7. Injection de dépendances (Mappage de paramètres)

Permet de transmettre automatiquement token, userId, etc. depuis les réponses amont vers les requêtes aval.

7.1 Prérequis

Le nœud cible doit avoir au moins une dépendance amont, sinon le message « Aucun nœud amont, créez d'abord une dépendance » s'affiche.

7.2 Configuration

1. Appuyer sur le nœud aval → Injection de dépendances
2. Appuyer sur Ajouter un mappage et configurer :

3. Enregistrer le mappage

7.3 Scénario classique : connexion + requête avec token

[Connexion POST /login] ──→ [Profil GET /user/profile]
         │                            ↑
    réponse : data.token    Authorization = Bearer ${token injecté}

1. Ajouter les deux requêtes
2. Sur GET /user/profile → Définir une dépendance → appuyer sur POST /login
3. Sur GET /user/profile → Injection de dépendances :
   • Source : nœud de connexion, corps data.token
   • Cible : en-tête Authorization
   • Préfixe : Bearer

7.4 Ordre de traitement à l'exécution

Paramètres prédéfinis / modification de requête
        ↓
   Injection d'expressions (${method.timestamp()}, etc.)
        ↓
   Injection de dépendances (mappages)
        ↓
     Envoi de la requête HTTP

8. Injection d'expressions

Écrire des expressions ${...} dans les en-têtes, paramètres de requête ou corps ; elles sont remplacées à l'exécution.

8.1 Méthodes intégrées

Exemple :

{
  "requestId": "${method.uuid()}",
  "timestamp": "${method.timestamp()}",
  "date": "${method.date()}"
}

8.2 Variables globales

Les expressions ${token}, ${appId}, etc. (ne commençant pas par method.) sont des variables globales.

Configuration (page d'exécution) :

1. Un nœud de la règle utilise une expression ${variableName}
2. Un bouton 🌐 apparaît à droite de la barre d'état
3. Appuyer dessus et renseigner les valeurs
4. Après enregistrement, persistées avec la règle (supprimées avec la règle)

Les paramètres prédéfinis et « Modifier la requête » supportent la syntaxe d'expressions ; le remplacement a lieu au moment où vous appuyez sur « Exécuter le rejeu ».

8.3 Exemple combiné

Header:  X-Request-Id: ${method.uuid()}
Query:   ts=${method.timestamp()}
Body:    {"token": "${token}", "userId": "123"}

Renseignez token via 🌐 avant l'exécution.

9. Page d'exécution

9.1 Interface

9.2 Avant l'exécution

• Appuyer sur un nœud → Modifier la requête (cette exécution uniquement, non enregistré dans la règle)
• Si des expressions globales existent → appuyer sur 🌐 pour renseigner les valeurs

9.3 Après l'exécution

• Appuyer sur un nœud → Détails d'exécution (requête réellement envoyée, réponse, durée, erreurs)
• Réinitialiser dans la barre de navigation (rouge) : effacer tous les résultats et relancer

9.4 Statut des nœuds

9.5 Critère de succès

Les codes HTTP 200–299 sont considérés comme succès ; les autres comme échec.

10. Guide des scénarios types

Scénario 1 : Tester en parallèle plusieurs entrées pour une même API

POST /api/order  nœud1  body: {"type":"normal"}
POST /api/order  nœud2  body: {"type":"edge"}
POST /api/order  nœud3  body: {"type":"invalid"}

• Sans dépendance → les 3 nœuds s'exécutent en parallèle
• Définir des body différents via Paramètres prédéfinis par nœud
• Comparer les résultats après exécution

Scénario 2 : Chaîne de connexion

POST /login  →  GET /user  →  POST /order
     │              ↑              ↑
     └──── token injecté dans Authorization ─┘

• Dépendances : GET /user dépend de POST /login ; POST /order dépend de GET /user
• Configurer le mappage du token sur GET /user et POST /order
• Exécution série : connexion → profil utilisateur → commande

Scénario 3 : Paramètres dynamiques + token fixe

• Body : {"ts":"${method.timestamp()}","id":"${method.uuid()}"}
• Header : Authorization: Bearer ${token}
• Renseigner token via 🌐 avant l'exécution
• Horodatage et UUID se mettent à jour à chaque exécution

11. FAQ

Q : J'ai ajouté des requêtes mais la page d'exécution est vide ?
R : Enregistrez la règle avec ✓ dans l'éditeur, puis ouvrez la page d'exécution depuis la liste.

Q : J'ai modifié les paramètres prédéfinis mais la page d'exécution n'a pas changé ?
R : Vérifiez que la règle a bien été enregistrée ; « Modifier la requête » n'affecte que l'exécution en cours.

Q : L'injection de dépendances ne fonctionne pas ?
R : Vérifiez : ① les dépendances existent ; ② le chemin JSON correspond à la réponse exemple ; ③ le nœud amont a réussi ; ④ l'injection d'expressions précède l'injection de dépendances.

Q : Les variables globales sont remplacées par du vide ?
R : Renseignez les valeurs via 🌐 sur la page d'exécution et enregistrez ; les variables non renseignées deviennent des chaînes vides.

Q : Pourquoi certains nœuds sont ignorés ?
R : En cas d'échec d'un nœud de la même couche ou amont, tous les nœuds des couches suivantes sont marqués ignorés.

Q : Peut-on ajouter des requêtes WebSocket ?
R : Non, seules les requêtes HTTP/HTTPS standard sont prises en charge.

12. Aide-mémoire