en komplet Guide til specs og Behavior Driven Development (BDD) Tutorial:

Hvad er specs?

Specurve er en testramme, der understøtter BDD-praksis i.net-rammen. 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 Agurksprog, der er klart forståeligt af nogen.

der er forskellige værktøjer til at skrive test i BDD-tilgangen som agurk / JBehave til Java, salat til Python, Jasmine til Javascript, Speclyde til .NET.

BDD (Behavior Driven Development) er et sæt praksis eller en tilgang svarende til TDD (Test Driven Development), der sigter mod at bygge bro over kommunikationsgabet mellem forskellige interessenter som produkt, udviklere og testere.

slutmålet med BDD-tilgangen er at skabe forretningskrav, der kunne 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 Specurve Tutorial Series:

Læs gennem den komplette Specurve træningsserie for bedre forståelse af konceptet.

Tutorial # 1: Introduktion til Specurve BDD Værktøj(denne Tutorial)
Tutorial #2: Specurve og selen eksempel
Tutorial #3: Specurve Binding & avancerede koncepter
Tutorial #4: Trin Argumenttransformationer & Speckstrømstabeller
Tutorial # 5: Speckstrøm levende dokumentation med Pickles
Tutorial #6: Speckstrømsrapportgenerator
Tutorial #7: Speckstrømsintervju spørgsmål

en kort oversigt over Tutorials i Speckstrømserien:

lad os starte med den første tutorial i denne serie.

Introduktion til Specflod BDD værktøj

se Video Tutorial:

Her er en video tutorial om Specflod og adfærd drevet udvikling:

funktioner af BDD

nøglefunktionerne i BDD er orienteret nedenfor:

#1) det forsøger at definere opførslen af systemet eller funktionen, der udvikles gennem et eksempel eller scenario. For eksempel, hvis du bygger en simpel regnemaskine ansøgning derefter de forskellige adfærd omfatter tilføjelse, multiplikation, division, etc.

derfor gennem BDD, alle interessenter vil først mødes for at beslutte opførslen af ansøgningen ligesom Tilføjelse og vil have scenarier som vist nedenfor.

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

Hvis du ser ovenstående repræsentation, er det et scenario på almindeligt engelsk, der er klart forståeligt af nogen og gør kravene til en funktion klar (i henhold til acceptkriterierne). Derfor er det første skridt at formulere disse krav.

#2) Nu med et sæt af disse scenarier skriver kvalitetssikringen 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 tests igen.

#4) testene kan bestå eller mislykkes. Hvis de fejler-refactor kode og gentag processen

#5) Når kode refactoring er færdig, skal alle scenarier/tests passere.

derfor bruger BDD i det væsentlige TDD-tilgang og tager det til næste niveau ved at have nogle fælles let forstå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, Jasmine til Javascript, Speclource for .NET.

i denne vejledning vil vi fokusere på Speclurance.

Læs også = > Top BDD – værktøjer og testramme

nøgleordene-givet, når & derefter

fra enhedstestverdenen er de fleste af os bekendt med 3 A ‘ er, dvs.arrangere, handle og hævde. Nu, givet, hvornår og da er erstatningerne for disse i BDD-verdenen.

lad os tage et eksempel for at forstå hver af disse. Antag, at du notering ned et scenario for validering af et produkt, der bliver tilføjet til indkøbskurven af en e-handel program, 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 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 

givet: dette bruges til at beskrive et sæt forudsætninger for scenariet, der defineres. For eksempel er scenariets forudsætning i eksemplet En logget kunde. Derfor sammenlignes med Arranger-analogien i en enhedstest, trinimplementeringen skal sikre, at der er en logget ind kunde.

hvornår: dette bruges til at beskrive en handling 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 til vognen. Dette kan sammenlignes med Act-trinnet i Enhedstestene.

derefter: dette bruges til at beskrive resultatet af scenariet og i det væsentlige hvor valideringerne skal placeres. Det kan sammenlignes med Assert-trinnet i Enhedstestverdenen. I eksemplet her vil trinimplementeringen hævde, om produktet faktisk blev tilføjet, og mængden er den samme som den, der blev valgt af kunden.

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 logisk kan adskilles.

