Ein vollständiger Leitfaden für Specflow und Behavior Driven Development (BDD) Tutorial:

Was ist Specflow?

Specflow ist ein Testframework, das BDD-Praktiken in .NET Framework unterstützt. Es ist ein Open-Source-Framework, das auf GitHub gehostet wird. Es hilft bei der Verwendung von ATDD (Acceptance Test Driver Development) für .NET-Anwendungen. Damit können wir ein Szenario in einfachem Englisch definieren, das von Gherkin Language definiert wird und von jedem klar verständlich ist.

Es gibt verschiedene Tools zum Schreiben von Tests im BDD-Ansatz wie Cucumber / JBehave für Java, Salat für Python, Jasmin für Javascript, Specflow für .NET.

BDD (Behavior Driven Development) ist eine Reihe von Praktiken oder ein Ansatz ähnlich wie TDD (Test Driven Development), der darauf abzielt, die Kommunikationslücke zwischen verschiedenen Interessengruppen wie Produkt, Entwicklern und Testern zu schließen.

Das Endziel des BDD-Ansatzes besteht darin, Geschäftsanforderungen zu erstellen, die vom gesamten Team verstanden werden können, um Missverständnisse zu vermeiden und das zu entwickelnde Feature auf die akzeptabelste Weise zu versenden.

Eine komplette Specflow-Tutorial-Serie:

Lesen Sie die komplette Specflow-Trainingsreihe durch, um das Konzept besser zu verstehen.

Tutorial # 1: Einführung in das Specflow BDD-Tool (dieses Tutorial)
Tutorial # 2: Specflow- und Selenium-Beispiel
Tutorial # 3: Specflow-Bindung & Erweiterte Konzepte
Tutorial # 4: Schritt 2: & Specflow-Tabellen
Tutorial #5: Specflow Living Documentation mit Pickles
Tutorial #6: Specflow Report Generator
Tutorial #7: Specflow Interview questions

Ein kurzer Überblick über die Tutorials der Specflow-Serie:

Beginnen wir mit dem ersten Tutorial dieser Serie.

Einführung in das Specflow BDD-Tool

Sehen Sie sich das Video-Tutorial an:

Hier ist ein Video-Tutorial zu Specflow und verhaltensgesteuerter Entwicklung:

Funktionen von BDD

Die wichtigsten Funktionen von BDD werden im Folgenden erläutert:

# 1) Es wird versucht, das Verhalten des Systems oder der Funktion, die entwickelt wird, anhand eines Beispiels oder Szenarios zu definieren. Wenn Sie beispielsweise eine einfache Taschenrechneranwendung erstellen, umfassen die verschiedenen Verhaltensweisen Addition, Multiplikation, Division usw.

Daher treffen sich über BDD zunächst alle Beteiligten, um das Verhalten der Anwendung wie Addition zu bestimmen, und haben Szenarien wie unten gezeigt.

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

Wenn Sie die obige Darstellung sehen, handelt es sich um ein Szenario in einfachem Englisch, das für jeden klar verständlich ist und die Anforderungen an ein Feature klar macht (gemäß den Akzeptanzkriterien). Daher besteht der erste Schritt darin, diese Anforderungen zu artikulieren.# 2) Jetzt mit einer Reihe dieser Szenarien schreibt die QA Tests gegen diese und dies wird zunächst fehlschlagen, da die Funktion noch nicht entwickelt ist.#3) Nun schreibt der Entwickler einen Feature-Code und führt diese Tests erneut aus.

#4) Die Tests können bestehen oder fehlschlagen. Wenn sie fehlschlagen – Code umgestalten und den Vorgang wiederholen

# 5) Sobald das Code-Refactoring abgeschlossen ist, sollten alle Szenarien / Tests bestanden werden.

Daher verwendet BDD im Wesentlichen den TDD-Ansatz und bringt ihn auf die nächste Ebene, indem es einige gemeinsame, leicht verständliche Spezifikationen in Form von Szenarien enthält. Sie repräsentieren auch die Feature-Dokumentation an sich.

Es gibt verschiedene Tools zum Schreiben von Tests im BDD-Ansatz wie Cucumber / JBehave für Java, Salat für Python, Jasmin für Javascript, Specflow für .NET.

In diesem Tutorial konzentrieren wir uns auf Specflow.

Lesen Sie auch => Top BDD Tools und Testing Framework

Die Schlüsselwörter – Gegeben, wenn & Dann

Aus der Unit-Test-Welt sind die meisten von uns mit 3 A’s vertraut, dh Arrangieren, handeln und behaupten. Nun, Gegeben, Wann und wann sind die Ersetzungen für diese in der BDD-Welt.

