specflow tutorial ultimate guide bdd tool
En komplett guide till specflöde och beteendriven utveckling (BDD) -handledning:
Vad är Specflow?
Specflow är ett testramverk som stöder BDD-metoder i .NET framework. Det är en öppen källkodsram som finns på GitHub. Det hjälper till att använda ATDD (Acceptance test driver development) för .NET-applikationer. Med detta kan vi definiera scenariot på vanlig engelska definierat av gurka-språket som är klart förståeligt för alla.
Det finns olika verktyg för att skriva tester i BDD-metoden som Gurka / JBehave för Java, Lettuce för Python, Jasmine för Javascript, Specflow för .NET.
BDD (Behavior Driven Development) är en uppsättning metoder eller ett tillvägagångssätt som liknar TDD (Test Driven Development), som syftar till att överbrygga kommunikationsgapet mellan olika intressenter som Product, Developers och Testers.
Slutmålet med BDD-metoden är att skapa affärskrav som kan förstås av hela teamet för att undvika missförstånd och hjälper till att leverera den funktion som utvecklas på det mest acceptabla sättet.
En komplett Specflow-handledningsserie:
Läs igenom Komplett Specflow-träningsserie för bättre förståelse av konceptet.
Handledning nr 1: Introduktion till Specflow BDD Tool (Denna handledning)
Handledning nr 2: Specflow och selenexempel
Självstudie 3: Specflow Binding & Advanced Concepts
Självstudie 4: Steg Argument Transformations & Specflow Tabeller
Handledning nr 5: Specflow levande dokumentation med pickles
Självstudie nr 6: Specflow Report Generator
Handledning nr 7: Specflow-intervjufrågor
En kort översikt över handledning i Specflow-serien:
Handledning # | Beskrivning |
---|---|
7 | Specflow-intervjufrågor En lista över de mest populära Specflow-intervjufrågorna och svaren med exempel ingår i denna handledning så att du kan knäcka alla Specflow-intervjuer framgångsrikt vid första försöket. |
1 | Introduktion till Specflow BDD Tool (Denna handledning) Denna introduktionshandledning kommer att förklara allt om Specflow i detalj. Specflow är ett testramverk som stöder BDD-metoder i .NET framework. Det är en öppen källkodsram som finns på GitHub. Det hjälper till att använda ATDD (Acceptance test driver development) för .NET-applikationer. |
två | Specflow och selenexempel Denna handledning kommer att fokusera på integrering av Selenium med Specflow-ramverk genom ett enkelt testscenario för videosökning på Youtube-applikationen. Du kommer också att kontrollera hur du delar data över olika bindningar genom privata klassfält. |
3 | Specflow och selenexempel Denna handledning kommer att fokusera på integrering av Selenium med Specflow-ramverk genom ett enkelt testscenario för videosökning på Youtube-applikationen. Du kommer också att kontrollera hur du delar data över olika bindningar genom privata klassfält. |
4 | Steg Argument Transformations & Specflow Tabeller Denna informativa Specflow-handledning expalinerar i detalj om Step Argument-transformationer som tillåter anpassade typkonverteringar för Specflow-argument för att undvika pannkodskod och Specflow-tabeller är praktiska när du behöver skicka in många fält / data i ett enda steg i en användarvänlig tabell. formatera. |
5 | Specflow levande dokumentation med pickles Från denna Specflow-handledning kommer du att lära dig hur du skapar snygg levande dokumentation genom en öppen källkodsram som kallas pickles med dina befintliga Specflow-filer. |
6 | Specflow Report Generator I den här Specflow-rapporteringshandledningen lär du dig hur du kör Specflow-funktionstester tillsammans med att generera HTML-rapporter genom Specflow-körningen. |
Låt oss börja med den första guiden i denna serie.
Vad du kommer att lära dig:
Introduktion till Specflow BDD Tool
Titta på videohandledningen:
Här är en videohandledning om Specflow och Behavior Driven Development:
Funktioner i BDD
De viktigaste funktionerna i BDD beskrivs nedan:
# 1) Den försöker definiera beteendet hos systemet eller funktionen som utvecklas genom ett exempel eller scenario. Om du till exempel bygger en enkel kalkylatorapplikation inkluderar de olika beteenden addition, multiplikation, division etc.
Genom BDD kommer därför alla intressenter att träffas först för att bestämma beteendet för applikationen som Addition och kommer att ha scenarier som visas nedan.
Given, I have 2 numbers 30 and 50 as input When I add these 2 numbers Then I should get an output of 80
Om du ser ovanstående representation är det ett scenario på vanlig engelska som är klart förståeligt för alla och som gör kraven på en funktion tydliga (enligt acceptanskriterierna). Därför är det första steget att formulera dessa krav.
#två) Nu med en uppsättning av dessa scenarier skriver QA tester mot dessa och detta kommer initialt att misslyckas eftersom funktionen ännu inte är utvecklad.
# 3) Nu skriver utvecklaren en funktionskod och kör dessa tester igen.
# 4) Testerna kan klara eller misslyckas. Om de misslyckas - refaktorkod och upprepa processen
# 5) När kodrefactoring är klar ska alla scenarier / tester klara.
Därför använder BDD i huvudsak TDD-tillvägagångssätt och tar det till nästa nivå genom att ha några vanliga lättförståelige specifikationer i form av scenarier. De representerar också funktionsdokumentationen i sig.
Det finns olika verktyg för att skriva tester i BDD-metoden som Gurka / JBehave för Java, Lettuce för Pytonorm , Jasmine for Javascript, Specflow för .NET.
vad är en testplan i qa
I denna handledning kommer vi att fokusera på Specflow.
Läs också => Topp BDD-verktyg och testramverk
Nyckelorden - ges, när och då
Från enhetstestvärlden är de flesta av oss bekanta med 3 A, dvs. Arranger, Act och Assert. Nu, givet, när och då är ersättarna för dessa i BDD-världen.
Låt oss ta en Exempel för att förstå var och en av dessa. Anta att du noterar ett scenario för att validera en produkt som läggs till i kundvagnen för en e-handelsapplikation som kräver att du är inloggad som en förutsättning.
Specifikationen kan skrivas enligt följande:
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
Given :Detta används för att beskriva en uppsättning förhandsvillkor för det scenario som definieras. Till exempel, i exemplet, är scenarioets förutsättning en inloggad kund. Därav jämförelse med Ordna analogi i ett enhetstest måste stegimplementeringen säkerställa att det finns en inloggad kund.
När :Detta används för att beskriva ett åtgärds- eller körningssteg. I exemplet visar det att kunden försöker lägga till en produkt i sin kundvagn. Därför kommer stegimplementeringen för detta steg att ta hand om simuleringskoden för att lägga till en produkt i kundvagnen. Detta kan jämföras med spela teater steg i enhetstesterna.
Sedan :Detta används för att beskriva resultatet av scenariot och i huvudsak var valideringen ska placeras i. Det kan jämföras med Hävda steg i enhetstestvärlden. I exemplet här kommer stegimplementeringen att påstå om produkten faktiskt har lagts till och kvantiteten är densamma som den som valts av kunden.
Funktionsfilen
Funktionsfilen är i huvudsak en gruppering av flera scenarier för applikationen under utveckling eller test. Det kan också helt enkelt ses på som olika moduler i applikationen genom vilka applikationen kan separeras logiskt.
Till exempel:
En e-handelsapplikation kan välja att ha olika högfunktionsfiler som:
- Inloggnings- / utloggningsfunktion
- Kundvagn
- Betalning etc.
Vad är Specflow?
Specflow är ett verktyg som stöder BDD-metoder i .NET framework. Det är en öppen källkodsram som finns på GitHub. Det hjälper till att använda ATDD (Acceptance test driver development) för .NET-applikationer.
Bindande affärskrav för en applikation med hjälp av Specification By Exempel paradigm hjälper till att bättre förstå applikationsbeteendet av alla intressenter och resulterar därmed i att leverera produkten med korrekta förväntningar.
Det använder sig av Gurka syntax för att skapa funktioner och scenarier. Det har också en aktiv diskussion / utvecklare forum .
Specflow - Komma igång
I det här avsnittet kommer vi att utforska installation av specflow i Visual Studio IDE och skapa funktionsfiler för en enkel String Utility-applikation.
Om provapplikation
Vi kommer att illustrera olika funktioner i Specflow-ramverket i den här självstudien med hjälp av en kalkylatorapplikation som har funktioner / gränssnitt för att tillhandahålla olika operationer som:
- Lägg till 2 nummer.
- Subtrahera 2 siffror.
- Dela och multiplicera 2 nummer.
- Hitta kvadratroten för det angivna numret.
Specflow Installationsguide
Specflow-installation är en tvåstegsprocess
# 1) Installera de nödvändiga tilläggen i Visual Studio IDE.
- För att installera specflow-plugin, navigera till Verktyg -> Tillägg och uppdateringar.
- Klicka nu på 'Online' i den vänstra panelen.
- Sök nu efter specflow i den högra panelen.
- Välj 'Specflow för Visual Studio 2017' i sökresultaten.
#två) Ställa in projektet med funktionsfiler och stegdefinitioner.
- Skapa ett enkelt nytt projekt i Visual Studio. Vi kan skapa alla typer av projekt som klassbibliotek / konsolapplikation / enhetstestprojekt etc. För enkelhetens skull tar vi upp ett klassbiblioteksprojekt. Namnge projektet som “SpecflowBasic”.
- För att kunna köra Specflow-scenarierna som vi ska skapa behöver vi en testlöpare. Specflow ger en löpare ur lådan som heter Specflow + Runner (som är en betald version och den gratis versionen introducerar en fördröjning).
(Andra löpare finns också för NUnit och MsTest som vi kommer att se i de ytterligare artiklarna i denna serie).
Så här installerar du Specflow + Runner - Navigera till Verktyg -> NuGet Package Manager -> Package Manager Console.
När Package Manager-konsolen öppnas - Kör kommandot.
Install-Package SpecRun.SpecFlow
- För att hävda värdena behöver vi också hjälp av ett testramverk. NUnit kan vara ett av alternativen och de andra inkluderar MsTest, etc. För att installera NUnit-ramverket till applikationen, öppna Package Manager Console och skriv kommandot.
Install-Package NUnit
# 3) Skapa en ny klass med namnet 'CalculatorApplication' som blir vår applikation som testas. Detta är en enkel klass som har funktioner för att utföra addition / multiplikation / division / kvadratrot etc. för den angivna ingången. Så här ser klassen CalculatorApplication ut.
# 4) När paketet har installerats skapar du två mappar i projektet och namnge dem som funktioner och stegdefinitioner för lagring av funktionsfiler respektive stegbindningar. Vi kommer att diskutera i detalj orsaken till denna mapporganisation för Feature & Step-definitioner.
# 5) Nu i funktionsmappen, lägg till en ny funktionsfil och namnge den som CalculatorFeature.
Du skulle se att funktionsfilen som standard har någon beskrivning i Feature och Scenario.
Ersätt det med det vi ska testa.
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) Generera stegdefinitioner: Specflow ger ett automatiserat sätt att generera bindningar / implementering för de olika stegen i funktionsfilsscenarier. Detta kan uppnås genom att högerklicka på funktionsfilen och klicka på 'Generate Step Definitions'.
Detta steg garanterar inte en implementering för alla steg, men det försöker sitt bästa för att gruppera de vanliga stegen i scenarier och återanvända så många bindningar som möjligt. Det gör dock jobbet att undvika pannkodskod varje gång ett scensteg måste implementeras.
Efter att ha klickat “Generera stegdefinitioner” , Ett fönster kommer att visas med de identifierade stegimplementeringarna som processorn har upptäckt. Man kan välja eller avmarkera enligt kraven.
I de senare avsnitten kommer vi att undersöka mer detaljer om rullgardinsmenyn Style som visas i ovanstående skärmdump.
Låt oss för närvarande hålla dem alla markerade med standardinställningar. Genom att klicka på förhandsgranskningen visas en ögonblicksbild av hur implementeringen kommer att se ut.
Efter att ha skapat stegdefinitioner, har det fortfarande visuella sätt att identifiera de oimplementerade applikationerna om det finns några icke implementerade steg. Det visar dessa steg i en annan färg genom att göra det helt enkelt att veta att det finns några steg som ännu inte har en implementering (eller som har tvetydiga stegdefinitioner).
En provskärm visar nedan:
Notera: Stegdefinitionerna kan också skapas manuellt - Alla .cs-filer med [Binding] -attribut är en stegimplementeringsklass och Gherkin-syntaxen kommer att leta efter matchning av implementeringen av det angivna scenariot.
Avrättning
Som vi redan har lagt till Specflow + Runner i avsnittet ovan är det ganska enkelt att köra scenarierna (eftersom det är en utvärderingsversion av Specrun introducerar den en variabel fördröjning på 10-20s innan scenarierna körs., Denna fördröjning finns inte för registrerade varianter och andra smaker av Specrun-löpare som NUnit och MsTest).
Om alla steg har inte varit implementeras och om det fortfarande finns bindningar som har ett väntande tillstånd. Då visas utgången som väntande.
Låt oss försöka köra dessa tester / scenarier vid denna tidpunkt när det inte finns någon implementering för bindningarna, och alla scenarierna väntar.
Låt oss nu försöka implementera klassen CalculatorApplication med de metoder som vi vill testa, dvs addera, subtrahera, multiplicera, dela och sqrt.
Nedan följer ett kodexempel på hur vår CalculatorApplication-klass ser ut:
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 är klar kan vi försöka ta reda på sätten att implementera bindningarna för vart och ett av scenaristegen.
Låt oss se steg för steg-metoden för att implementera dessa:
- Först måste vi ha en instans av applikationen som behöver testas. För enkelhetens skull kan vi starta AUT (klassen Application Under Test) i stegbindningar och använda den instanserade instansen för att faktiskt anropa olika metoder / funktioner enligt steget som implementeras.
- För att fånga in- och utdata förklarar vi variabler för att hålla dessa värden för att anropa funktioner i applikationsinstansen.
Låt oss se slutet till slut-implementeringen för alla bindningar som är inblandade i valideringen av Add-funktionen (resten av scenarierna utvidgar helt enkelt detta).
Lägg till scenariot ser ut som visas nedan:
Scenario: Add two numbers Given I have provided 70 and 20 as the inputs When I press add Then the result should
Låt oss se stegimplementeringen för vart och ett av dessa enskilda steg. För användning av alla stegimplementeringar förklarar vi en instans av applikation under test såväl som variabler för att hålla in- och utdatavariabler som visas nedan:
// instantiating application instance CalculatorApplication app = new CalculatorApplication(); // variables to hold input values and the intermeditate result int input1, input2; double output;
Låt oss se implementeringen av scenariostegen en efter en.
Steg 1: Med tanke på att jag har tillhandahållit 70 och 20 som ingångarna.
[Given(@'I have provided (.*) and (.*) as the inputs')] public void GivenIHaveProvidedAndAsTheInputs(int p0, int p1) { input1 = p0; input2 = p1; }
Här har vi just initierat inmatningsvariablerna med de värden som skickats in från scenariostegen. p0 och p1 är de värden som skickas in från scenaristeget och kommer att initieras till 70 respektive 20.
Steg 2: När jag trycker på lägg till.
[When(@'I press add')] public void WhenIPressAdd() { output = app.add(input1, input2); }
Detta är exekveringssteget (eller lagen) där den faktiska metoden anropas i applikationen som testas. Observera att eftersom ingångsvariablerna input1 och input2 redan innehåller de värden som skickades i steg 1 kan applikationsinstansen anropa metoden med dessa variabler.
Steg 3: - Då bör resultatet bli 90.
[Then(@'the result should be (.*)')] public void ThenTheResultShouldBe(double p0) { Assert.AreEqual(p0, output); }
Detta är valideringssteget (eller påståendet) där utdata genereras av metodanropet och applikationsinstansen valideras mot den förväntade utgången.
Lägg märke till att Hävda nyckelord som används är från NUnit Framework, som returnerar true eller false beroende på valideringen / förväntningen som ställts in. Om det returnerar falskt, kommer det att leda till att Step-implementeringen misslyckas och det visar att scenarioresultatet misslyckas.
vad används c ++ programmering för
Observera också att utdatavariabeln får värdet från föregående steg där den faktiska metoden anropades i applikationsinstansen.
I likhet med ovanstående utförs stegimplementeringar för resten av scenariot på samma sätt, skillnaden är att anropa olika metoder i applikationsinstansen och hävda olika utdatavärden.
När alla scenariot har implementerats kan testerna köras.
Den resulterande produktionen ser ut som nedan:
Du kan också visa utdata från det enskilda scenariot som också visar utdata från enskilda steg:
Slutsats
Hoppas att den här artikeln skulle ha gett dig en grundläggande förståelse för vad BDD är och vilka verktyg som stöder BDD för .NET där vi täckte Specflow.
Vi diskuterade också installation och körning av Specflow-funktionsfiler med hjälp av ett exempelprogram.
Kodfiler
Kodfilerna som används i applikationen visas nedan:
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
Vår kommande handledning kommer att informera dig om exempel på End to End för att använda Specflow och Selenium Webdriver!
Rekommenderad läsning
- Fördjupade förmörkningsövningar för nybörjare
- TestLink Tutorial: En lekman guide till TestLink Test Management Tool (Självstudie nr 1)
- Bugzilla Tutorial: Defect Management Tool Praktisk handledning
- TestComplete Tutorial: En omfattande GUI-testverktygsguide för nybörjare
- SeeTest Automation Tutorial: A Mobile Test Automation Tool Guide
- Handledning för datanätverk: den ultimata guiden
- Handledning för testning av WAVE-tillgänglighetsverktyg
- BDD (Behavior Driven Development) Framework: A Complete Tutorial