Gurke Features: eine Übersicht

Einleitung

Gherkin ist eine Sprache, die immer noch in vielen Testautomatisierungs-Frameworks verwendet wird. Manchmal liegt es daran, dass der Kunde von uns verlangt, dass wir es verwenden, manchmal liegt es daran, dass das Team sich dafür entscheidet.

Ehrlich gesagt war es für mich keine Liebe auf den ersten Blick. Ich persönlich habe eine ziemlich lange Reise mit Gherkin hinter mir – von der anfänglichen Gefallenheit über die Abneigung gegen die Sprache bis hin zur erneuten Gefallenheit. In diesem Artikel werde ich die wichtigsten Cucumber-Funktionen zusammen mit der Java-Implementierung vorstellen.

Hier sind alle Cucumber-Funktionen, die in diesem Artikel behandelt werden:

Feature-Datei

Zunächst einmal, was ist eine Feature-Datei? In der technischen Welt wurde ein nicht-technischer Ansatz entwickelt, um es nicht-technischen Personen zu ermöglichen, während der Entwicklung einer App mit dem Team zusammenzuarbeiten. Die Gherkin-Sprache wurde als zusätzliche Schicht im BDD-Ansatz geschaffen. Die Gherkin-Tests befinden sich in den sogenannten Feature-Dateien, die mit dem Code (Java, Kotlin, C# etc.) verklebt werden. Normalerweise ist Gherkin sehr einfach zu bedienen und erfordert minimale Programmierkenntnisse, aber es gibt Funktionen, die etwas Codierung erfordern.

Beginnen wir mit etwas Einfachem.

Szenario

Hier ist das grundlegendste und am einfachsten zu verwendende Beispiel für den Gurkentest:

 Funktion: Szenario

 Hintergrund: Vorher-Testszenarien
   Da führe ich vor dem Schritt aus

 @Prüfen
 Szenario: Szenario 
   Angenommen, ich verwende den parametrisierten Schritt von "Szenario 1".

Codeblock 1. Szenario

Codeblock 1. enthält einige Dinge, die erklärt werden müssen:

• Feature : Der Titel der Feature-Datei
• Background : Das Schlüsselwort, das es dem Benutzer ermöglicht, Testschritte vor jedem in der Feature-Datei definierten Testszenario auszuführen
• @Test : Tag, das dem Testframework mitteilt, welches Testszenario ausgeführt werden soll. „Test“ wird vom Benutzer definiert. Wir können zB „@SmokeTest“ verwenden
• Szenario : Name des Testszenarios

Gherkin-Tests verwenden vor jedem Testschritt die Schlüsselwörter [Given, When, Then, But]. In unserem einzigen Testschritt, außer dem Hintergrundschritt, verwenden wir einen Parameter, in dem wir den Wert „Szenario 1“ übergeben.

Sehen wir uns nun an, wie der geklebte Java-Code aussieht:

 @Given("Ich führe vor dem Schritt aus")
public void iExecuteBeforeStep() {
   // etwas Implementierung
}

@Given("Ich verwende den parametrisierten Schritt von {string}")
public void iUseParametrizedStepOf(String p) {
   // etwas Implementierung
}

Code-Block 2. Java-Code-Implementierung des Szenarios

Szenarioübersicht

Machen wir etwas Komplexeres:

 Feature: Szenarioübersicht

 @Prüfen
 Szenarioskizze: Szenarioskizze
   Angenommen, ich führe den Schritt mit "<parameter1>" und "<parameter2>" aus
 Beispiele:
     | parameter1 | parameter2 |
     | parameter1a | parameter2a |
     | parameter1b | parameter2b |

Codeblock 3. Szenarioskizze

Dieses Mal verwenden wir die Scenario Outline, die es uns ermöglicht, Testszenarien mit unterschiedlichen Testdatenkonfigurationen zu wiederholen. Codeblock 3. enthält einige Dinge, die erklärt werden müssen:

• Beispiele : die Matrix von Testdaten, die von Testszenarien verwendet werden sollen. Die erste Zeile ist eine Kopfzeile mit Parameternamen.

Und Java-Implementierung:

 @Given("Ich führe den Schritt mit {string} und {string} aus")
public void iRunStepWithAnd(String p1, String p2) {
   // etwas Implementierung
}

Codeblock 4. Java-Implementierung von Scenario Outline

Datentabelle

Die Szenarioskizze ist sehr nützlich, aber was ist, wenn wir nicht das gesamte Testszenario, sondern nur einen Testschritt wiederholen möchten? Gherkin hat eine Möglichkeit, dies zu tun, und sie heißt „Data Table“.

 Feature: Datentabelle

@Prüfen
Szenario: Datentabellen-Szenario
 Da ich verifiziere, dass die Spalte den erwarteten Wert enthält
 | Spaltenname | erwartetWert |
 | irgendeinSpaltenname | irgendeinerwarteterWert |

Codeblock 5. Datentabelle

Das Szenario mit Datentabelle unterscheidet sich nicht wesentlich von der Szenarioskizze. Das einzige ist, dass wir das Schlüsselwort „Beispiele“ nicht vor die Tabelle setzen.

Die Java-Implementierung sieht etwas komplexer aus als in den vorherigen Fällen:

 @Given("Ich bestätige, dass die Spalte den erwarteten Wert enthält")
public void iVerifyColumnValuesInTableUsingQueryFromFileOnSchema(DataTable dataTable) {
   List<Map<String, String>> data = dataTable.asMaps();
   for (Map<String, String> form : data) {
       String Spaltenname = form.get("SpaltenName");
       Zeichenfolge erwartetesErgebnis = form.get("erwarteterWert");
       // etwas Implementierung
       }
   }
}