Lassen Sie uns ein Beispiel nehmen, um jedes davon zu verstehen. Angenommen, Sie listen ein Szenario zur Validierung eines Produkts auf, das dem Warenkorb einer E-Commerce-Anwendung hinzugefügt wird, für das Sie als Voraussetzung angemeldet sein müssen.

Die Spezifikation kann wie folgt geschrieben werden:

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 

Gegeben: Dies wird verwendet, um eine Reihe von Voraussetzungen für das zu definierende Szenario zu beschreiben. Im Beispiel ist die Voraussetzung des Szenarios beispielsweise ein angemeldeter Kunde. Im Vergleich zur Arrange-Analogie in einem Komponententest muss die Step-Implementierung daher sicherstellen, dass ein angemeldeter Kunde vorhanden ist.

Wann: Dies wird verwendet, um eine Aktion oder einen Ausführungsschritt zu beschreiben. Im Beispiel zeigt es, dass der Kunde versucht, ein Produkt in seinen Warenkorb zu legen. Daher kümmert sich die Step-Implementierung für diesen Schritt um den Simulationscode, um ein Produkt in den Warenkorb zu legen. Dies kann mit dem Act-Schritt in den Komponententests verglichen werden.

Then: Dies wird verwendet, um das Ergebnis des Szenarios zu beschreiben und im Wesentlichen, wo die Validierungen platziert werden sollen. Es kann mit dem Assert-Schritt in der Unit-Test-Welt verglichen werden. Im Beispiel hier wird durch die Schrittimplementierung festgestellt, ob das Produkt tatsächlich hinzugefügt wurde und die Menge der vom Kunden gewählten Menge entspricht.

Die Feature-Datei

Die Feature-Datei ist im Wesentlichen eine Gruppierung mehrerer Szenarien für die Anwendung in der Entwicklung oder im Test. Es kann auch einfach als verschiedene Module der Anwendung gedacht werden, durch die die Anwendung logisch getrennt werden kann.

Zum Beispiel:

Eine E-Commerce-Anwendung kann sich entscheiden, verschiedene High-Level-Feature-Dateien wie:

• Login/Logout-Funktionalität
• Warenkorb
• Zahlung usw.

Was ist Specflow?

Specflow ist ein Tool, das BDD-Praktiken in .NET Framework unterstützt. Es ist ein Open-Source-Framework, das auf GitHub gehostet wird. Es hilft bei der Verwendung von ATDD (Acceptance Test Driver Development) für .NET-Anwendungen.

Die Bindung von Geschäftsanforderungen an eine Anwendung anhand des Paradigmas der Spezifikation anhand von Beispielen hilft allen Beteiligten, das Anwendungsverhalten besser zu verstehen, und führt dazu, dass das Produkt mit den richtigen Erwartungen ausgeliefert wird.

Es verwendet die Gherkin-Syntax zum Erstellen von & Szenarien. Es hat auch ein aktives Diskussions- / Entwicklerforum.

Specflow – Erste Schritte

In diesem Abschnitt werden wir die Installation von Specflow in der Visual Studio-IDE und das Erstellen von Feature-Dateien für eine einfache String-Utility-Anwendung untersuchen.

Über Beispielanwendung

In diesem Tutorial werden wir verschiedene Funktionen des Specflow-Frameworks mit einer Taschenrechneranwendung veranschaulichen, die über Funktionen / Schnittstellen verfügt, um verschiedene Operationen bereitzustellen, wie:

1. Hinzufügen von 2 Zahlen.
2. Subtrahieren von 2 Zahlen.
3. Dividieren und Multiplizieren von 2 Zahlen.
4. Die Quadratwurzel der gegebenen Zahl finden.

Specflow-Installationsanleitung

Die Specflow-Installation ist ein 2-stufiger Prozess

# 1) Installieren der erforderlichen Plugins in der Visual Studio-IDE.

• Um das Specflow-Plugin zu installieren, navigieren Sie zu Extras -> Erweiterung & Updates.
• Klicken Sie nun im linken Bereich auf „Online“.
• Suchen Sie nun im rechten Bereich nach specflow.
• Wählen Sie in den Suchergebnissen „Specflow für Visual Studio 2017“ aus.

# 2) Einrichten des Projekts mit Feature-Dateien und Schrittdefinitionen.

• Erstellen Sie ein einfaches neues Projekt in Visual Studio. Wir können jede Art von Projekt wie Klassenbibliothek / Konsolenanwendung / Unit-Test-Projekt usw. erstellen. Der Einfachheit halber nehmen wir ein Klassenbibliotheksprojekt auf. Benennen Sie das Projekt als „SpecflowBasic“.
• Um die Specflow-Szenarien auszuführen, die wir erstellen werden, benötigen wir einen Testläufer. Specflow bietet einen Läufer aus der Box genannt Specflow + Runner (die eine kostenpflichtige Version ist und die kostenlose Version führt eine Verzögerung).

