Un Guide complet du Didacticiel de Développement axé sur le Comportement et le comportement (BDD):

Qu’est-ce que Specflow?

Specflow est un framework de test prenant en charge les pratiques BDD dans .NET framework. 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 clair défini par un langage cornichon 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, Laitue pour Python, Jasmine pour Javascript, Specflow pour .NET.

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

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

Une série complète de tutoriels Specflow:

Lisez la série complète de formation Specflow pour une meilleure compréhension du concept.

Tutoriel #1: Introduction à l’outil BDD Specflow (Ce Tutoriel)
Tutoriel #2: Exemple de Specflow et de sélénium
Tutoriel #3: Liaison Specflow &Concepts avancés
Tutoriel #4: Transformations d’arguments d’étape &Tables Specflow
Tutoriel #5: Documentation vivante Specflow avec Cornichons
Tutoriel #6: Générateur de rapports Specflow
Tutoriel #7: Questions d’entrevue Specflow

Un Bref Aperçu des Tutoriels de la série Specflow:

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

Introduction à l’outil BDD Specflow

Regardez le Tutoriel vidéo:

Voici un tutoriel vidéo sur le développement axé sur Specflow et 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 construisez une application de calculatrice simple, les différents comportements incluent l’addition, la multiplication, la division, etc.

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

Given, I have 2 numbers 30 and 50 as inputWhen I add these 2 numbersThen I should get an output of 80

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

#2) Maintenant, avec un ensemble de ces scénarios, l’assurance qualité é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, refactorisez le code et répétez le processus

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

Par conséquent, en substance, BDD utilise l’approche TDD et l’amène au niveau suivant 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 soi.

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

Dans ce tutoriel, nous allons nous concentrer sur Specflow.

Lisez également =>Outils BDD et cadre de test

Les mots–clés – Donnés, Lorsque &Puis

Du monde des tests unitaires, la plupart d’entre nous sont familiers avec 3 A, c’est-à-dire Organiser, Agir et affirmer. Maintenant, Étant donné, Quand et puis sont les remplacements de ceux-ci dans le monde BDD.

Prenons un Exemple pour comprendre chacun de ces éléments. Supposons que vous répertoriez un scénario de validation d’un produit ajouté au panier d’une application de commerce électronique qui nécessite que vous soyez connecté comme préalable.

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

Scenario: Products get added to cart for a logged in customerGiven I have a logged-in customer on my applicationWhen I add 2 quantity of a product to my shopping cartThen 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 à définir. Par exemple, dans l’exemple, la condition préalable du scénario est un client connecté. Par conséquent, en comparant à l’analogie d’arrangement dans un test unitaire, l’implémentation de l’étape devra s’assurer qu’il y a un client connecté.

Quand : Ceci est utilisé pour décrire une action ou une étape d’exécution. Dans l’exemple, cela montre que le client essaie d’ajouter un produit à son panier. Par conséquent, l’implémentation de l’étape pour cette étape prendra en charge le code de simulation pour ajouter un produit au panier. Cela peut être comparé à l’étape Act dans les tests unitaires.

Ensuite: 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é à l’étape Assert dans le monde des tests unitaires. Dans l’exemple ici, la mise en œuvre de l’étape indiquera 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 d’entité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 d’achat
• Paiement etc.

Qu’est-ce que Specflow ?

Specflow est un outil prenant en charge les pratiques BDD dans .NET framework. 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.

Les exigences métier contraignantes pour une application utilisant le paradigme de spécification par exemple aident à mieux comprendre le comportement de l’application par toutes les parties prenantes et permettent ainsi d’expédier le produit avec des attentes correctes.

Il utilise la syntaxe du cornichon pour créer des scénarios de fonctionnalités &. Il dispose également d’un forum de discussion / développeur actif.

Specflow – Mise en route

Dans cette section, nous allons explorer l’installation de specflow dans l’EDI Visual Studio et la création de fichiers d’entités pour une application utilitaire de chaîne simple.

À propos de l’exemple d’application

Nous allons illustrer différentes fonctionnalités du framework Specflow dans ce tutoriel en utilisant une application de calculatrice qui a des fonctions / interfaces pour fournir différentes opérations comme:

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

Guide d’installation de Specflow

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

#1)Installer les plugins requis dans l’EDI Visual Studio.

• Pour installer le plugin specflow, accédez à Tools->Extension & 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″ »

#2) Configuration du projet avec des fichiers de fonctionnalités et des définitions d’étapes.

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

