Menu

Tutoriel Specflow: Le guide ultime de l'outil BDD

specflow tutorial ultimate guide bdd tool

Essayez Notre Instrument Pour Éliminer Les Problèmes

Un guide complet du didacticiel de développement piloté par le comportement et le Specflow (BDD):

Qu'est-ce que Specflow?

Specflow est un framework de test prenant en charge les pratiques BDD dans le framework .NET. C'est un framework open source hébergé sur GitHub. Il aide à utiliser ATDD (développement de pilotes de test d'acceptation) pour les applications .NET. Avec cela, nous pouvons définir un scénario en anglais simple défini par le langage Gherkin qui est clairement compréhensible par n'importe qui.

Il existe différents outils pour écrire des tests dans l'approche BDD comme Cucumber / JBehave pour Java, Lettuce pour Python, Jasmine pour Javascript, Specflow pour .NET.

Specflow et BDD

BDD (Behaviour Driven Development) est un ensemble de pratiques ou une approche similaire au TDD (Test Driven Development), qui vise à combler le fossé de communication entre les différentes parties prenantes telles que les produits, les développeurs et les testeurs.

L'objectif final de l'approche BDD est de créer des exigences commerciales qui pourraient être comprises par toute l'équipe afin d'éviter les malentendus et d'aider à expédier la fonctionnalité en cours de développement de la manière la plus acceptable.

Une série complète de didacticiels Specflow:

Lisez le Série complète de formations Specflow pour une meilleure compréhension du concept.

Tutoriel n ° 1: Introduction à l'outil Specflow BDD (Ce tutoriel)
Tutoriel n ° 2: Exemple Specflow et Selenium
Tutoriel n ° 3: Liaison Specflow et concepts avancés
Tutoriel n ° 4: Transformations d'arguments d'étape et tables Specflow
Tutoriel n ° 5: Documentation Specflow Living avec cornichons
Tutoriel n ° 6: Générateur de rapports Specflow
Tutoriel n ° 7: Questions d'entrevue Specflow

Un bref aperçu des didacticiels de la série Specflow:

Didacticiel #Description
7 Questions d'entrevue Specflow

Une liste des questions et réponses d'entrevue Specflow les plus populaires avec des exemples est incluse dans ce didacticiel pour vous permettre de réussir n'importe quelle interview Specflow dès la première tentative.
1 Introduction à l'outil Specflow BDD (Ce tutoriel)

Ce didacticiel d'introduction vous expliquera tout sur Specflow en détail. Specflow est un framework de test prenant en charge les pratiques BDD dans le framework .NET. C'est un framework open source hébergé sur GitHub. Il aide à utiliser ATDD (développement de pilotes de test d'acceptation) pour les applications .NET.
deux Exemple Specflow et Selenium

Ce tutoriel se concentrera sur l'intégration de Selenium avec le framework Specflow à travers un scénario de test simple de recherche vidéo sur l'application Youtube. Vous vérifierez également comment partager des données entre différentes liaisons via des champs de classe privés.
3 Exemple Specflow et Selenium

Ce tutoriel se concentrera sur l'intégration de Selenium avec le framework Specflow à travers un scénario de test simple de recherche vidéo sur l'application Youtube. Vous vérifierez également comment partager des données entre différentes liaisons via des champs de classe privés.
4 Transformations d'arguments d'étape et tables Specflow

Ce didacticiel Specflow informatif expliquera en détail les transformations Step Argument qui permettent des conversions de type personnalisées pour les arguments Specflow afin d'éviter le code standard et les tables Specflow sont utiles lorsque vous devez transmettre un grand nombre de champs / données en une seule étape dans un tableau convivial format.
5 Documentation Specflow Living avec cornichons

À partir de ce didacticiel Specflow, vous apprendrez à générer une documentation vivante de qualité via un framework open source appelé pickles en utilisant vos fichiers Specflow existants.
6 Générateur de rapports Specflow

Dans ce didacticiel Specflow Reporting, vous apprendrez les moyens d'exécuter des tests de fonctionnalités Specflow ainsi que de générer des rapports HTML via l'exécutable Specflow.

Commençons par le premier didacticiel de cette série.

Ce que vous apprendrez:

Introduction à l'outil Specflow BDD

Regardez le didacticiel vidéo:

Voici un didacticiel vidéo sur Specflow et le développement piloté par le comportement:

Caractéristiques de BDD

Les principales caractéristiques de BDD sont présentées ci-dessous:

#1) Il tente de définir le comportement du système ou de la fonctionnalité en cours de développement à travers un exemple ou un scénario. Par exemple, si vous créez une simple application de calculatrice, les différents comportements incluent l'addition, la multiplication, la division, etc.

Par conséquent, à travers BDD, toutes les parties prenantes se réuniront d'abord pour décider du comportement de l'application comme Addition et auront des scénarios comme indiqué ci-dessous.

Given, I have 2 numbers 30 and 50 as input When I add these 2 numbers Then I should get an output of 80

Si vous voyez la représentation ci-dessus, il s'agit d'un scénario en anglais simple qui est clairement compréhensible par tout le monde et clarifie les exigences d'une fonctionnalité (selon les critères d'acceptation). Par conséquent, la première étape consiste à articuler ces exigences.