(Andere Runner sind auch für NUnit und MSTest verfügbar, die wir in den weiteren Artikeln dieser Serie sehen werden).Um Specflow + Runner zu installieren, navigieren Sie zu Tools -> NuGet Package Manager -> Paketmanager-Konsole.

Sobald die Paketmanager-Konsole geöffnet ist, führen Sie den Befehl aus.

 Install-Package SpecRun.SpecFlow

• Um die Werte zu bestätigen, benötigen wir auch die Hilfe eines Testframeworks. NUnit kann eine der Optionen sein und die anderen umfassen MSTest usw. Um das NUnit-Framework in der Anwendung zu installieren, öffnen Sie die Paketmanager-Konsole und geben Sie command ein.

 Install-Package NUnit 

# 3) Erstellen Sie eine neue Klasse mit dem Namen „CalculatorApplication“, die zu unserer zu testenden Anwendung wird. Dies ist eine einfache Klasse mit Funktionen zum Ausführen von Addition / Multiplikation / Division / Quadratwurzel usw., für die angegebene Eingabe. So sieht die CalculatorApplication-Klasse aus.# 4) Erstellen Sie nach der Installation des Pakets 2 Ordner im Projekt und benennen Sie sie als Features und Schrittdefinitionen zum Speichern der Feature-Dateien bzw. Wir werden den Grund für diese Ordnerorganisation für Feature & Schrittdefinitionen im Detail diskutieren.#5) Fügen Sie nun im Ordner Features eine neue Feature-Datei hinzu und nennen Sie sie CalculatorFeature.

Sie würden sehen, dass die Feature-Datei standardmäßig eine Beschreibung in Feature und Szenario enthält.

Ersetzen Sie das durch das, was wir testen werden.

 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) Schrittdefinitionen generieren: Specflow bietet eine automatisierte Möglichkeit, Bindungen / Implementierungen für die verschiedenen Schritte in Feature-File-Szenarien zu generieren. Dies kann erreicht werden, indem Sie mit der rechten Maustaste auf die Feature-Datei klicken und auf „Schrittdefinitionen generieren“ klicken.

Dieser Schritt garantiert keine Implementierung für alle Schritte, versucht jedoch, die allgemeinen Schritte in Szenarien zu gruppieren und so viele Bindungen wie möglich wiederzuverwenden. Es macht jedoch die Aufgabe, Boilerplate-Code jedes Mal zu vermeiden, wenn ein Szenarioschritt implementiert werden muss.

Nachdem Sie auf „Schrittdefinitionen generieren“ geklickt haben, wird ein Fenster mit den identifizierten Schrittimplementierungen angezeigt, die der Prozessor erkannt hat. Man kann nach den Anforderungen auswählen oder deaktivieren.

In den späteren Abschnitten werden wir uns eingehender mit dem Dropdown-Menü Stil befassen, das im obigen Screenshot gezeigt wird.

Lassen Sie uns vorerst alle mit den Standardeinstellungen auswählen. Wenn Sie auf die Vorschau klicken, wird eine Momentaufnahme der Implementierung angezeigt.

Nach dem Erstellen von Schrittdefinitionen haben die Feature-Dateien, wenn es einige nicht implementierte Schritte gibt, eine visuelle Möglichkeit, die nicht implementierten Anwendungen zu identifizieren. Es zeigt diese Schritte in einer anderen Farbe an, indem es absolut einfach zu wissen ist, dass es einige Schritte gibt, die noch keine Implementierung haben (oder mehrdeutige Schrittdefinitionen haben).

Ein Beispielbildschirm zeigt Folgendes:

Hinweis: Die Schrittdefinitionen können auch manuell erstellt werden – Beliebig .cs file having Attribut ist eine Step Implementierungsklasse und die Gherkin Syntax sucht nach der Implementierung des gegebenen Szenarios step

Execution