Codeblock 6. Java-Implementierung der Datentabelle

Um auf Daten aus einer Datentabelle zuzugreifen, erstellen wir eine spezielle Variable dataTable vom Typ „DataTable“. Alle Daten werden in der Listenvariable gespeichert.

Szenariokontext

Mit dem Szenariokontext können wir Daten zwischen den Schritten austauschen. Nehmen wir an, wir haben ein Szenario mit zwei Schritten, in dem wir den Wert „Daten“ von Schritt 1 an Schritt 2 übergeben möchten (Codeblock 7).

 @Prüfen
Szenario: Szenariokontext
 Angenommen, ich habe den Szenariokontextwert "data" festgelegt
 Da ich den Kontextwert des Szenarios verwende

Codeblock 7. Szenariokontext

Zuerst müssen wir eine spezielle Klasse namens ScenarioContext mit Szenariokontextfunktionen zum Setzen und Abrufen von Daten erstellen (Codeblock 8). Unser Szenariokontext ist eine HashMap mit einem Schlüssel-Wert-Paar. Wir werden Werte anhand ihres Schlüssels identifizieren.

• ScenarioContext() : HashMap des Schlüssel-Wert-Paares
• setContext() : Schlüsselwertmethode zum Speichern von Szenariokontextdaten
• getContext() : Methode zum Abrufen von Daten, die den Schlüssel bereitstellen

 öffentliche Klasse Szenariokontext {

   private Map<String, Object> SzenarioKontext;

   öffentliches SzenarioContext(){
       SzenarioKontext = neue HashMap<>();
   }

   public void setContext(Kontextschlüssel, Objektwert) {
       SzenarioContext.put(key.toString(), Wert);
   }

   öffentliches Objekt getContext(Kontextschlüssel){
       SzenarioContext.get(key.toString()) zurückgeben;
   }

}

öffentlicher Aufzählungskontext {
   ICH WÜRDE;
}

Codeblock 8. Java-Implementierung der Szenariokontextklasse

Damit können wir implementierte Methoden nutzen. In Schritt 1 setzen wir dann den Wert im Szenariokontext und in Schritt 2 erhalten wir den Wert (Code Block 9).

 ScenarioContext scriptContext = new ScenarioContext();

@Given("Ich habe den Kontextwert {string} des Szenarios festgelegt")
public void iSetScenarioContextValue(String-Wert) {
   SzenarioContext.setContext (Kontext.ID, Wert);
}

@Given("Ich verwende den Kontextwert des Szenarios")
public void iUseScenarioContextValue() {
   Zeichenfolge SharedValue = ScenarioContext.getContext(Context.ID).toString();
}

Codeblock 9. Szenariokontextschritte

Gurken-Datentypen

Cucumber verarbeitet eine begrenzte Anzahl von Datentypen. Wir können Zeichenfolgen, Ganzzahlen und Float-Werte definieren, aber im Fall von booleschen Werten müssen wir einige Problemumgehungen codieren.

 @Prüfen
Szenario: Szenario mit Variablen
 Da ich String "string", int 1, float 1.1 und boolean "false" verwende

Codeblock 10. Gurkendatentypen

Der Java-Code würde in etwa so aussehen:

 @Given("Ich benutze string {string}, int {int}, float {float} und boolean {string}")
public void iUseStringIntFloatAndBoolean(String var1, int var2, double var3, String var4) {
   boolean f = Boolean.valueOf(var4);
   // irgendein Code
}

Codeblock 11. Java-Implementierung von Cucumber-Datentypen

Gurke Regulärer Ausdruck

Dies ist eine weitere häufig verwendete Funktion. Codeblock 12 zeigt ein Szenario mit zwei Schritten, die sich nur durch die Verwendung unterschiedlicher Variablenwerte (var1 und var2) unterscheiden. Dies ist tatsächlich nur ein Schritt, und im Java-Code (Code-Block 13) definieren wir nur eine Methode, aber mit Regex und einem Parameter var.

 @Prüfen
Szenario: Szenario mit regulären Ausdrücken
 Da ich die Variable var1 verwende
 Da ich die Variable var2 verwende

Codeblock 12. Regulärer Ausdruck in Gurke

 @Given("^Ich verwende Variable (.*)")
public void examTimeTableInSummerSeason(String var) {
   if (var.equals("var1")){
       // irgendein Code
   }
   sonst if(var.equals("var2")){
       // irgendein Code
   }
}

Codeblock 13. Java-Implementierung des regulären Cucumber-Ausdrucks

Gurkenhaken

Last but not least: Gurkenhaken.

Codeblock 14 stellt die 4 wichtigsten Hooks vor:

• @Before : Führt Code vor jedem Testszenario aus
• @After : Führt Code nach jedem Testszenario aus
• @BeforeStep : Führt Code vor jedem Testschritt aus
• @AfterStep : Führt Code nach jedem Testschritt aus

 @Vor
public void beforeScenario() {
   // irgendein Code
}

@Nach
public void afterScenario() {
   // irgendein Code
}

@BeforeStep
public void beforeStep() {
   // irgendein Code
}

@AfterStep
public void afterStep() {
   // irgendein Code
}

Codeblock 14. Gurkenhaken

Zusammenfassung

Ich hoffe, ich habe Sie davon überzeugt, Gherkin in Ihren Tests zu verwenden. Diese wenigen Funktionen machen Ihre Tests für Laien lesbarer und leichter verständlich. Auch für neue Mitarbeiter wird es einfacher sein, die Geschäftslogik zu verstehen und ihre Onboarding-Zeit zu verkürzen.