#deux) Maintenant, avec un ensemble de ces scénarios, le QA écrit des tests contre ceux-ci et cela échouera initialement car la fonctionnalité n'est pas encore développée.

# 3) Maintenant, le développeur écrit un code de fonctionnalité et exécute à nouveau ces tests.

# 4) Les tests peuvent réussir ou échouer. S'ils échouent - refactoriser le code et répéter le processus

# 5) Une fois la refactorisation du code terminée, tous les scénarios / tests doivent réussir.

Par conséquent, en substance, BDD utilise l'approche TDD et l'amène au niveau supérieur en ayant des spécifications communes facilement compréhensibles sous la forme de scénarios. Ils représentent également la documentation des fonctionnalités en elle-même.

Il existe différents outils pour écrire des tests dans l'approche BDD comme Cucumber / JBehave pour Java, Lettuce pour Python , Jasmine pour Javascript, Specflow pour .NET.

quel genre d'emails y a-t-il

Dans ce tutoriel, nous nous concentrerons sur Specflow.

Lire aussi => Principaux outils BDD et cadre de test

Les mots-clés - Donné, quand et alors

Dans le monde des tests unitaires, la plupart d’entre nous sont familiers avec les 3 A, à savoir organiser, agir et affirmer. Maintenant, Donné, Quand et Alors sont les remplaçants pour ceux-ci dans le monde BDD.

Prenons un Exemple pour comprendre chacun d'eux. Supposons que vous répertoriez un scénario pour valider un produit qui est ajouté au panier d'une application de commerce électronique qui nécessite que vous soyez connecté en tant que condition préalable.

La spécification peut être écrite comme suit:

Scenario: Products get added to cart for a logged in customer Given I have a logged-in customer on my application When I add 2 quantity of a product to my shopping cart Then the shopping cart should get updated and have the right product and quantity

Donné :Ceci est utilisé pour décrire un ensemble de conditions préalables pour le scénario en cours de définition. Par exemple, dans l'exemple, le pré-requis du scénario est un client connecté. Par conséquent, en comparant au Organiser analogie dans un test unitaire, la mise en œuvre de l'étape devra s'assurer qu'il y a un client connecté.

Lorsque :Ceci est utilisé pour décrire une action ou une étape d'exécution. Dans l'exemple, cela montre que le client tente d'ajouter un produit à son panier. Par conséquent, la mise en œuvre de l'étape pour cette étape prendra en charge le code de simulation pour ajouter un produit au panier. Cela peut être comparé au Acte étape dans les tests unitaires.

Puis :Ceci est utilisé pour décrire le résultat du scénario et essentiellement où les validations doivent être placées. Il peut être comparé au Affirmer étape dans le monde des tests unitaires. Dans l'exemple ici, la mise en œuvre de l'étape affirmera si le produit a été réellement ajouté et si la quantité est la même que celle choisie par le client.

Le fichier d'entités

Le fichier de fonctionnalités est essentiellement un regroupement de plusieurs scénarios pour l'application en cours de développement ou de test. Il peut également être simplement considéré comme différents modules de l'application par lesquels l'application peut être logiquement séparée.

Par exemple:

Une application de commerce électronique peut décider d'avoir différents fichiers de fonctionnalités de haut niveau comme:

  • Fonctionnalité de connexion / déconnexion
  • Panier
  • Paiement etc.

Qu'est-ce que Specflow?

Specflow est un outil prenant en charge les pratiques BDD dans le framework .NET. C'est un framework open source hébergé sur GitHub. Il aide à utiliser ATDD (développement de pilotes de test d'acceptation) pour les applications .NET.

La liaison des exigences métier pour une application utilisant le paradigme Specification By Example permet de mieux comprendre le comportement de l'application par toutes les parties prenantes et aboutit ainsi à expédier le produit avec des attentes correctes.

Il utilise Cornichon syntaxe pour créer des fonctionnalités et des scénarios. Il a également une discussion / développeur actif forum .