Da wir bereits Specflow+ Runner im obigen Abschnitt hinzugefügt haben, ist die Ausführung der Szenarien ziemlich einfach (da es sich um eine Testversion von Specrun handelt, wird eine variable Verzögerung von 10-20s eingeführt, bevor die Szenarien ausgeführt werden. , Diese Verzögerung ist für registrierte Varianten und andere Varianten von Specrun (wie NUnit und MSTest) nicht vorhanden.

Wenn nicht alle Schritte implementiert wurden und noch Bindungen mit dem Status pending vorhanden sind. Dann wird die Ausgabe als ausstehend angezeigt.

Lassen Sie uns versuchen, diese Tests / Szenarien an diesem Punkt auszuführen, wenn es keine Implementierung für die Bindungen gibt und die Szenarien alle ausstehend sind.

Versuchen wir nun, die CalculatorApplication Klasse mit den Methoden zu implementieren, die wir testen möchten, dh addieren, subtrahieren, multiplizieren, dividieren und sqrt.

Unten finden Sie ein Codebeispiel, wie unsere CalculatorApplication Klasse aussieht:

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

Sobald die Anwendung fertig ist, versuchen wir herauszufinden, wie die Bindungen für jeden der Szenarioschritte implementiert werden können.

Sehen wir uns den schrittweisen Ansatz an, um diese zu implementieren:

• Zuerst müssen wir eine Instanz der Anwendung haben, die getestet werden muss. Der Einfachheit halber können wir die AUT (Application Under Test class) in Schrittbindungen instanziieren und die instanziierte Instanz verwenden, um verschiedene Methoden / Funktionen gemäß dem implementierten Schritt aufzurufen.
• Um die Eingabe und Ausgabe zu erfassen, deklarieren wir Variablen, die diese Werte enthalten, um Funktionen für die Anwendungsinstanz aufzurufen.

Sehen wir uns die End-to-End-Implementierung für alle Bindungen an, die an der Validierung der Add Funktionalität beteiligt sind (der Rest der Szenarien erweitert dies einfach).

Das Add-Szenario sieht wie folgt aus:

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

Sehen wir uns die Schritt-Implementierung für jeden dieser einzelnen Schritte an. Für die Verwendung aller Step-Implementierungen deklarieren wir eine Instanz der zu testenden Anwendung sowie Variablen, die Eingabe- und Ausgabevariablen enthalten, wie unten gezeigt:

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

Sehen wir uns die Implementierung der Szenarioschritte nacheinander an.

Schritt 1: Gegeben, ich habe 70 und 20 als Eingaben angegeben.

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

Hier haben wir gerade die Eingabevariablen mit den Werten initialisiert, die aus den Szenarioschritten übergeben wurden. p0 und p1 sind die Werte, die aus dem Szenarioschritt übergeben werden und als 70 & 20 initialisiert werden.

Schritt 2: Wenn ich Hinzufügen drücke.

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

Dies ist der Ausführungs- (oder Act-) Schritt, in dem die eigentliche Methode für die zu testende Anwendung aufgerufen wird. Beachten Sie, dass die Anwendungsinstanz die Methode mit diesen Variablen aufrufen kann, da die Eingabevariablen input1 und input2 bereits die in Schritt 1 übergebenen Werte enthalten.

Schritt 3: – Dann sollte das Ergebnis 90 sein.

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

Dies ist der Validierungsschritt (oder Assert-Schritt), bei dem die Ausgabe durch den Methodenaufruf generiert und die Anwendungsinstanz anhand der erwarteten Ausgabe validiert wird.

Beachten Sie, dass das verwendete Assert-Schlüsselwort aus dem NUnit-Framework stammt, das je nach festgelegter Validierung / Erwartung true oder false zurückgibt. Falls false zurückgegeben wird, schlägt die Schrittimplementierung fehl und das Szenarioergebnis wird als fehlgeschlagen angezeigt.

Beachten Sie außerdem, dass die Ausgabevariable den Wert aus dem vorherigen Schritt erhält, in dem die tatsächliche Methode für die Anwendungsinstanz aufgerufen wurde.

Ähnlich wie oben werden Schrittimplementierungen für die restlichen Szenarioschritte auf die gleiche Weise ausgeführt, der Unterschied besteht darin, verschiedene Methoden für die Anwendungsinstanz aufzurufen und unterschiedliche Ausgabewerte zuzuweisen.

Sobald alle Szenarioschritte implementiert sind, können die Tests ausgeführt werden.

Die resultierende Ausgabe sieht wie folgt aus:

Sie können auch die Ausgabe des einzelnen Szenarios anzeigen, in dem auch die Ausgabe der einzelnen Schritte aufgelistet ist:

Fazit

Ich hoffe, dieser Artikel hätte Ihnen ein grundlegendes Verständnis dafür vermittelt, was BDD ist und welche Werkzeuge es gibt das unterstützt BDD für .NET, wo wir Specflow behandelt haben.

Wir haben auch die Installation und Ausführung von Specflow-Feature-Dateien mit Hilfe einer Beispielanwendung besprochen.

Codedateien

Die in der Anwendung verwendeten Codedateien werden unten angezeigt:

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

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

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

Unser bevorstehendes Tutorial wird Sie über ein End-to-End-Beispiel für die Verwendung von Specflow und Selenium Webdriver informieren!

NÄCHSTES Tutorial