(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 à Tools – >Gestionnaire de paquets NuGet – > Console du gestionnaire de paquets.

Une fois la console du Gestionnaire de paquets ouverte, Exécutez la commande.

 Install-Package SpecRun.SpecFlow

• De plus, 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 paquets et tapez la commande.

 Install-Package NUnit 

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

#4) Une fois le paquet installé, créez 2 dossiers dans le projet et nommez-les comme Caractéristiques et Définitions d’étapes pour stocker respectivement les fichiers d’entités et les liaisons d’étapes. Nous discuterons en détail de la raison de cette organisation du dossier pour les définitions d’étape de la fonctionnalité &.

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

Vous verrez que par défaut le fichier de fonctionnalité a une description dans la fonctionnalité et le scénario.

Remplacez cela par ce que nous allons tester.

 Feature: CalculatorFeatureIn order to test my applicationAs a developerI want to validate different operations of the applicationScenario: Add two numbersGiven I have provided 70 and 20 as the inputsWhen I press addThen the result should be 90Scenario: Substract two numbersGiven I have provided 70 and 20 as the inputsWhen I press substractThen the result should be 50Scenario: Multiply two numbersGiven I have provided 70 and 20 as the inputsWhen I press multiplyThen the result should be 1400Scenario: Divide two numbersGiven I have provided 70 and 20 as the inputsWhen I press divideThen the result should be 3.5Scenario: SquareRoot of numberGiven I have provided 70 as inputWhen I press squarerootThen 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 dans les scénarios de fichiers d’entités. Cela 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’étapes ».

Cette étape ne garantit pas une implémentation pour toutes les étapes, mais elle fait de son mieux pour regrouper les étapes communes dans des scénarios et réutiliser autant de liaisons qu’elle le peut. Cependant, il s’agit d’éviter le code standard à chaque fois qu’une étape de scénario doit être implémentée.

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

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

Pour l’instant, gardons-les tous sélectionnés avec les paramètres par défaut. En cliquant sur l’aperçu, vous verrez un instantané de l’apparence de l’implémentation.

Après avoir créé des définitions d’étapes, s’il y a des étapes non implémentées, les fichiers de fonctionnalités ont 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 y a certaines étapes qui n’ont pas encore d’implémentation (ou qui ont des définitions d’étapes ambiguës).

Un Exemple d’écran Illustre cela Ci-dessous :

Remarque : Les définitions d’étape peuvent également être créées manuellement – N’importe quelle.le fichier cs ayant un attribut 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 secondes avant l’exécution des scénarios. , Ce délai n’est pas présent pour les variantes enregistrées et autres saveurs de Specrun runner comme NUnit et MsTest).

Si toutes les étapes n’ont pas été implémentées et s’il existe encore des liaisons qui ont un état en attente. Ensuite, la sortie s’affichera comme 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.

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.

Ci-dessous est un exemple de code de la façon dont notre classe CalculatorApplication ressemble:

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 l’application 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 implémenter:

• Tout d’abord, nous devons avoir une instance de l’application qui doit être testée. Pour plus de simplicité, nous pouvons instancier l’AUT (Application Sous classe de test) dans les liaisons par étapes et utiliser l’instance instanciée pour appeler 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 de l’application.

Voyons l’implémentation de bout en bout pour toutes les liaisons impliquées dans la validation de la fonctionnalité Add (le reste des scénarios l’étendent simplement).

Le scénario d’ajout se présente comme indiqué 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 l’implémentation de l’étape pour chacune de ces étapes individuelles. Pour l’utilisation de toutes les implémentations d’étapes, nous déclarons une instance d’application en cours de test ainsi que des variables pour contenir les 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 l’implémentation des étapes du scénario une par une.

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

 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 comme 70 &20 respectivement.

Étape 2: Lorsque j’appuie sur ajouter.

 public void WhenIPressAdd() { output = app.add(input1, input2); } 

Il s’agit de l’étape d’Exécution (ou Act) 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 transmises à l’étape 1, l’instance d’application peut appeler la méthode avec ces variables.

Étape 3: – Alors le résultat devrait être de 90.

 public void ThenTheResultShouldBe(double p0) { Assert.AreEqual(p0, output); }

Il s’agit de l’étape de validation (ou d’affirmation) 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.

Notez que le mot-clé Assert utilisé provient du framework NUnit, qui renvoie true ou false en fonction de la validation/ attente définie. Dans le cas où il renvoie false, cela entraînera l’échec de l’implémentation de l’étape et affichera le résultat du scénario comme un échec.

Notez également 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 de l’application.

De manière similaire à ce qui précède, les implémentations d’étapes 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 de l’application et l’affirmation de différentes valeurs de sortie.

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

La sortie résultante se présente comme indiqué ci-dessous:

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

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 de fichiers d’entité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:

Étapes de calcul.cs

using System;using TechTalk.SpecFlow;using NUnit;using NUnit.Framework;namespace SpecflowBasic.StepDefinitions{public class CalculatorFeatureSteps{// instantiating application instanceCalculatorApplication app = new CalculatorApplication();// variables to hold input values and the intermeditate resultint input1, input2;double output;public void GivenIHaveProvidedAndAsTheInputs(int p0, int p1){input1 = p0;input2 = p1;}public void GivenIHaveProvidedAsInput(int p0){input1 = p0;}public void WhenIPressAdd(){output = app.add(input1, input2);}public void WhenIPressSubstract(){output = app.subsctract(input1, input2);}public void WhenIPressMultiply(){output = app.multiply(input1, input2);}public void WhenIPressDivide(){output = app.divide(input1, input2);}public void WhenIPressSquareroot(){output = app.squareRoot(input1);}public void ThenTheResultShouldBe(double p0){Assert.AreEqual(p0, output);}}} 

Application de calcul.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;}}} 

paquets.config

<?xml version="1.0" encoding="utf-8"?><packages><package version="10.0.3" targetFramework="net461" /><package version="3.11.0" targetFramework="net461" /><package version="2.4.0" targetFramework="net461" /><package version="1.8.5" targetFramework="net461" /><package version="1.8.5" targetFramework="net461" /><package version="1.8.5" targetFramework="net461" /><package version="4.3.0" targetFramework="net461" /></packages>

Notre prochain tutoriel vous informera de bout en bout de l’utilisation de Specflow et Selenium Webdriver!

Tutoriel SUIVANT