Lors de la conception de flux de travail de test automatisés dans Apidog, vous utiliserez différents types d'étapes de test, telles que les requêtes **API, les requêtes de base de données, les boucles For, les boucles ForEach, les scripts**, et plus encore.
Souvent, les données produites lors d'une étape doivent être utilisées lors d'une étape ultérieure. Cela crée un flux logique où les **données pilotent le processus** et les **étapes sont liées entre elles**.
Par exemple, vous pourriez :
- Récupérer un jeton utilisateur lors d'une étape précédente, ou exécuter une requête de base de données pour obtenir un enregistrement spécifique.
- Puis utiliser ces résultats dans une requête de point de terminaison à l'étape suivante.
Cela soulève une question importante :
Comment référencer correctement les données des étapes précédentes (en amont) dans les étapes qui suivent (en aval) ?
Deux mécanismes de transmission de données dans Apidog
Dans les tests automatisés d'Apidog, il existe deux méthodes principales pour transmettre des données entre différentes étapes de test :
1. Récupérer les données de l'étape précédente via les "Valeurs Dynamiques"
Vous pouvez directement référencer la sortie d'une étape précédente (en amont) dans une étape ultérieure (en aval) en utilisant la fonction "Valeur Dynamique". Cela vous permet de récupérer des données à la volée sans les stocker.
2. Stocker les variables et les réutiliser
Vous pouvez extraire des données importantes d'une étape en amont et les **stocker en tant que variable**. Ces variables peuvent ensuite être réutilisées dans n'importe quelle étape suivante.
La maîtrise de ces deux méthodes de transmission de données est essentielle pour construire des flux de travail automatisés efficaces et axés sur les données dans Apidog.
Cet article explique comment gérer les données dans différents types d'étapes de test sous deux angles : **comment extraire les données** et **comment les utiliser**. En comprenant les deux, vous pourrez construire des flux de travail de test plus flexibles et mieux connectés.
Extraction et utilisation des données de réponse de point de terminaison
Comprendre les données de réponse de point de terminaison
Dans les tests automatisés, les requêtes API renvoient généralement des **réponses JSON** structurées, qui servent souvent d'**entrée pour les étapes de test ultérieures**.
Contrairement à d'autres types d'étapes, les réponses de point de terminaison ont tendance à être plus complexes — incluant fréquemment des **objets et des tableaux imbriqués**.
Comment extraire des données d'une réponse de point de terminaison
Il existe deux façons principales d'extraire et de transmettre les données de réponse de point de terminaison entre les étapes de test :
Première méthode : Référence de valeur dynamique
Utilisez les "Valeurs Dynamiques" pour référencer directement les données des étapes précédentes :
- Dans n'importe quel champ de saisie d'une étape en aval, cliquez sur l'icône de la **baguette magique**.
- Choisissez "Récupérer les données de l'étape précédente".
- Apidog insérera automatiquement l'expression correcte — pas besoin de l'écrire manuellement.
Deuxième méthode : Extraire les données en tant que variables
Vous pouvez également utiliser la fonction "Extraire les variables" dans les post-processeurs de point de terminaison pour extraire des champs spécifiques de la réponse en tant que variables.
Par exemple, pour extraire l'id des produits dans une réponse :
- Définissez le nom de la variable comme
products_id - Utilisez le JSONPath :
$.products[0].id
Dans les étapes ultérieures, il suffit de le référencer en utilisant {{products_id}}.
Comment utiliser les données extraites d'une réponse de point de terminaison
Une fois que vous avez extrait des données d'une réponse API — soit en utilisant les "Valeurs Dynamiques" soit les "Variables Extraites" — vous pouvez utiliser ces données dans les étapes en aval de plusieurs manières :
1. Utiliser les données dans les requêtes de point de terminaison
- Via Valeur Dynamique : Comme précédemment, cliquez sur l'icône de la **baguette magique** dans le champ de saisie, choisissez "Récupérer les données de l'étape précédente", et Apidog insérera automatiquement l'expression correcte.
- Via Variable Extraite : Si vous avez précédemment enregistré une valeur en tant que variable (par exemple,
products_id), utilisez simplement{{products_id}}comme paramètre dans la requête API.
2. Utiliser les données dans les opérations de base de données
Vous pouvez utiliser la réponse API comme entrée dans une requête de base de données. Les deux méthodes fonctionnent :
- Méthode de valeur dynamique
SELECT * FROM products WHERE id = '{{$.1.response.body.products[0].id}}'
Utilisez des valeurs dynamiques pour référencer directement les données de réponse API dans la requête SQL :
- Méthode de variable extraite : Si vous avez extrait l'ID du produit en tant que variable nommée
products_id, utilisez :
SELECT * FROM products WHERE id = '{{products_id}}'3. Utiliser les données dans une boucle For
Pour répéter des étapes en fonction de la longueur d'un tableau issu d'une réponse API :
- Utilisez des valeurs dynamiques pour obtenir la longueur du tableau, par exemple :
{{$.1.response.body.products.length}}Cela définit le nombre d'itérations de la boucle.
4. Utiliser les données dans les boucles ForEach
Si vous souhaitez parcourir chaque élément d'un tableau renvoyé par un point de terminaison :
- Méthode de valeur dynamique : Extrayez directement le tableau entier, par exemple
{{$.1.response.body.products}}
- Méthode d'extraction de variable : En supposant que le tableau entier a été extrait en tant que variable
products, insérez directement{{products}}dans la boucle.
5. Utiliser les données dans les scripts
Pour utiliser les données des étapes précédentes à l'intérieur d'un **script**, utilisez la méthode pm.variables.get(). Voici comment :
- Méthode de valeur dynamique : Lisez les données directement à partir d'une étape précédente :
const products = pm.variables.get("$.1.response.body.products")
- Méthode d'extraction de variable : Si vous avez enregistré le tableau ou la valeur en tant que variable, utilisez le script suivant pour obtenir les données :
Obtenir la valeur d'une variable temporaire :
const products = pm.variables.get("products") Obtenir la valeur d'une variable d'environnement :
const products = pm.environment.get("products")
Obtenir la valeur d'une variable globale :
const products = pm.globals.get("products"){{products}}. Au lieu de cela, vous devez récupérer les valeurs des variables en utilisant les méthodes appropriées mentionnées ci-dessus.Extraction et utilisation des résultats de requêtes de base de données
Comprendre les données de base de données
Lorsqu'une étape de requête de base de données est exécutée, elle renvoie des données structurées sous la forme d'un tableau d'objets. Même si un seul enregistrement est renvoyé, il sera toujours enveloppé dans un tableau. Par exemple :
Contrairement aux réponses de point de terminaison, les **données des étapes de base de données ne peuvent pas être directement accédées à l'aide de variables dynamiques**. Vous devez d'abord extraire les valeurs dans des variables.
Comment extraire des données de la base de données
Après l'exécution de la requête SQL dans une étape de base de données, Apidog analysera automatiquement la réponse en données structurées, comme ceci :
[
{
"id": "1000",
"title": "Titre 1",
"description": "Description pour le Titre 1"
}
]
Vous pouvez ensuite utiliser **JSONPath** pour extraire des champs spécifiques et les enregistrer en tant que variables.
Par exemple :
- Nom de la variable :
products_id - JSONPath :
$[0].id(pour extraire l'ID du premier élément). Si vous souhaitez extraire l'ensemble des résultats, utilisez :$. - Les étapes en aval référencent les variables via
{{ }}, par exemple :{{products_id}}
Comment utiliser les données extraites d'une base de données
1. Utiliser les données dans les requêtes de point de terminaison
Si votre requête de base de données renvoie un ID et que vous l'avez enregistré en tant que variable (products_id), vous pouvez l'utiliser directement dans une requête de point de terminaison en aval :
2. Utiliser les données dans les boucles ForEach
Si votre requête renvoie une liste d'enregistrements et que vous souhaitez traiter chacun d'eux individuellement, vous pouvez utiliser le tableau entier comme source pour une boucle ForEach :
La prémisse est que vous enregistrez le tableau entier lors de l'extraction des variables dans les opérations de base de données, par exemple :
- Nom de la variable :
products - JSONPath :
$
3. Utiliser les données dans les scripts
Pour utiliser les variables de base de données extraites dans un script, utilisez la même méthode qu'avec les autres variables.
Obtenir la valeur d'une variable temporaire :
const products = pm.variables.get("products")Obtenir la valeur d'une variable d'environnement :
const products = pm.environment.get("products")Obtenir la valeur d'une variable globale :
const products = pm.globals.get("products")
Extraction et utilisation des données des boucles For
Comment fonctionnent les boucles For ?
Une **boucle For** est utilisée pour répéter un ensemble spécifique d'actions plusieurs fois. Elle s'exécute en fonction d'un nombre défini d'itérations.
Vous pouvez soit définir un nombre fixe de répétitions de la boucle, soit utiliser une valeur dynamique comme la longueur d'un tableau .length renvoyée par une étape précédente. Par exemple : {{$.1.response.body.products.length}} :
Note : Contrairement aux autres étapes qui produisent des données, une **boucle For ne renvoie pas directement de données**. Elle fournit uniquement une valeur d'index (à partir de 0) pour indiquer le nombre de fois que la boucle a été exécutée.
Comment extraire des données des boucles For
Pendant le processus d'exécution, vous pouvez accéder à l'index de la boucle actuelle en utilisant la syntaxe de variable dynamique : {{$.9.index}}
- Le nombre
9fait référence à l'ID de l'étape desboucles For. - Chaque étape a un ID unique.
- L'index commence à 0 pour la première boucle, 1 pour la deuxième, et ainsi de suite.
Comment utiliser les données extraites des boucles For
1. Utiliser les données dans les scripts
Si vous souhaitez utiliser des informations liées à la boucle dans votre script de test, vous pouvez utiliser pm.variables.get() pour obtenir l'index actuel :
// Obtenir l'index de la boucle actuelle
const index = pm.variables.get("$.7.index");
2. Utiliser les données avec d'autres sources de données
Un cas d'utilisation courant d'une boucle For est de traiter des données provenant d'étapes antérieures — comme parcourir un tableau et gérer chaque élément :
// Obtenir le tableau d'une étape précédente
const products = pm.variables.get("$.1.response.body.products");
// Obtenir l'index de la boucle actuelle
const index = pm.variables.get("$.7.index");
// Accéder à l'élément actuel du tableau en utilisant l'index
console.log(products[index]);
Cela vous permet d'effectuer des opérations par lot sur chaque élément du tableau à chaque itération de la boucle.
Extraction et utilisation des données de la boucle ForEach
Comment fonctionne la boucle ForEach ?
La boucle ForEach est spécifiquement conçue pour les données de tableau. Elle itère automatiquement sur chaque élément du tableau et effectue le même ensemble d'opérations.
La principale différence entre une boucle ForEach et une boucle For est que la boucle ForEach extrait automatiquement les données complètes de l'élément de tableau actuel à chaque itération, les rendant directement accessibles dans ses étapes enfants.
Accéder aux données dans une boucle ForEach
Au sein d'une boucle ForEach, le système crée automatiquement deux variables spéciales :
- Éléments de la boucle actuelle : Contient les données complètes de l'élément du tableau en cours de traitement. Par exemple :
{{$.4.element}}. Si le tableau contient des objets, vous pouvez directement accéder à leurs propriétés, telles que :{{$.4.element.id}},{{$.4.element.title}}, etc.
- Index de la boucle actuelle : Représente le nombre d'itérations actuel (à partir de 0), par exemple,
{{$.4.index}}.
Note : Le chiffre 4 fait référence à l'ID de l'étape de la boucle ForEach. Dans votre flux de travail réel, remplacez-le par l'ID d'étape correct de votre processus.
Cas d'utilisation courants des données de la boucle ForEach
1. Utiliser les données dans les requêtes de point de terminaison
Les boucles ForEach sont parfaites pour gérer les opérations de données par lots. Par exemple, si vous avez un tableau d'éléments, vous pouvez automatiquement envoyer une requête de point de terminaison pour chaque élément du tableau. Pendant chaque boucle, le même modèle de requête est réutilisé, mais rempli avec des données différentes, telles que {{$.4.element.id}}.
2. Utiliser les données dans les opérations de base de données
Vous pouvez utiliser les données de l'élément de boucle actuel pour exécuter des requêtes de base de données ou insérer plusieurs lignes.
Exemple : Interroger la base de données en utilisant le champ de l'élément actuel
SELECT * FROM products WHERE id = '{{$.4.element.id}}'
L'expression {{$.4.element.id}} est accessible via la fonction de valeur dynamique.
Insertion de plusieurs champs de l'élément actuel dans une table :
INSERT INTO products (id, title) VALUES ('{{$.4.element.id}}', '{{$.4.element.title}}')
3. Utiliser les données dans les scripts
Si vous avez besoin de traiter davantage les données de la boucle dans un script personnalisé, vous pouvez utiliser la méthode pm.variables.get() pour récupérer les valeurs :
// Obtenir l'élément actuel
const item = pm.variables.get("$.4.element");
// Obtenir l'index actuel
const index = pm.variables.get("$.4.index");Extraction et utilisation des données des scripts
Comment fonctionnent les données de script
Contrairement aux autres étapes d'un flux de travail, les scripts ne génèrent pas automatiquement de sortie qui peut être utilisée directement dans les étapes suivantes. Si vous souhaitez transmettre des données d'un script aux étapes ultérieures, vous devez les stocker manuellement dans une variable.
Comment extraire des données d'un script
Vous pouvez enregistrer des valeurs dans différents types de variables comme ceci :
// Obtenir les données de réponse JSON
// 1. À partir de la réponse de point de terminaison actuelle
// const currentData = pm.response.json();
// 2. Ou les obtenir d'une étape précédente en utilisant une valeur dynamique
const preData = pm.variables.get("$.1.response.body");
// Enregistrer dans les variables d'environnement
pm.environment.set('products', preData.products);
pm.environment.set('products_id', preData.products[0].id);
// Enregistrer dans les variables globales
pm.globals.set('products', preData.products);
// Enregistrer dans les variables temporaires (valides uniquement pendant cette exécution)
pm.variables.set('products', preData.products);Une fois les variables extraites et définies, vous pouvez les référencer dans les étapes ultérieures en utilisant la syntaxe {{nomVariable}}.
Comment utiliser les données extraites des scripts
1. Utiliser les données dans les requêtes de point de terminaison
Les variables définies dans un script peuvent être directement utilisées comme paramètres dans les requêtes de point de terminaison en aval. Par exemple, si vous enregistrez products_id dans le script, vous pouvez le référencer dans une requête ultérieure comme ceci : {{products_id}}.
2. Utiliser les données dans les opérations de base de données
Les variables de script peuvent également être utilisées pour construire des instructions SQL dynamiques. Par exemple :
SELECT * FROM products WHERE id = '{{products_id}}'3. Utiliser les données dans la boucle For
Vous pouvez utiliser un script pour générer le nombre d'itérations de la boucle ou d'autres valeurs intermédiaires, les stocker en tant que "variables temporaires" et les transmettre à l'étape de la **boucle For** :
pm.variables.set("loopCount", 5); Ensuite, dans les paramètres de la boucle, utilisez {{loopCount}} comme nombre d'itérations.
4. Utiliser les données dans les boucles ForEach
Vous pouvez stocker un tableau entier dans une variable et l'utiliser comme source de données pour une **boucle ForEach**.
Exemple :
// Récupérer éventuellement le tableau d'une étape précédente en utilisant des valeurs dynamiques
// const preData = pm.variables.get("$.1.response.body.products")
const preData = [{id: 1}, {id: 2}, {id: 3}];
// Enregistrer dans une variable d'environnement
pm.environment.set('products', preData);
Ensuite, dans la **boucle ForEach**, définissez la source de données sur {{products}}.
Conclusion
Pour construire un flux de travail de test automatisé efficace, il est essentiel de comprendre comment extraire et utiliser les données des différents types d'étapes :
- Les **étapes de point de terminaison et de base de données** génèrent des données liées aux activités.
- Les **étapes de boucle** contrôlent le flux logique.
- Les **étapes de script** sont utilisées pour traiter et transformer les données.
En combinant le **référencement de valeurs dynamiques** avec l'**extraction de variables**, vous pouvez concevoir un processus de test flexible et puissant, axé sur les données.
Meilleures pratiques pour la transmission de données :
- Utilisez le **référencement de valeurs dynamiques** pour les données simples qui ne sont utilisées qu'une seule fois ou occasionnellement.
- Utilisez l'**extraction de variables** pour les données qui doivent être réutilisées dans plusieurs étapes ou traitées dans des scripts.
Choisir la bonne méthode en fonction de la complexité des données et de la fréquence d'utilisation rendra votre flux de travail plus maintenable et efficace.