for eksempel:

en e-handelsapplikation kan beslutte at have forskellige funktionsfiler på højt niveau som:

• Login/Logout-funktionalitet
• indkøbskurv
• betaling osv.

Hvad er specs?

Specurve er et værktøj, der understøtter BDD-praksis i.net-rammen. 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 specifikation ved Eksempelparadigme hjælper med en bedre forståelse af applikationsadfærden hos alle interessenter og resulterer derved i forsendelse af produktet med korrekte forventninger.

det gør brug af Gherkin syntaks for at skabe funktioner& scenarier. Det har også en aktiv diskussion / Udvikler forum.

Specurve – Kom godt i gang

i dette afsnit undersøger vi installation af specurve i Visual Studio IDE og oprettelse af funktionsfiler til et simpelt program til Strengværktøj.

om prøveapplikation

vi illustrerer forskellige funktioner i Spektralrammen i denne vejledning ved hjælp af en Lommeregnerapplikation, der har funktioner/grænseflader til at levere forskellige operationer som:

1. tilføjelse af 2 numre.
2. subtraktion af 2 Tal.
3. dividere og multiplicere 2 Tal.
4. find kvadratroden af det givne tal.

Installationsvejledning til lysstrøm

installation af lysstrøm er en 2-trins proces

#1) installation af de nødvendige plugins i Visual Studio IDE.

• for at installere speckstrømmen plugin navigere til værktøjer- > udvidelse& opdateringer.
• Klik nu på “Online” i venstre panel.
• Søg nu efter specløb i højre panel.
• fra søgeresultaterne skal du vælge “Specløb for Visual Studio 2017”.

#2) 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 enkelhedens skyld tager vi et Klassebiblioteksprojekt op. Navngiv projektet som”Specurbasic”.
• for at køre de Spektrumscenarier, vi skal oprette, har vi brug for en testløber. Specurve giver en løber ud af boksen kaldet Specurve + 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).

for at installere Specløb + Runner – Naviger til værktøjer- >NuGet Package Manager -> Package Manager Console.

Når Pakkehåndteringskonsollen åbnes – Kør kommandoen.

 Install-Package SpecRun.SpecFlow

• for at hævde værdierne skal vi også bruge 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-konsollen og skrive kommandoen.

 Install-Package NUnit 

#3) Opret en ny klasse med navnet “CalculatorApplication”, som bliver vores ansøgning under test. Dette er en simpel klasse, der har funktioner til at udføre tilføjelse/multiplikation/division/kvadratrod osv., for det givne input. Sådan ser Calculatorapplicationsklassen ud.

#4) når pakken bliver installeret, skal du oprette 2 mapper i projektet og navngive dem som funktioner og Trindefinitioner til lagring af henholdsvis funktionsfiler og trinbindinger. Vi vil diskutere detaljeret årsagen til denne mappeorganisation for funktionen & trindefinitioner.

#5) Tilføj nu en ny Funktionsfil i mappen funktioner og navngiv den som CalculatorFeature.

du vil se, at funktionsfilen som standard har en beskrivelse i funktion og scenarie.

udskift det med det, vi skal teste.

 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) generering af Trindefinitioner: Specourse giver en automatiseret måde at generere bindinger/implementering til de forskellige trin i funktionsfilscenarier. 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 forsøger sit bedste for at gruppere de fælles trin i scenarier og genbruge så mange bindinger det kan. Det gør dog jobbet med at undgå kedelpladekode, hver gang et scenarietrin skal implementeres.

Når du har klikket på” Generer Trindefinitioner”, vises et vindue med en liste over de identificerede trinimplementeringer, som processoren har registreret. Man kan vælge eller de-select som pr kravene.

i de senere afsnit vil vi undersøge flere detaljer om rullemenuen Stil vist i ovenstående skærmbillede.

lad os nu holde dem alle valgt med standardindstillinger. Ved at klikke på forhåndsvisningen vises et øjebliksbillede af, hvordan implementeringen vil se ud.

