Tutoriel Karate Framework: Test d'API automatisé avec Karaté

karate framework tutorial

Ce didacticiel est une introduction aux tests d'API à l'aide de Karate Framework. Découvrez la structure du script de test de karaté et les étapes pour créer le premier script de test:

API est un acronyme qui signifie Application Programming Interface. En termes simples, on peut le définir comme un intermédiaire logiciel permettant la communication entre les applications.

Nous avons besoin de tests d'API car:

• Les résultats sont publiés plus rapidement, donc plus besoin d'attendre pour voir si l'API fonctionne correctement.
• Avec une réponse plus rapide, le déploiement de ces API devient également plus rapide, ce qui permet un délai d'exécution rapide.
• La détection précoce des pannes, même avant la création de l'interface utilisateur de l'application, nous permet d'atténuer les risques et de corriger les pannes.
• Livraison à grande échelle possible dans un délai plus court.

Pour pouvoir travailler sur les tests d'API, nous avons divers outils disponibles sur le marché comme Postman, Mocha et Chai. Ceux-ci ont démontré de bons résultats et une utilisation efficace pour tester les API, mais ils sont fortement influencés par le code. Pour pouvoir les utiliser, il faut être techniquement solide et familiarisé avec les langages de programmation.

Le cadre de karaté résout magnifiquement ce problème de ses outils logiciels précédents.

Ce que vous apprendrez:

• Qu'est-ce que le cadre de karaté
  • Histoire du cadre de karaté
• Comparaison du karaté et du repos assuré
  • Outils nécessaires pour travailler avec le cadre de karaté
  • Structure du script de test de karaté
  • Création du premier script de test de karaté de base
• Conclusion
  • lecture recommandée

Qu'est-ce que le cadre de karaté

Karaté? Parlons karaté. Est-ce celui du Japon? Qu'en penses-tu? Peut-être que le grand Bruce Lee avait développé cela pendant son temps libre.

Bien que nous aimerions nous plonger dans les racines intéressantes du karaté, pour l'instant, parlons de la Outil de karaté qui a été développé par Peter Thomas , l'un des grands outils qui viennent à la rescousse des testeurs d'API.

Le cadre de karaté suit le style d'écriture du programme Cucumber qui suit l'approche BDD. La syntaxe est facile à comprendre par les non-programmeurs. Et ce cadre est le seul outil de test d'API qui a combiné l'automatisation des API et les tests de performances en un seul outil autonome.

Il offre aux utilisateurs la possibilité d'exécuter les cas de test en parallèle et d'effectuer les vérifications JSON et XML.

Avec ces informations, certains points clés peuvent être déduits pour mieux comprendre l'outil de Karaté en détail:

• Karaté est un cadre de test BDD au lieu d'un TDD.
• Il est conçu pour être facile pour les non-programmeurs. Cette fonctionnalité change la donne car elle permet une utilisation et un accès accrus par de nombreuses personnes, indépendamment de leur expérience technique ou de leurs capacités.
• Il utilise le fichier de fonctionnalités Cucumber et le langage Gherkins pour écrire le test qui est très facile à comprendre.

Toutes ces fonctionnalités en font l'un des outils d'automatisation les plus avantageux actuellement disponibles.

Histoire du cadre de karaté

Créé par ' Peter Thomas » en 2017, ce logiciel vise à rendre les fonctionnalités de test accessibles à tous. Il a été écrit en Java et la plupart des gens s'attendaient à ce que ses fichiers soient également dans le même langage, mais ce n'est heureusement pas le cas.

Il utilise plutôt des fichiers Gherkins, qui résultent de sa relation avec le framework Cucumber. Le logiciel d'automatisation est une extension de Cucumber, hérite donc de l'utilisation du fichier Gherkins dans son fonctionnement. La grande différence entre les deux est que Karate n'utilise pas Java lors des tests, contrairement à Cucumber.

C'est la raison même pour laquelle il s'adresse aux non-programmeurs car la syntaxe de Gherkins est super lisible et complète. C'est la raison pour laquelle le Karaté est le plus approprié et recommandé pour faire une entrée dans le monde des tests API automatisés.

Voici quelques fonctionnalités du cadre de test de karaté:

• Utilise un langage Gherkins facile à comprendre.
• Il ne nécessite aucune connaissance en programmation technique comme Java.
• Il est basé sur les normes populaires de concombre.
• Facile à créer un cadre.
• Les tests parallèles sont la fonctionnalité de base fournie par le Karaté lui-même, nous n'avons donc pas besoin de dépendre de Maven, Gradle , etc.
• UI pour déboguer le test.
• Appel d'un fichier d'entités à partir d'un autre fichier.
• Fournit des supports pour le test de pilote de données qui est construit en interne, donc pas besoin de dépendre de cadres externes.
• Rapports de repos natifs intégrés. De plus, il peut être intégré au concombre pour de meilleurs rapports d'interface utilisateur et plus de clarté.
• Fournit une assistance en interne pour la commutation de configuration entre différents environnements de test (QA, Stage, Prod, Pre-Prod).
• Prise en charge transparente de l'intégration CI / CD qui peut être utile.
• Capable de gérer divers appels HTTP:
  • Prise en charge de Web Socket
  • Demande SOAP
  • HTTP
  • Gestion des cookies du navigateur
  • HTTPS
  • Données de formulaire HTML
  • Requête XML

Comparaison du karaté et du repos assuré

Repos assuré : Il s'agit d'une bibliothèque basée sur Java pour tester les services REST. Il utilise le langage Java pour écrire les lignes de code. Il aide à tester de nombreuses catégories de demandes, ce qui entraîne en outre la vérification de différentes combinaisons de logique métier.

Cadre de karaté : Un outil basé sur les concombres / cornichons, utilisé pour tester les services SOAP & REST.

Le tableau suivant répertorie quelques différences plus importantes entre Rest-Assured et Karate Framework:

Par conséquent, comme le démontrent les différences ci-dessus, il est prudent de dire que le karaté est l'une des choses les plus faciles que quiconque puisse faire.

Outils nécessaires pour travailler avec le cadre de karaté

Maintenant que nous avons nos connaissances de base sur le cadre de karaté sur le point, examinons les processus et les outils nécessaires à la mise en place de l'environnement de karaté.

# 1) Éclipse

Eclipse est un environnement de développement intégré utilisé dans le domaine de la programmation informatique. Il est principalement utilisé pour la programmation Java. Comme mentionné précédemment, Karate est écrit en Java, il est donc plus logique que Eclipse soit l'IDE incontournable pour le logiciel de test d'API. Une autre raison est qu’il s’agit d’un outil open source, et c’est une bonne raison d’opter pour cet outil.

Remarque: Nous pourrions même utiliser IntelliJ, Visual Studio et d'autres éditeurs différents disponibles sur le marché.

# 2) Maven

Il s'agit d'un outil d'automatisation de construction utilisé principalement pour créer des projets Java. C'est une façon de mettre en place un environnement de Karaté et d'écrire le code. Pour configurer votre Eclipse avec les exigences Maven, vous pouvez cliquer sur ici pour l'installation Maven.

Tout en travaillant dans Maven, utilisez les dépendances Maven qui vous aideraient à prendre en charge Karate Framework.

Les dépendances suivantes seront utilisées avec Maven dans pom.xml.

Remarque: Les dernières versions peuvent être disponibles dans le référentiel Maven.

outils de test de résistance pour application web

# 3) Gradle

Gradle est une alternative à Maven et peut être utilisé à capacité égale. Ils ont leurs similitudes et leurs différences mais peuvent également être utilisés dans la mise en place d'un environnement pour nos codes de Karaté.

Il est plus facile à utiliser, flexible et il est recommandé d'utiliser lorsque notre application a des exigences de modularisation et de gestion avec un tas de plug-ins. Le code de configuration de Gradle ressemblerait à ceci,

Remarque: Vous pouvez soit utiliser MAVEN ou GRADLE.

# 4) Configuration de l'environnement Java dans votre système

Besoin de configurer l'environnement JDK et JRE pour commencer avec les scripts Karate Framework.

Structure du script de test de karaté

Un script de test de Karaté est connu pour la possession de l'extension «.feature». Cette propriété est héritée de Cucumber. L'organisation des fichiers dans la convention Java est également autorisée. Vous êtes libre d'organiser vos fichiers selon les conventions du package Java.

Cependant, les directives de Maven indiquent que le stockage des fichiers non Java doit être effectué séparément. Ils sont faits dans un src / test / ressources structure. Et les fichiers Java sont conservés sous src / main / java .

Mais selon les créateurs de Karate Framework, ils croient fermement que nous gardons côte à côte les fichiers Java et non Java. Selon eux, il est beaucoup plus facile de rechercher les fichiers * .java et * .feature lorsqu'ils sont conservés ensemble, plutôt que de suivre la structure standard de Maven.

Cela peut être facilement fait en modifiant votre pom.xml comme suit (pour Maven):

Voici les grandes lignes de la structure générale de Karate Framework:

Maintenant, comme ce cadre de Karaté utilise le fichier Runner, qui est également nécessaire dans Cucumber pour exécuter les fichiers de fonctionnalités, la plupart de l'écriture suivra les normes Cucumber.

Mais, contrairement au concombre, les étapes ne nécessitent pas une définition claire en karaté et qui, à leur tour, améliorent la flexibilité et la facilité des opérations. Nous n'avons pas besoin d'ajouter la colle supplémentaire que nous devons généralement ajouter lorsque nous suivons le framework Cucumber.

La classe 'Runner' est la plupart du temps nommée TestRunner.java.

Ensuite, le fichier TestRunner.java prendra la forme de:

Et en parlant de la .fonctionnalité fichier, il contient tous les scénarios de test qui doivent être testés pour s'assurer que l'API fonctionne selon les exigences attendues.

Un fichier * .feature général ressemble à quelque chose comme indiqué ci-dessous:

Création du premier script de test de karaté de base

Cette section vous aidera à démarrer avec la création de votre tout premier script de test, qui vous sera utile pour convertir les API sous la forme d'un framework de Karaté.

Avant d'écrire les scripts de test de Karaté de base, veuillez installer les conditions suivantes sur votre machine:

• Eclipse IDE
• Maven. Définissez le chemin Maven approprié.
• JDK & JRE. Définissez le chemin approprié.

Jetons un coup d'œil à l'approche étape par étape:

#1) Créer un nouveau MAVEN Projet dans l'éditeur Eclipse

• Ouvrez Eclipse
• Cliquez sur Fichier. Sélectionnez Nouveau projet.

• Sélectionnez le projet Maven

• Choisissez l'emplacement de l'espace de travail.
• Sélectionnez l'archétype (généralement, nous choisissons ' Maven-archetype-quickstart 1.1 ”Pour les projets Maven simples).
• Fournissez l'ID de groupe et l'ID d'artefact (nous avons utilisé les valeurs suivantes dans notre exemple).
  • ID de groupe : Karaté
  • ID de l'artefact: KaratéTestScriptsÉchantillon
• Cliquez sur Terminer pour terminer la configuration.

#deux) Une fois créé, vous pourrez maintenant voir la structure suivante dans la fenêtre Explorateur de projet.

# 3) Incluez toutes vos dépendances.

