Menu

Exécuter des cas de test en parallèle et générer des rapports à l'aide de l'outil Karaté

  • Principal
  • Autre
  • Exécuter des cas de test en parallèle et générer des rapports à l'aide de l'outil Karaté

run test cases parallel generate reports using karate tool

Essayez Notre Instrument Pour Éliminer Les Problèmes

comment trouver la clé réseau sur le routeur

Ce tutoriel explique comment effectuer certaines opérations de base sur l'API, exécuter des cas de test en parallèle et générer des rapports avec Karate Framework:

Nous avons appris à créer un script de test de base dans notre tutoriel précédent, nous pouvons maintenant aller de l'avant avec l'apprentissage de certaines opérations de base qui peuvent être effectuées tout en travaillant avec l'API et le cadre de Karaté. Il existe de nombreuses opérations de ce type et nous en discuterons quelques-unes couramment utilisées dans ce didacticiel.

Nous allons également approfondir le processus d'exécution de cas de test en parallèle en suivant une approche étape par étape. Nous discuterons également du rapport actuel qui est généré automatiquement et le comparerons avec le rapport Cucumber que nous pouvons générer en intégrant un plugin.

Exécution de diverses opérations, exécution de cas de test en parallèle et génération de rapports

Ce que vous apprendrez:

Travailler avec l'API et l'outil de test de karaté

Comme indiqué dans le didacticiel précédent, dans le .fonctionnalité fichier que nous avions créé, nous pourrions utiliser différents mots-clés pour effectuer différentes opérations sur l'API. Karaté framework nous fournit plusieurs mots-clés qui peuvent être utilisés pour effectuer diverses actions.

=> Lecture recommandée: Test d'API avec le cadre de karaté

Exécution de diverses opérations

# 1) Impression de la réponse dans la console

Impression est un mot-clé fourni par Karate Framework pour imprimer le résultat dans la console ou le fichier. L'une des utilisations les plus courantes consiste à imprimer la réponse de l'API. Cela peut être très utile pour l'utilisateur.

Nous pouvons le faire en utilisant les lignes de code suivantes:

Feature: fetching User Details Scenario: testing the get call for User Details Given url 'https://reqres.in/api/users/2' When method GET Then status 200 #We are printing the Response of the API using the print keyword# Then print response

Les lignes de code ci-dessus donneront la sortie suivante:

18:15:44.495 (main) INFO com.intuit.karate - (print) { 'ad': { 'company': 'StatusCode Weekly', 'text': 'A weekly newsletter focusing on software development, infrastructure, the server, performance, and the stack end of things.', 'url': 'http://statuscode.org/' }, 'data': { 'last_name': 'Weaver', 'id': 2, 'avatar': 'https://s3.amazonaws.com/uifaces/faces/twitter/josephstein/128.jpg', 'first_name': 'Janet', 'email': 'janet.weaver@reqres.in' } }

C'est ainsi que nous pouvons imprimer la réponse de l'API dans la console à des fins de lecture, qui peut être utilisée au moment du débogage.

# 2) Déclaration des variables

Nous pouvons déclarer les variables en utilisant le mot-clé def dans le cadre de Karaté, puis utilisez les variables déclarées dans le code chaque fois que nécessaire.

Dans l'exemple ci-dessous, nous avons ajouté quelques lignes de code supplémentaires à l'existant userDetails.feature fichier pour aider à déclarer les variables dans le script.

Feature: fetching User Details Scenario: testing the get call for User Details Given url 'https://reqres.in/api/users/2' When method GET Then status 200 #We are printing the Response of the API using the print keyword Then print response # Declaring and assigning a string value: Given def varName = 'value' # using a variable Then print varName

# 3) Affirmation de la réponse réelle à la réponse attendue

Karate Framework aide à effectuer les opérations liées à l'assertion en utilisant le correspondre mot-clé. La correspondre est intelligent car l'espace blanc n'a pas d'importance pour lui et l'ordre des touches n'est pas important.

Pour l'utilisation faire correspondre le mot-clé, nous devons utiliser le signe double égal «==» qui représente une comparaison.

Nous allons maintenant essayer de développer certaines utilisations de correspondre mot-clé.

a) Lorsque toute la réponse attendue est mentionnée dans le fichier .feature lui-même.

À certains moments, nous avons des données que nous aimerions valider immédiatement dans le fichier lui-même. Habituellement, ces types de données sont mentionnés lors du débogage du code.

Nous pourrions faire la même chose dans le fichier .feature lui-même, comme indiqué ci-dessous:

Feature: fetching User Details Scenario: testing the get call for User Details Given url 'https://reqres.in/api/users/2' When method GET Then status 200 #Asserting the reponse #response variable is holding the Actual response from API #Right hand side value is holding the expected Response And match response == {'ad':{'company':'StatusCode Weekly','text':'A weekly newsletter focusing on software development, infrastructure, the server, performance, and the stack end of things.','url':'http://statuscode.org/'},'data':{'last_name':'Weaver','id':2,'avatar': 'https://s3.amazonaws.com/uifaces/faces/twitter/josephstein/128.jpg','first_name':'Janet', 'email':'janet.weaver@reqres.in'}}

Si vous envoyez une demande à l'URL «Https://reqres.in/api/users/2» dans le navigateur, puis vous obtiendrez la réponse suivante:

{ 'ad': { 'company': 'StatusCode Weekly', 'text': 'A weekly newsletter focusing on software development, infrastructure, the server, performance, and the stack end of things.', 'url': 'http://statuscode.org/' }, 'data': { 'last_name': 'Weaver', 'id': 2, 'avatar': 'https://s3.amazonaws.com/uifaces/faces/twitter/josephstein/128.jpg', 'first_name': 'Janet', 'email': 'janet.weaver@reqres.in' } }

Nous essayons de valider la réponse ci-dessus en utilisant le fichier * .feature.

Nous avons utilisé le correspondre mot-clé fourni par le cadre de karaté, qui aide à effectuer différents types de Assertions dans la réponse de l'API.

Remarque : Nous aurions besoin de transformer la réponse de l'API en une seule ligne pour effectuer l'étape ci-dessus. Vous pouvez utiliser l'un des outils disponibles en ligne.

b) Lorsque la sortie attendue est conservée dans un fichier JSON externe.

Dans l'exemple ci-dessus, nous avons discuté d'un scénario où nous avions des données limitées et la même réponse qui était facile à gérer, mais dans les scénarios réels, nous aurons des ensembles gigantesques de réponses JSON que nous devrons peut-être évaluer.

Donc, dans ces cas, il est préférable de conserver la réponse dans le fichier externe, puis de vérifier la même chose.

Dans l'exemple ci-dessous, nous discuterons plus en détail de la même chose:

  • Besoin de créer un ExpectedOutput.json fichier dans notre dossier Projet comme indiqué dans l'image ci-dessous.

Créer une nouvelle ressource de package -> Créer un nouveau fichier ExpectedOutput.json

Et stockez la réponse JSON dans ce fichier et enregistrez-le.

ExpectedOutput.json1

Créer un nouveau package de ressources

Vous devrez écrire le code suivant dans votre userDetails.feature déposer:

Feature: fetching User Details Scenario: testing the get call for User Details Given url 'https://reqres.in/api/users/2' When method GET Then status 200 #Verifying the JSON response by providing same in feature file And match response == {'ad':{'company':'StatusCode Weekly','text':'A weekly newsletter focusing on software development, infrastructure, the server, performance, and the stack end of things.','url':'http://statuscode.org/'},'data':{'last_name':'Weaver','id':2,'avatar': 'https://s3.amazonaws.com/uifaces/faces/twitter/josephstein/128.jpg','first_name': 'Janet','email':'janet.weaver@reqres.in'}} #Reading the file ExpectedOutput.json and storing same response in variable expectedResult Given expectedResult=read('./resources/ExpectedOutput.json') #Asserting the Actual Response with the Expected Response And match response == expectedResult

Dans l'exemple ci-dessus, nous lisons d'abord le fichier ExpectedOutput.json et stocker la réponse de celui-ci dans la variable résultat attendu en utilisant le lignes de code suivantes:

Given expectedResult=read('./resources/ExpectedOutput.json')

Ensuite, nous mettons l'assertion en utilisant les lignes de code suivantes, où nous faisons correspondre le Réponse réelle avec le résultat attendu réponse avec le ' == ' opérateur.

And match response == expectedResult

c) Correspondance / vérification de certaines valeurs de la réponse

Jusqu'à présent, nous avons vérifié l'intégralité de la réponse de l'API, mais à chaque fois, vous ne voudriez pas vérifier l'intégralité de la réponse. Parfois, vous souhaitez évaluer une partie de la réponse uniquement. Habituellement, nous faisons de même lorsque nous utilisons les autres outils pour les tests d'API ou lors de la création d'un framework.

Pour mieux comprendre, prenons la réponse JSON suivante comme exemple:

{ 'ad': { 'company': 'StatusCode Weekly' } }