Specflow - Prise en main

Dans cette section, nous explorerons l'installation de specflow dans l'IDE de Visual Studio et la création de fichiers de fonctionnalités pour une application utilitaire de chaîne simple.

À propos de l'exemple d'application

Nous illustrerons différentes fonctionnalités du framework Specflow dans ce didacticiel à l'aide d'une application Calculator qui a des fonctions / interfaces pour fournir différentes opérations telles que:

  1. Ajout de 2 nombres.
  2. Soustraire 2 nombres.
  3. Diviser et multiplier 2 nombres.
  4. Trouver la racine carrée du nombre donné.

Specflow Guide d'installation

L'installation de Specflow est un processus en 2 étapes

#1) Installation des plugins requis dans l'IDE de Visual Studio.

  • Pour installer le plugin specflow, accédez à Outils -> Extension et mises à jour.
  • Cliquez maintenant sur «En ligne» dans le panneau de gauche.
  • Recherchez maintenant specflow dans le panneau de droite.
  • Dans les résultats de la recherche, sélectionnez «Specflow pour Visual Studio 2017».

Installation de Specflow-Plugin

#deux) Configuration du projet avec des fichiers de fonctionnalités et des définitions d'étape.

  • Créez un nouveau projet simple dans Visual Studio. Nous pouvons créer tout type de projet comme un projet de bibliothèque de classes / d'application console / de test d'unité, etc. Pour plus de simplicité, nous prenons un projet de bibliothèque de classes. Nommez le projet «SpecflowBasic».
  • Afin d'exécuter les scénarios Specflow que nous allons créer, nous avons besoin d'un testeur. Specflow fournit un runner prêt à l'emploi appelé Specflow + Runner (qui est une version payante et la version gratuite introduit un retard).

(D'autres coureurs sont également disponibles pour NUnit et MsTest que nous verrons dans les autres articles de cette série).

Pour installer Specflow + Runner - Accédez à Outils -> Gestionnaire de package NuGet -> Console du gestionnaire de package.

Une fois la console du gestionnaire de package ouverte - Exécutez la commande.

Install-Package SpecRun.SpecFlow

Installation Specrun

  • Aussi, pour affirmer les valeurs, nous aurons besoin de l'aide d'un framework de test. NUnit peut être l'une des options et les autres incluent MsTest, etc. Pour installer le framework NUnit dans l'application, ouvrez la console du gestionnaire de packages et tapez command.
Install-Package NUnit

# 3) Créez une nouvelle classe nommée «CalculatorApplication» qui deviendra notre application en cours de test. Il s'agit d'une classe simple ayant des fonctions pour effectuer l'addition / multiplication / division / racine carrée etc., pour l'entrée donnée. Voici à quoi ressemble la classe CalculatorApplication.

# 4) Une fois le package installé, créez 2 dossiers dans le projet et nommez-les en tant que fonctionnalités et définitions d'étape pour stocker respectivement les fichiers de fonctionnalités et les liaisons d'étape. Nous discuterons en détail de la raison de cette organisation de dossiers pour les définitions de fonctionnalité et d'étape.

# 5) Maintenant, dans le dossier des fonctionnalités, ajoutez un nouveau fichier de fonctionnalités et nommez-le comme CalculatorFeature.

Fonction de calculatrice

Vous verrez que par défaut, le fichier de fonctionnalités a une description dans Fonctionnalité et Scénario.

Remplacez cela par ce que nous allons tester.

Feature: CalculatorFeature In order to test my application As a developer I want to validate different operations of the application Scenario: Add two numbers Given I have provided 70 and 20 as the inputs When I press add Then the result should be 90 Scenario: Substract two numbers Given I have provided 70 and 20 as the inputs When I press substract Then the result should be 50 Scenario: Multiply two numbers Given I have provided 70 and 20 as the inputs When I press multiply Then the result should be 1400 Scenario: Divide two numbers Given I have provided 70 and 20 as the inputs When I press divide Then the result should be 3.5 Scenario: SquareRoot of number Given I have provided 70 as input When I press squareroot Then the result should be 8.37

# 6) Génération de définitions d'étape: Specflow fournit un moyen automatisé de générer des liaisons / implémentation pour les différentes étapes des scénarios de fichiers d'entités. Ceci peut être réalisé en cliquant avec le bouton droit sur le fichier d'entités et en cliquant sur «Générer des définitions d'étape».

Générer une définition d

Cette étape ne garantit pas une mise en œuvre pour toutes les étapes, mais il fait de son mieux pour regrouper les étapes courantes dans des scénarios et réutiliser autant de liaisons qu'il le peut. Cependant, cela permet d'éviter le code passe-partout à chaque fois qu'une étape de scénario doit être mise en œuvre.

Après avoir cliqué 'Générer des définitions d'étape' , Une fenêtre apparaîtra répertoriant les implémentations d'étapes identifiées que le processeur a détectées. On peut sélectionner ou désélectionner selon les exigences.

Générer un squelette de définition d

Dans les sections suivantes, nous examinerons plus de détails sur la liste déroulante Style montrée dans la capture d'écran ci-dessus.

Pour l'instant, gardons-les tous sélectionnés avec les paramètres par défaut. Cliquez sur Aperçu pour afficher un instantané de l'apparence de l'implémentation.

Aperçu de la mise en œuvre

Une fois les définitions d'étape créées, s'il existe des étapes non implémentées, les fichiers de fonctionnalités disposent d'un moyen visuel d'identifier les applications non implémentées. Il montre ces étapes dans une couleur différente en rendant absolument simple de savoir qu'il existe des étapes qui n'ont pas encore d'implémentation (ou qui ont des définitions d'étape ambiguës).