Notre toute première étape, après l'installation, nous allons inclure toutes les dépendances qui sera nécessaire pour l'exécution. Nous conserverons toutes les balises sous le POM.xml (en supposant que vous soyez déjà au courant de l'utilisation de POM.xml).

• Ouvrez POM.xml et copiez le code ci-dessous sous la balise de dépendance et enregistrez le fichier.

Cliquez sur ici pour la source.

# 4) Réfléchissons au scénario, qu'est-ce que nous allons tester dans ce script de test de base de karaté.

Scénario:

Nous allons tester une API avec ceci URL.

Chemin: api / utilisateurs / 2

Méthode: OBTENIR

Et nous devons valider , si la demande renvoie un Code de réussite (200) ou non.

comment faire une attaque ddos ​​sur un site Web

En termes simples, nous allons simplement tester un exemple d'API pour voir s'il est exécuté avec succès ou non.

Remarque: Nous prenons un exemple d'API disponible pour les tests. Vous pouvez choisir n'importe quel PATH ou vous référer à votre API.

Cliquez sur ici pour la source.

# 5) Maintenant, notre prochaine étape serait de créer un .fonctionnalité déposer.

Comme indiqué dans la section d'introduction, le fichier .feature est la propriété héritée de Cucumber. Dans ce fichier, nous écrirons les scénarios de test qui doivent être exécutés pour effectuer les tests d'API.

• Aller au dossier src / test / java dans votre projet.

• Faites un clic droit dessus et créez un nouveau fichier - userDetails.feature. Cliquez ensuite sur le bouton Terminer.

Vous verrez maintenant le fichier suivant sous le dossier src / test / java

Le Icône de couleur verte ressemble au .feature fi le dans Cucumber que nous venons de créer.

• Une fois le fichier créé, nous allons maintenant écrire nos scénarios de test qui seront discutés dans la section suivante.

# 6) Puisque nous avons le scénario et le blanc. fonctionnalité fichier prêt, commençons maintenant avec notre premier script. Commençons à coder

Écrivez la ligne suivante de code sous le fichier userDetails.feature que nous avons créé à l'étape 5:

Essayons de comprendre les composants qui sont écrits dans le fichier ci-dessus:

• Fonctionnalité: Le mot-clé explique le nom de la fonctionnalité que nous testons.
• Fond: Il s'agit d'une section facultative qui est traitée comme une section préalable. Cela peut être utilisé pour définir tout ce qui est nécessaire pour tester l'API. Il contient EN-TÊTE, URL ET PARAM options.
• Scénario: Chaque fichier de fonctionnalités que vous verrez aura au moins une fonctionnalité (bien qu'il puisse donner plusieurs scénarios). C'est la description du cas de test.
• Donné: C'est l'étape qui doit être exécutée avant toute autre étape de test. C'est une action obligatoire à effectuer.
• Lorsque: Il spécifie la condition à remplir pour effectuer la prochaine étape de test.
• Puis: Il nous dit que ce qui devrait se passer dans le cas où la condition mentionnée dans le Lorsque est satisfait.

Remarque: Tous les mots-clés mentionnés ci-dessus sont issus du langage Gherkins. Il s'agit de la manière standard d'écrire les scripts de test à l'aide de Cucumber.

Et quelques autres mots utilisés dans le fichier d'entités sont:

• 200: C'est le code de statut / réponse que nous attendons (Cliquez ici pour la liste des codes d'état)
• OBTENIR: C'est la méthode API comme POST, PUT, etc.

Nous espérons que cette explication vous a été facile à comprendre. Vous pourrez maintenant vous rapporter à ce qui est exactement écrit dans le fichier ci-dessus.

Nous devons maintenant créer un fichier TestRunner.java

Comme expliqué dans la section ci-dessus, Cucumber a besoin d'un fichier Runner qui serait nécessaire pour exécuter le .fonctionnalité fichier contenant les scénarios de test.

• Aller au dossier src / test / java dans votre projet

• Faites un clic droit dessus et créez un nouveau fichier Java: TestRunner.java
• Une fois le fichier créé, placez-y les lignes de code suivantes:

• Test Runner est le fichier qui sera maintenant exécuté pour exécuter le scénario souhaité qui a été écrit à l'étape 5.

# 7) Maintenant, nous sommes prêts avec les deux fichiers TestRunner.Java et userDeatils.feature. La seule tâche qui nous reste est de Courir le scénario.

• Accédez au fichier TestRunner.java et cliquez avec le bouton droit sur le fichier comme indiqué dans l'image ci-dessous.

• Choisissez Exécuter en tant que -> Test Junit
• Maintenant, une fois sélectionné, vous commencerez à observer que le scénario de test a maintenant commencé.
• Attendez que le script de test s'exécute. Une fois cela fait, vous observerez quelque chose comme indiqué dans l'image ci-dessous dans votre fenêtre.

• Enfin, nous pouvons dire que nous avons créé avec succès notre tout premier basique Script de test en utilisant le Cadre de karaté.

# 8) Enfin, le framework Karaté donne également une présentation de rapport HTML pour l'exécution qui a été effectuée.

• Allez dans le dossier cible -> surefire-reports-> Ici vous verrez votre rapport HTML que vous pouvez ouvrir.

** Nous vous suggérons également de l'ouvrir à l'aide du navigateur Chrome pour une meilleure apparence.

• Le rapport HTML suivant vous sera présenté, illustrant Scénarios et test qui a été exécuté pour le scénario mentionné:

Conclusion

Dans ce didacticiel, nous avons discuté des tests d'API, des différents outils de test disponibles sur le marché et de la manière dont le cadre de karaté est une meilleure option par rapport à ses homologues.

Nous avons suivi une approche étape par étape pour créer notre premier script de test de base. Nous avons commencé par créer une base Projet Maven dans l'IDE Eclipse pour créer un fichier .feature, qui contient tout le scénario de test et un fichier Runner pour exécuter le cas de test mentionné dans le fichier .feature.

À la fin des multiples étapes, nous avons pu voir le rapport d'exécution des résultats du test.

Nous espérons que ce didacticiel a été utile pour les débutants en apprenant à créer leur premier script de test à l'aide de Karate Framework et à effectuer des tests d'API. Cette approche détaillée étape par étape est un excellent moyen d'exécuter et d'exécuter divers tests sur l'API.

SUIVANT >>

lecture recommandée

• Comment configurer le cadre de test Node.js: Tutoriel Node.js
• Tutoriel Parasoft SOAtest: outil de test d'API sans script
• Tutoriel Mockito: Framework Mockito pour la simulation dans les tests unitaires
• Tutoriel de test d'API: un guide complet pour les débutants
• Tutoriel TestNG: Introduction à TestNG Framework
• Tutoriel Jest - Tests unitaires JavaScript à l'aide de Jest Framework
• Tutoriel sur les tests destructifs et les tests non destructifs
• Comment utiliser Postman pour tester différents formats d'API?