Si nous voulons vérifier que le paramètre entreprise devrait avoir la valeur StatusCode Hebdomadaire, alors nous devrons créer un chemin JSON. Cela peut être fait en parcourant le fichier JSON et en utilisant le '.' (Opérateur point)

Le chemin JSON de la réponse ci-dessus sera:

ad.company == 'StatusCode Weekly'

Vous trouverez ci-dessous l'extrait de code qui nous aidera à évaluer les valeurs du paramètre particulier. Ce code appartient au .fonctionnalité déposer.

Feature: fetching User Details Scenario: testing the get call for User Details Given url 'https://reqres.in/api/users/2' When method GET Then status 200 #Verifying the JSON response by providing same in feature file And match response == {'ad':{'company':'StatusCode Weekly', 'text':'A weekly newsletter focusing on software development, infrastructure, the server, performance, and the stack end of things.', 'url':'http://statuscode.org/'},'data':{'last_name':'Weaver','id':2,'avatar': 'https://s3.amazonaws.com/uifaces/faces/twitter/josephstein/128.jpg', 'first_name':'Janet','email':'janet.weaver@reqres.in'}} #Reading the file ExpectedOutput.json and storing same response in variable expectedResult Given expectedResult=read('./resources/ExpectedOutput.json') #Asserting the Actual Response with the Expected Response And match response == expectedResult ##Creating JSON path to verify the values of particular parameters## And match response.ad.url == 'http://statuscode.org/' And match response.data.first_name == 'Janet'

Ci-dessous se trouve la ligne de code qui exécute les assertions paramétriques.

And match response.ad.url == 'http://statuscode.org/' And match response.data.first_name == 'Janet'

En utilisant le chemin JSON, nous évaluons les valeurs des paramètres.

Effectuer des opérations de poste

Jusqu'à présent, nous avons couvert les scénarios de base de test d'une API lorsque la méthode était ' OBTENIR'. Mais lorsque nous travaillons dans l'environnement réel, nous devons envoyer beaucoup d'informations au serveur, donc dans ce cas, nous utilisons le ' PUBLIER' méthode .

Cette section vous donnera un aperçu de l'utilisation de la requête POST de base.

Voyons quelques brèves idées sur les paramètres dont nous avons besoin pour envoyer la requête POST.

# 1) Création d'une requête POST, lorsque le corps JSON est mentionné dans le fichier * .feature

  • Créez une fonction userDetailsPost.feature en utilisant les étapes similaires mentionnées dans le didacticiel précédent.
  • Écrivez les lignes de code suivantes:
Feature: Posting User Details Scenario: testing the POST call for User Creation Given url 'https://reqres.in/api/users' And request '{'name': 'morpheus','job': 'leader'}' When method POST Then status 201

Puisqu'il s'agit d'une requête POST, qui doit toujours être accompagnée d'un corps qui doit être envoyé au serveur pour une certaine réponse, nous l'avons mentionné sous le composant suivant:

demander: Il prend un corps JSON comme requête qui est requise avec la méthode POST.

# 2) Création d'une requête POST, lorsque le corps JSON est mentionné dans un fichier externe

Habituellement, nous aurons un énorme corps de demande, ce qui serait difficile à mentionner dans le *.fonctionnalité déposer. Il est donc préférable de le conserver dans le fichier externe.

  • Besoin de créer un fichier PostBody.json dans notre dossier Projet comme indiqué ci-dessous. Créez une nouvelle ressource de package -> Créez un nouveau fichier PostBody.json et stockez le corps JSON dans ce fichier et enregistrez-le.

Créer une requête POST

lorsque le corps JSON est mentionné dans un fichier externe1

Noter: Nous avons mentionné le corps de la méthode POST dans le fichier JSON ci-dessus.

  • Vous devrez écrire le code suivant dans votre userDetailsPost .fonctionnalité déposer:
Feature: Posting User Details Scenario: testing the POST call for User Creation using External File Given url 'https://reqres.in/api/users' Given postBody=read('./resources/PostBody.json') And request postBody When method POST Then status 201

Nous lisons le corps JSON de PostBody.json en utilisant les lignes de code suivantes:

Given postBody=read('./resources/PostBody.json')

Noter: Tous les userDeatils.feature les fichiers que nous avons créés jusqu'à présent nécessiteront la base TestRunner.java fichier pour les exécuter, que nous avons créé dans notre didacticiel de script de test de base comme indiqué ci-dessous:

import org.junit.runner.RunWith; import com.intuit.karate.junit4.Karate; @RunWith(Karate.class) public class TestRunner { }

Exécuter des cas de test en parallèle

Maintenant que nous avons appris les étapes pour créer un script de test de base et effectué quelques opérations de base sur l'API, il est temps de commencer à travailler dans l'environnement réel.

Habituellement, nous devons exécuter les cas de test en parallèle pour accélérer l'exécution. Fondamentalement, l'idée est d'obtenir plus de rendement en moins de temps.

Il s'agit d'une fonctionnalité essentielle du framework et ne dépend pas de JUnit, Maven ou Grade. Cela nous permet de:

  • Choisissez facilement les fonctionnalités et les balises pour exécuter des suites de tests de manière simple.
  • Affichez les résultats parallèles dans le dossier surefire-plugin.
  • Nous pouvons même intégrer les rapports JSON Cucumber pour une meilleure interface utilisateur (qui sera discutée sous peu).

Dans Karate Framework, nous n'avons pas besoin d'effectuer de nombreuses étapes pour démarrer l'exécution parallèle de nos cas de test. Il suffit de suivre les étapes suivantes:

1) Nous devons maintenant changer le TestRunner.java fichier que nous utilisons jusqu'à présent. Le code pour l'exécution parallèle doit être écrit dans le fichier ci-dessus.

Veuillez garder à l'esprit la ligne suivante, lors de l'exécution de votre code en parallèle:

quels sont quelques bons sites d'anime

** Nous ne pouvons pas utiliser l'annotation @RunWith (Karate.class) lorsque nous essayons de travailler dans un environnement parallèle.

Ouvrez l'original TestRunner.java fichier et utilisez le code suivant maintenant:

import com.intuit.karate.Results; import com.intuit.karate.Runner; import org.junit.Test; // important: do not use @RunWith(Karate.class) ! public class TestRunner { @Test public void testParallel() { Results results = Runner.parallel(getClass(),5); } }

** Le code suivant sera applicable pour Dépendance JUnit 4 Maven

Dans l'extrait de code ci-dessus, nous avons inclus la ligne de code ci-dessous:

Résultats résultats = Runner.parallel (getClass (), 5);

Cette ligne indique d'exécuter l'instance des cas de test en parallèle en récupérant dynamiquement les classes au Runtime.

2) Créer un doublon userDetails.feature comme mentionné ci-dessous sous le src / test / java dossier.

userDetails.feature

Maintenant, nous sommes tous prêts pour l'exécution parallèle avec deux . Caractéristiques déposer.

3) Aller à TestRunner.java fichier créé à l'étape ci-dessus et exécutez-le en tant que test JUnit. Avec cela, nous exécuterons nos cas de test au format parallèle.

Pour une lisibilité facile, certaines informations sont présentées par le cadre de Karaté dans la console, chaque fois que l'exécution du test est terminée.

Le résultat ressemble à ceci:

console

Avec l'exécution parallèle, toutes les fonctionnalités s'exécuteront en parallèle et les scénarios fonctionneront également dans un format parallèle.

En suivant les étapes ci-dessus, vous serez en mesure de démarrer l'exécution parallèle très basique du test d'API, en utilisant le cadre de Karaté.

** Vous pouvez étudier les tests parallèles en parcourant les différents filtres de la page Exécution parallèle

Intégrer le plugin Cucumber pour la création de rapports

Comme nous utilisons le Coureur JUnit pour l'exécution de différents scénarios qui ont été mentionnés dans les différents *.fonctionnalité fichiers, il crée automatiquement un rapport pour chacun des fichiers d'entités qui sont stockés dans le chemin rapports cibles / infaillibles.

Intégration du plugin Cucumber pour le reporting

Il génère un Rapport formaté de l'interface utilisateur de base pour présenter les cas de test qui ont été exécutés.

Mais, les rapports générés ne sont pas très agréables en termes d'interface utilisateur, et pour partager les rapports avec les parties prenantes, nous avons besoin de quelque chose de plus convivial et facilement compréhensible.

Afin de parvenir à un tel format de rapport, Karate Framework offre la possibilité d'intégrer Plugin de rapport de concombre ce qui nous aidera à générer un rapport au format graphique, qui sera plus présentable.

Voici les étapes pour intégrer le même:

#1) Ajoutez ce qui suit Rapport sur les concombres dépendance à votre POM.xml

net.masterthought cucumber-reporting 3.8.0 test

#deux) Modifiez le fichier TestRunner.java lorsqu'il n'y a qu'un seul *.fonctionnalité fichier dans le projet.

