specflow tutorial ultimate guide bdd tool
En komplet guide til specflow og adfærd drevet udvikling (BDD) vejledning:
Hvad er Specflow?
Specflow er en testramme, der understøtter BDD-praksis i .NET framework. Det er en open source-ramme hostet på GitHub. Det hjælper med at bruge ATDD (Acceptance test driver development) til .NET-applikationer. Med dette kan vi definere scenarie på almindeligt engelsk defineret af agurkesprog, der er tydeligt forståeligt for enhver.
Der er forskellige værktøjer til at skrive tests i BDD-tilgangen som Agurk / JBehave til Java, Salat til Python, Jasmine til Javascript, Specflow til .NET.
BDD (Behavior Driven Development) er et sæt praksis eller en tilgang svarende til TDD (Test Driven Development), som har til formål at bygge bro mellem kommunikationsgabet mellem forskellige interessenter som Product, Developers og Testers.
Det endelige mål med BDD-tilgangen er at skabe forretningskrav, der kan forstås af hele teamet for at undgå misforståelser, og hjælper med at sende den funktion, der udvikles, på den mest acceptable måde.
En komplet specflow tutorial-serie:
Læs gennem Komplet Specflow-træningsserie for bedre forståelse af konceptet.
Tutorial # 1: Introduktion til Specflow BDD Tool (Denne vejledning)
Tutorial # 2: Specflow og seleneksempel
Tutorial # 3: Specflow bindende og avancerede koncepter
Tutorial # 4: Trin Argument Transformationer & Specflow tabeller
Tutorial # 5: Specflow levende dokumentation med pickles
Tutorial # 6: Specflow rapportgenerator
Tutorial # 7: Specflow Interview spørgsmål
En kort oversigt over vejledninger i Specflow-serien:
| Vejledning # | Beskrivelse |
|---|---|
| 7 | Specflow Interview spørgsmål En liste over de mest populære Specflow-interviewspørgsmål og svar med eksempler er inkluderet i denne vejledning, så du kan knække ethvert Specflow-interview med succes ved første forsøg. |
| 1 | Introduktion til Specflow BDD Tool (Denne vejledning) Denne introduktionsvejledning forklarer dig alt om Specflow detaljeret. Specflow er en testramme, der understøtter BDD-praksis i .NET framework. Det er en open source-ramme hostet på GitHub. Det hjælper med at bruge ATDD (Acceptance test driver development) til .NET-applikationer. |
| to | Specflow og seleneksempel Denne tutorial vil fokusere på integration af selen med Specflow-rammer gennem et simpelt testscenarie med videosøgning på Youtube-applikationen. Du vil også kontrollere, hvordan du deler data på tværs af forskellige bindinger gennem private klassefelter. |
| 3 | Specflow og seleneksempel Denne tutorial vil fokusere på integration af selen med Specflow-rammer gennem et simpelt testscenarie med videosøgning på Youtube-applikationen. Du vil også kontrollere, hvordan du deler data på tværs af forskellige bindinger gennem private klassefelter. |
| 4 | Trin Argument Transformationer & Specflow tabeller Denne informative Specflow-tutorial ekspalerer i detaljer om trinargumenttransformationer, der tillader konvertering af brugerdefineret type til Specflow-argumenter for at undgå kedelpladekode, og Specflow-tabeller er nyttige, når du skal sende mange felter / data i et enkelt trin i en brugervenlig tabel. format. |
| 5 | Specflow levende dokumentation med pickles Fra denne Specflow-tutorial får du at vide, hvordan du genererer flot levende dokumentation gennem en open source-ramme kaldet pickles ved hjælp af dine eksisterende Specflow-filer. |
| 6 | Specflow rapportgenerator I denne Specflow-rapporteringsvejledning lærer du, hvordan du udfører Specflow-funktionstest sammen med generering af HTML-rapporter gennem den eksekverbare Specflow. |
Lad os starte med den første tutorial i denne serie.
Hvad du vil lære:
Introduktion til Specflow BDD Tool
Se videoundervisningen:
Her er en video tutorial om Specflow og Behavior Driven Development:
Funktioner ved BDD
Nøglefunktionerne i BDD er beskrevet nedenfor:
# 1) Den forsøger at definere systemets eller funktionens opførsel gennem et eksempel eller scenarie. For eksempel, hvis du bygger en simpel lommeregnerapplikation, inkluderer de forskellige adfærd addition, multiplikation, division osv.
Derfor gennem BDD mødes alle interessenter først for at bestemme applikationens opførsel som Tilføjelse og vil have scenarier som vist nedenfor.
Given, I have 2 numbers 30 and 50 as input When I add these 2 numbers Then I should get an output of 80Hvis du ser ovenstående repræsentation, er det et scenarie på almindelig engelsk, der er forståeligt for alle og gør kravene til en funktion klare (i henhold til acceptkriterierne). Derfor er det første skridt at formulere disse krav.
#to) Nu med et sæt af disse scenarier skriver QA test mod disse, og dette vil i første omgang mislykkes, da funktionen endnu ikke er udviklet.
# 3) Nu skriver udvikleren en funktionskode og udfører disse test igen.
# 4) Testene kan bestå eller mislykkes. Hvis de fejler - refaktorkode og gentag processen
# 5) Når kodefakturering er afsluttet, skal alle scenarier / test bestå.
Derfor bruger BDD i det væsentlige TDD-tilgang og tager det til det næste niveau ved at have nogle almindelige letforståelige specifikationer i form af scenarier. De repræsenterer også funktionsdokumentationen i sig selv.
Der er forskellige værktøjer til at skrive tests i BDD-tilgangen som Agurk / JBehave til Java, Salat til Python , Jasmin til Javascript, Specflow til .NET.
hvad er en god annonceblokering
I denne vejledning vil vi fokusere på Specflow.
Læs også => Top BDD-værktøjer og testrammer
Nøgleordene - givet, hvornår og derefter
Fra enhedstestverdenen er de fleste af os bekendt med 3 A'er, dvs. Arranger, Act og Assert. Nu, givet, hvornår og derefter er erstatningerne for disse i BDD-verdenen.
Lad os tage en Eksempel for at forstå hver af disse. Antag at du noterer et scenarie for validering af et produkt, der føjes til indkøbskurven i en e-handelsapplikation, som kræver, at du er logget ind som en forudsætning.
Specifikationen kan skrives som følger:
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 Givet :Dette bruges til at beskrive et sæt forudsætninger for det scenarie, der defineres. For eksempel er scenariets forudsætning i eksemplet en indlogget kunde. Derfor sammenlignes med Arranger analogi i en enhedstest, skal trinimplementeringen sikre, at der er en indlogget kunde.
Hvornår :Dette bruges til at beskrive et handlings- eller udførelsestrin. I eksemplet viser det, at kunden forsøger at tilføje et produkt til sin indkøbskurv. Derfor vil trinimplementeringen for dette trin tage sig af simuleringskoden for at tilføje et produkt i vognen. Dette kan sammenlignes med Handling trin i enhedstestene.
Derefter :Dette bruges til at beskrive resultatet af scenariet og i det væsentlige, hvor valideringerne skal placeres. Det kan sammenlignes med Hævde trin i enhedstestverdenen. I eksemplet her vil trinimplementeringen hævde, om produktet faktisk blev tilføjet, og mængden er den samme som den, kunden valgte.
Funktionsfilen
Funktionsfilen er i det væsentlige en gruppering af flere scenarier for applikationen under udvikling eller test. Det kan også simpelthen betragtes som forskellige moduler i applikationen, hvormed applikationen kan logisk adskilles.
For eksempel:
En e-handelsapplikation kan beslutte at have forskellige funktioner på højt niveau som:
- Login / Logout funktionalitet
- Indkøbskurv
- Betaling mv.
Hvad er Specflow?
Specflow er et værktøj, der understøtter BDD-praksis i .NET framework. Det er en open source-ramme hostet på GitHub. Det hjælper med at bruge ATDD (Acceptance test driver development) til .NET-applikationer.
Bindende forretningskrav til en applikation ved hjælp af Specification By Example paradigme hjælper med at få en bedre forståelse af applikationsadfærd fra alle interessenter og resulterer derved i at sende produktet med de korrekte forventninger.
Det gør brug af Agurk syntaks til oprettelse af funktioner og scenarier. Det har også en aktiv diskussion / udvikler forum .
Specflow - Kom godt i gang
I dette afsnit undersøger vi installation af specflow i Visual Studio IDE og oprettelse af funktionsfiler til et simpelt String Utility-program.
Om prøveansøgning
Vi illustrerer forskellige funktioner i Specflow-rammen i denne vejledning ved hjælp af en lommeregnerapplikation, der har funktioner / grænseflader til at give forskellige operationer som:
- Tilføjer 2 numre.
- Fratrækning af 2 tal.
- Opdeling og multiplikation af 2 tal.
- Find kvadratroden af det givne nummer.
Specflow Installationsvejledning
Specflow installation er en totrins proces
# 1) Installation af de nødvendige plugins i Visual Studio IDE.
- For at installere specflow-pluginet skal du navigere til Værktøjer -> Udvidelse og opdateringer.
- Klik nu på 'Online' i venstre panel.
- Søg nu efter specflow i højre panel.
- Vælg 'Specflow for Visual Studio 2017' fra søgeresultaterne.
#to) Opsætning af projektet med funktionsfiler og trindefinitioner.
- Opret et simpelt nyt projekt i Visual Studio. Vi kan oprette enhver form for projekt som klassebibliotek / konsolapplikation / enhedstestprojekt osv. For at gøre det nemmere tager vi et klassebiblioteksprojekt op. Navngiv projektet som “SpecflowBasic”.
- For at køre Specflow-scenarierne, som vi skal oprette, har vi brug for en testløber. Specflow giver en løber ud af boksen kaldet Specflow + Runner (som er en betalt version, og den gratis version introducerer en forsinkelse).
(Andre løbere er også tilgængelige for NUnit og MsTest, som vi vil se i de yderligere artikler i denne serie).
Sådan installeres Specflow + Runner - Naviger til Værktøjer -> NuGet Package Manager -> Package Manager Console.
Når Package Manager-konsollen åbnes - Kør kommandoen.
Install-Package SpecRun.SpecFlow 
- For at hævde værdierne har vi også brug for hjælp fra en testramme. NUnit kan være en af mulighederne, og de andre inkluderer MsTest osv. For at installere NUnit-rammen til applikationen skal du åbne Package Manager Console og skrive kommandoen.
Install-Package NUnit # 3) Opret en ny klasse med navnet “CalculatorApplication”, som bliver vores applikation under test. Dette er en simpel klasse, der har funktioner til at udføre addition / multiplikation / division / kvadratrod osv. For den givne input. Sådan ser klassen CalculatorApplication ud.
# 4) Når pakken er installeret, skal du oprette 2 mapper i projektet og navngive dem som henholdsvis funktioner og trindefinitioner til lagring af funktionsfilerne og trinbindingerne. Vi vil diskutere i detaljer årsagen til denne mappeorganisation for Feature & Step-definitioner.
# 5) Nu i funktionsmappen skal du tilføje en ny funktionsfil og navngive den som CalculatorFeature.
Du ser, at funktionsfilen som standard har en eller anden beskrivelse i Feature og Scenario.
Udskift det med det, vi skal teste.
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) Generering af trindefinitioner: Specflow giver en automatiseret måde at generere bindinger / implementering af de forskellige trin i funktionsscenarier på. Dette kan opnås ved at højreklikke på funktionsfilen og klikke på 'Generer trindefinitioner'.
Dette trin garanterer ikke en implementering for alle trin, men det prøver sit bedste for at gruppere de almindelige trin i scenarier og genbruge så mange bindinger, det kan. Det gør imidlertid jobbet med at undgå kedelpladekode hver gang et scenarie-trin skal implementeres.
Efter at have klikket 'Generer trindefinitioner' , Der vises et vindue, der viser de identificerede trinimplementeringer, som processoren har registreret. Man kan vælge eller fravælge efter kravene.
I de senere sektioner vil vi se på flere detaljer om rullemenuen Style vist i ovenstående skærmbillede.
Lad os indtil videre holde dem alle valgt med standardindstillinger. Ved at klikke på Preview vises et øjebliksbillede af, hvordan implementeringen vil se ud.
Efter oprettelse af trindefinitioner, hvis der er nogle ikke-implementerede trin, har Feature-filerne en visuel måde at identificere de ikke-implementerede applikationer på. Det viser disse trin i en anden farve ved at gøre det helt simpelt at vide, at der er nogle trin, der endnu ikke har en implementering (eller som har tvetydige trindefinitioner).
En eksempelskærm viser nedenunder:
Bemærk: Trindefinitionerne kan også oprettes manuelt - Enhver .cs-fil med (Binding) -attribut er en trinimplementeringsklasse, og agurkesyntaxen vil se efter at matche implementeringen af det givne scenarietrin
Udførelse
Da vi allerede har tilføjet Specflow + Runner i ovenstående afsnit, er det ganske ligetil at udføre scenarierne (da det er en evalueringsversion af Specrun, introducerer det en variabel forsinkelse på 10-20s, før scenarierne udføres., Denne forsinkelse er ikke til stede for registrerede varianter og andre varianter af Specrun runner som NUnit og MsTest).
Hvis alle trin har det ikke været implementeret, og hvis der stadig er bindinger, der har en ventende tilstand. Derefter vises output som afventende.
Lad os prøve at køre disse tests / scenarier på dette tidspunkt, når der ikke er nogen implementering af bindingerne, og scenarierne er alle afventende.
Lad os nu prøve at implementere CalculatorApplication-klassen med de metoder, vi vil teste, dvs. tilføje, trække fra, multiplicere, dele og sqrt.
Nedenfor er en kodeeksempel på, hvordan vores CalculatorApplication-klasse ser ud:
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; } } } Når applikationen er klar, skal vi prøve at finde ud af måderne til at implementere bindingerne for hvert af scenarietrinene.
Lad os se trin for trin tilgang til at implementere disse:
- Først skal vi have en forekomst af applikationen, der skal testes. For enkelheds skyld kan vi instantiere AUT (Application Under Test class) i trinbindinger og bruge den instantierede instans til faktisk at kalde forskellige metoder / funktioner i henhold til det trin, der implementeres.
- For at indfange input og output erklærer vi variabler, der holder disse værdier for at kalde funktioner på applikationsinstansen.
Lad os se slutningen til slut-implementeringen af alle de bindinger, der er involveret i validering af Tilføj-funktionaliteten (Resten af scenarierne udvider simpelthen dette).
Add-scenariet ser ud som vist nedenfor:
Scenario: Add two numbers Given I have provided 70 and 20 as the inputs When I press add Then the result should Lad os se trinimplementeringen for hvert af disse individuelle trin. Til brug for alle trinimplementeringer erklærer vi en forekomst af applikation under test samt variabler til at indeholde input- og outputvariabler som vist nedenfor:
// instantiating application instance CalculatorApplication app = new CalculatorApplication(); // variables to hold input values and the intermeditate result int input1, input2; double output; Lad os se implementeringen af scenarie trin en efter en.
Trin 1: Da jeg har givet 70 og 20 som indgangene.
(Given(@'I have provided (.*) and (.*) as the inputs')) public void GivenIHaveProvidedAndAsTheInputs(int p0, int p1) { input1 = p0; input2 = p1; } Her har vi lige initialiseret inputvariablerne med de værdier, der er sendt ind fra scenarie-trinene. p0 og p1 er de værdier, der sendes ind fra scenarietrinet og initialiseres som henholdsvis 70 og 20.
Trin 2: Når jeg trykker på tilføj.
(When(@'I press add')) public void WhenIPressAdd() { output = app.add(input1, input2); } Dette er udførelsestrinet (eller handlingen), hvor den aktuelle metode kaldes til den anvendte applikation. Bemærk, at da inputvariablerne input1 og input2 allerede indeholder de værdier, der blev sendt i trin1, kan applikationsinstansen kalde metoden med disse variabler.
Trin 3: - Så skal resultatet være 90.
(Then(@'the result should be (.*)')) public void ThenTheResultShouldBe(double p0) { Assert.AreEqual(p0, output); }Dette er Validation (eller Assert) trin, hvor output genereres af metoden kaldes til, og applikationsinstansen valideres mod det forventede output.
Bemærk, at Hævde det anvendte nøgleord er fra NUnit Framework, som returnerer true eller false afhængigt af den valgte validering / forventning. Hvis det returnerer falsk, vil det medføre, at trinimplementeringen mislykkes, og det viser scenarieresultatet som mislykket.
hash-tabel c ++ eksempel
Bemærk også, at outputvariablen får værdien fra det forrige trin, hvor den aktuelle metode blev kaldt på applikationsinstansen.
I lighed med ovenstående udføres trinimplementeringer for resten af scenarie-trinnene på samme måde, forskellen ligger i at kalde forskellige metoder på applikationsinstansen og hævde forskellige outputværdier.
Når alle scenarie trin er implementeret, kan testene udføres.
Den resulterende output ser ud som vist nedenfor:
Du kan også se output fra det enkelte scenario, som også viser output fra individuelle trin:
Konklusion
Håber, at denne artikel ville have givet dig en grundlæggende forståelse af, hvad BDD er, og hvad er de værktøjer, der understøtter BDD til .NET, hvor vi dækkede Specflow.
Vi diskuterede også installation og udførelse af Specflow-funktionsfiler ved hjælp af en prøveapplikation.
Kode filer
Kodefilerne, der bruges i applikationen, er vist nedenfor:
CalculatorFeatureSteps.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); } } } CalculatorApplication.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
Vores kommende tutorial giver dig en beskrivelse af End to End-eksemplet på brug af Specflow og Selenium Webdriver!
Anbefalet læsning
- Dybdegående formørkelsesvejledninger til begyndere
- TestLink Tutorial: En lægmandens guide til TestLink Test Management Tool (Tutorial # 1)
- Bugzilla Tutorial: Defect Management Tool Hands-on Tutorial
- TestComplete Tutorial: En omfattende GUI-testværktøjs guide til begyndere
- SeeTest Automation Tutorial: En mobil testautomatiseringsværktøjsvejledning
- Computer Networking Tutorial: The Ultimate Guide
- Vejledning til WAVE-tilgængelighedstestværktøj
- BDD (Behavior Driven Development) Framework: En komplet tutorial