Un exemple d'écran montre que ci-dessous:

Implémentation manquante

Remarque: Les définitions d'étape peuvent également être créées manuellement - Tout fichier .cs ayant l'attribut (Binding) est une classe d'implémentation Step et la syntaxe Gherkin cherchera à correspondre à l'implémentation de l'étape de scénario donnée

Exécution

Comme nous avons déjà ajouté Specflow + Runner dans la section ci-dessus, l'exécution des scénarios est assez simple (puisqu'il s'agit d'une version d'évaluation de Specrun, elle introduit un délai variable de 10 à 20 s avant l'exécution des scénarios., Ce délai n'est pas présent pour les variantes enregistrées et d'autres saveurs de Specrun runner comme NUnit et MsTest).

Si toutes les étapes ont pas été implémenté et s'il existe encore des liaisons qui ont un état en attente. Ensuite, la sortie s'affichera comme étant en attente.

Essayons d'exécuter ces tests / scénarios à ce stade lorsqu'il n'y a pas d'implémentation pour les liaisons et que les scénarios sont tous en attente.

Scénarios en attente

Essayons maintenant d'implémenter la classe CalculatorApplication avec les méthodes que nous voulons tester, c'est-à-dire ajouter, soustraire, multiplier, diviser et sqrt.

Vous trouverez ci-dessous un exemple de code illustrant à quoi ressemble notre classe CalculatorApplication:

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace SpecflowBasic { class CalculatorApplication { public int add(int input1, int input2) { return input1 + input2; } public int subsctract(int input1, int input2) { return input1 - input2; } public int multiply(int input1, int input2) { return input1 * input2; } public double divide(double input1, double input2) { return input2 != 0 ? Math.Round(input1 / input2, 2) : 0; } public double squareRoot(int input1) { return input1 != 0 ? Math.Round(Math.Sqrt(input1), 2) : 0; } } }

Une fois que l'application est prête, essayons de trouver les moyens d'implémenter les liaisons pour chacune des étapes du scénario.

Voyons l’approche étape par étape pour les mettre en œuvre:

  • Tout d'abord, nous devons disposer d'une instance de l'application qui doit être testée. Pour plus de simplicité, nous pouvons instancier la classe AUT (Application Under Test) dans les liaisons d'étape et utiliser l'instance instanciée pour appeler en fait différentes méthodes / fonctions selon l'étape implémentée.
  • Pour capturer l'entrée et la sortie, nous déclarons des variables pour contenir ces valeurs afin d'appeler des fonctions sur l'instance Application.

Voyons la mise en œuvre de bout en bout de toutes les liaisons impliquées dans la validation de la fonctionnalité Ajouter (le reste des scénarios étendent simplement cela).

Le scénario Ajouter ressemble à celui ci-dessous:

Scenario: Add two numbers Given I have provided 70 and 20 as the inputs When I press add Then the result should

Voyons la mise en œuvre des étapes pour chacune de ces étapes individuelles. Pour l'utilisation de toutes les implémentations d'étape, nous déclarons une instance d'application sous test ainsi que des variables pour contenir des variables d'entrée et de sortie comme indiqué ci-dessous:

// instantiating application instance CalculatorApplication app = new CalculatorApplication(); // variables to hold input values and the intermeditate result int input1, input2; double output;

Voyons la mise en œuvre des étapes du scénario une par une.

Étape 1: Étant donné que j'ai fourni 70 et 20 comme les entrées.