Nous devons mettre à jour notre fichier TestRunner.java, avec la méthode generateReport () suivante pour le plugin Cucumber.

public class TestRunner { @Test public void testParallel() { generateReport(results.getReportDir()); assertTrue(results.getErrorMessages(), results.getFailCount() == 0); } public static void generateReport(String karateOutputPath) { Collection jsonFiles = FileUtils.listFiles(new File(karateOutputPath), new String() {'json'}, true); final List jsonPaths = new ArrayList(jsonFiles.size()); jsonFiles.forEach(file -> jsonPaths.add(file.getAbsolutePath())); Configuration config = new Configuration(new File('target'), 'demo'); ReportBuilder reportBuilder = new ReportBuilder(jsonPaths, config); reportBuilder.generateReports(); } }

Dans le code mentionné ci-dessus, nous effectuons les actions suivantes:

  • Créer une nouvelle instance de File
  • Fournir le chemin pour stocker les fichiers sous le dossier cible
  • Création d'un objet ReportBuilder qui créera un nouveau rapport Cucumber

Remarque : Le code ci-dessus fonctionne bien lorsque nous avons un seul *. fonctionnalité fichier dans notre projet.

# 3) Modifiez le fichier TestRunner.java lorsqu'il y a multiple * .fonctionnalité fichiers dans le projet.

Nous aurions besoin d'ajouter une ligne de code (mise en évidence en gras ci-dessous) afin de garantir que l'exécution parallèle est prise en charge, pendant que les scénarios sont en cours d'exécution pour la génération du rapport.

public class TestRunner { @Test public void testParallel() { System.setProperty('karate.env', 'demo'); // ensure reset if other tests (e.g. mock) had set env in CI Results results = Runner.parallel(getClass(),5); generateReport(results.getReportDir()); assertTrue(results.getErrorMessages(), results.getFailCount() == 0); } public static void generateReport(String karateOutputPath) { Collection jsonFiles = FileUtils.listFiles(new File(karateOutputPath), new String() {'json'}, true); final List jsonPaths = new ArrayList(jsonFiles.size()); jsonFiles.forEach(file -> jsonPaths.add(file.getAbsolutePath())); Configuration config = new Configuration(new File('target'), 'demo'); ReportBuilder reportBuilder = new ReportBuilder(jsonPaths, config); reportBuilder.generateReports(); } }

Après avoir effectué les étapes mentionnées ci-dessus, nous serons en mesure de créer avec succès un rapport d'interface graphique bien représenté à l'aide du Concombre - rapports brancher.

Nous pouvons trouver le rapport sur le chemin suivant dans notre projet, comme indiqué dans l'image ci-dessous:

Concombre - rapports

Le rapport suivant a été généré pour notre projet, pour toutes les opérations que nous avons effectuées jusqu'à présent dans ce Tutoriel Karate Framework:

Signaler

Conclusion

Pour résumer, dans ce didacticiel, nous avons discuté des opérations de base qui sont utiles au quotidien lorsque vous travaillez avec le Cadre de karaté et comment exécuter plusieurs fichiers * .feature en parallèle. Nous avons également appris à créer un rapport graphique pour les utilisateurs utilisant le Rapports sur les concombres brancher.

Tout d'abord, nous avons discuté des opérations de base qui peuvent être effectuées sur l'API. Nous avons discuté de la façon dont nous pouvons envoyer le corps / la requête POST au serveur, soit en mentionnant le corps dans le fichier * .feature lui-même (ce qui n'est généralement pas une pratique recommandée) ou en utilisant un fichier externe (une pratique recommandée, afin de maintenir un code propre).

Deuxièmement, après avoir suivi quelques étapes de base, nous pourrions exécuter avec succès le résultat du test pendant deux *.fonctionnalité fichiers exécutés en parallèle, simplement en ajoutant quelques lignes de code dans le TestRunner.java fichier permettant le lancement de l'exécution parallèle.

De plus, nous avons appris à transformer le rapport de test JUnit natif en un rapport Cucumber en intégrant le Rapport sur les concombres brancher. Le plugin nous permet de générer des rapports qui ont une meilleure interface utilisateur, sont beaucoup plus compréhensibles pour l'utilisateur, et donc offrent une meilleure expérience utilisateur pour les parties prenantes avec lesquelles ces rapports sont partagés.

À présent, vous devriez être en mesure d'effectuer certaines opérations de base, d'exécuter les cas de test en parallèle et de générer un rapport facile à lire pour les utilisateurs.

<

lecture recommandée

^