efter oprettelse af Trindefinitioner, stadig, hvis der er nogle uimplementerede trin, har Funktionsfilerne 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 enkelt at vide, at der er nogle trin, der endnu ikke har en implementering (eller har tvetydige trindefinitioner).

en Prøveskærm viser det nedenfor:

Bemærk: Trindefinitionerne kan også oprettes manuelt – enhver .cs-fil, der har attribut, er en Trinimplementeringsklasse, og Gherkin-syntaksen vil se efter at matche implementeringen af det givne scenarietrin

udførelse

da vi allerede har tilføjet Specurve+ Runner i ovenstående afsnit, er det ret ligetil at udføre scenarierne (da det er en evalueringsversion af Specrun, introducerer den en variabel forsinkelse på 10-20 ‘ erne, 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 ikke er implementeret, og hvis der stadig er bindinger, der har en verserende 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 for bindingerne, og scenarierne afventer alle.

lad os nu prøve at implementere Beregningenapplikationsklasse med de metoder, vi vil teste, dvs.

nedenfor er en kodeeksempel på, hvordan vores CalculatorApplication class 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, lad os prøve at finde ud af måderne til at implementere bindingerne for hvert af scenarietrinnene.

lad os se den trinvise tilgang til implementering af disse:

• først skal vi have en forekomst af applikationen, der skal testes. For enkelhed 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 er implementeret.
• for at fange input og output erklærer vi variabler for at holde disse værdier for at kalde funktioner på Applikationsforekomsten.

lad os se end to end-implementeringen for alle bindinger, der er involveret i validering af Tilføjelsesfunktionaliteten (resten af scenarierne udvider simpelthen dette).

Tilføjelsesscenariet 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 holde 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 scenarietrin en efter en.

Trin 1: givet Jeg har givet 70 og 20 som input.

 public void GivenIHaveProvidedAndAsTheInputs(int p0, int p1) { input1 = p0; input2 = p1; } 

Her har vi netop initialiseret inputvariablerne med de værdier, der er overført fra scenarietrinnene. p0 og p1 er de værdier, der overføres fra scenarietrinnet og initialiseres som henholdsvis 70 & 20.

Trin 2: Når jeg trykker på Tilføj.

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

Dette er Udførelsestrinnet (eller Act), hvor den faktiske metode kaldes på applikationen under test. Bemærk, at da inputvariablerne input1 og input2 allerede indeholder de værdier, der er bestået i trin1, kan applikationsinstansen kalde metoden med disse variabler.

Trin 3: – så skal resultatet være 90.

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

Dette er Valideringstrinnet (eller Assert), hvor output genereres af metodeopkaldet, og Applikationsinstansen valideres mod det forventede output.

Bemærk, at det anvendte Assert-søgeord er fra NUnit-rammen, som returnerer true eller false afhængigt af den Validering/forventning, der er indstillet. Hvis det returnerer FALSK, vil det medføre, at Trinimplementeringen mislykkes, og det vil vise scenarieresultatet som mislykkes.

Bemærk også, at outputvariablen får værdien fra det foregående trin, hvor den faktiske metode blev kaldt på applikationsinstansen.

I lighed med ovenstående udføres Trinimplementeringer for resten af scenarietrinene på samme måde, forskellen er at kalde forskellige metoder på applikationsinstansen og hævde forskellige outputværdier.

når alle Scenarietrin er implementeret, kan testene udføres.

den resulterende output vil se ud som vist nedenfor:

Du kan også se output fra det individuelle scenarie, der 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 BDD er hvad er de værktøjer, der understøtter BDD til.net, hvor vi dækkede specs.

vi diskuterede også installation og udførelse af Funktionsfiler ved hjælp af en prøveapplikation.

kodefiler

de kodefiler, der bruges i applikationen, er vist nedenfor:

CalculatorFeatureSteps.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);}}} 

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;}}} 

pakker.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>

vores kommende tutorial vil orientere dig om Ende til Ende eksempel på at bruge specs og selen Netdriver!

næste Tutorial