(Given(@'I have provided (.*) and (.*) as the inputs')) public void GivenIHaveProvidedAndAsTheInputs(int p0, int p1) { input1 = p0; input2 = p1; }

Ici, nous venons d'initialiser les variables d'entrée avec les valeurs transmises à partir des étapes du scénario. p0 et p1 sont les valeurs transmises à partir de l'étape de scénario et seront initialisées respectivement à 70 et 20.

Étape 2: Quand j'appuie sur ajouter.

(When(@'I press add')) public void WhenIPressAdd() { output = app.add(input1, input2); }

Il s'agit de l'étape Exécution (ou Acte) où la méthode réelle est appelée sur l'application testée. Notez que puisque les variables d'entrée input1 et input2 contiennent déjà les valeurs passées à l'étape 1, l'instance d'application peut appeler la méthode avec ces variables.

Étape 3: - Ensuite, le résultat devrait être 90.

(Then(@'the result should be (.*)')) public void ThenTheResultShouldBe(double p0) { Assert.AreEqual(p0, output); }

Il s'agit de l'étape de validation (ou d'assertion) où la sortie est générée par l'appel de méthode et l'instance d'application est validée par rapport à la sortie attendue.

Remarquez que le Affirmer Le mot clé utilisé provient de NUnit Framework, qui retourne vrai ou faux en fonction de la validation / attente définie. Dans le cas où il retourne false, cela entraînera l'échec de l'implémentation Step et cela affichera le résultat du scénario comme échec.

expression régulière en c ++

Veuillez également noter que la variable de sortie obtient la valeur de l'étape précédente où la méthode réelle a été appelée sur l'instance d'application.

Semblable à ce qui précède, les implémentations Step pour le reste des étapes du scénario sont effectuées de la même manière, la différence réside dans l'appel de différentes méthodes sur l'instance d'application et l'affirmation de valeurs de sortie différentes.

Une fois toutes les étapes du scénario implémentées, les tests peuvent être exécutés.

La sortie résultante ressemblera à celle ci-dessous:

Sortie consolidée

Vous pouvez également afficher la sortie du scénario individuel qui répertorie également la sortie des étapes individuelles:

Sortie de scénario

Conclusion

J'espère que cet article vous aurait donné une compréhension de base de ce qu'est BDD et quels sont les outils qui prennent en charge BDD pour .NET où nous avons couvert Specflow.

Nous avons également discuté de l'installation et de l'exécution des fichiers de fonctionnalités Specflow à l'aide d'un exemple d'application.

Fichiers de code

Les fichiers de code utilisés dans l'application sont indiqués ci-dessous:

CalculatriceFeatureSteps.cs

using System; using TechTalk.SpecFlow; using NUnit; using NUnit.Framework; namespace SpecflowBasic.StepDefinitions { (Binding) public class CalculatorFeatureSteps { // instantiating application instance CalculatorApplication app = new CalculatorApplication(); // variables to hold input values and the intermeditate result int input1, input2; double output; (Given(@'I have provided (.*) and (.*) as the inputs')) public void GivenIHaveProvidedAndAsTheInputs(int p0, int p1) { input1 = p0; input2 = p1; } (Given(@'I have provided (.*) as input')) public void GivenIHaveProvidedAsInput(int p0) { input1 = p0; } (When(@'I press add')) public void WhenIPressAdd() { output = app.add(input1, input2); } (When(@'I press substract')) public void WhenIPressSubstract() { output = app.subsctract(input1, input2); } (When(@'I press multiply')) public void WhenIPressMultiply() { output = app.multiply(input1, input2); } (When(@'I press divide')) public void WhenIPressDivide() { output = app.divide(input1, input2); } (When(@'I press squareroot')) public void WhenIPressSquareroot() { output = app.squareRoot(input1); } (Then(@'the result should be (.*)')) public void ThenTheResultShouldBe(double p0) { Assert.AreEqual(p0, output); } } }

CalculatriceApplication.cs

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace SpecflowBasic { class CalculatorApplication { public int add(int input1, int input2) { return input1 + input2; } public int subsctract(int input1, int input2) { return input1 - input2; } public int multiply(int input1, int input2) { return input1 * input2; } public double divide(double input1, double input2) { return input2 != 0 ? Math.Round(input1 / input2, 2) : 0; } public double squareRoot(int input1) { return input1 != 0 ? Math.Round(Math.Sqrt(input1), 2) : 0; } } }

packages.config

Notre prochain tutoriel vous présentera un exemple de bout en bout d'utilisation de Specflow et Selenium Webdriver!

Tutoriel SUIVANT

lecture recommandée

^