Testning på avancerad nivå: JUnit, Mockito och integrationstester · Lektion

Implementera stegdefinitioner

Koppla Gherkin-featurefiler till körbar kod genom att skriva stegdefinitioner med ett BDD-ramverk.

Lektion 3 av 411 steg

Implementera stegdefinitioner är en gratis lektion i Testning på avancerad nivå: JUnit, Mockito och integrationstester på CoddyKit. Detta är lektion 3 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Testning på avancerad nivå: JUnit, Mockito och integrationstester, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Testning på avancerad nivå: JUnit, Mockito och integrationstester innehåller totalt 4 lektioner.

Stegdefinitioner: kodbryggan

Inom Behavior-Driven Development (BDD) beskriver Gherkin-featurefiler beteende på klarspråk. Men hur förstår applikationen dessa instruktioner?

Det är här Step Definitions kommer in! De är den viktiga länken som översätter varje Gherkin-steg (Given, When, Then) till körbar kod.

De är metoder som matchar Gherkin-mönster.
BDD-ramverk (som Cucumber) hittar och kör dessa metoder.

Vårt exempel: en enkel kalkylator

Vi använder en enkel Calculator för att visa hur stegdefinitioner fungerar. Den här klassen innehåller det tillstånd och den logik som våra steg interagerar med.

Prova att köra den här enkla kalkylatorn:

public class Calculator {
  private int result;

  public void add(int a, int b) {
    this.result = a + b;
  }

  public int getResult() {
    return result;
  }

  public void clear() {
    this.result = 0;
  }

  public static void main(String[] args) {
    Calculator calc = new Calculator();
    calc.add(10, 5);
    System.out.println("10 + 5 = " + calc.getResult());
  }
}

Annoteringen @Given

Annoteringen @Given används för metoder som etablerar det ursprungliga sammanhanget eller förvillkoren för ett scenario. Den förbereder ”världen” innan en åtgärd äger rum.

Vi skapar en StepDefinitions-klass som innehåller våra stegmetoder. Lägg märke till hur strängen i @Given matchar ett Gherkin-steg.

import io.cucumber.java.en.Given;

public class StepDefinitions {
  private Calculator calculator;

  @Given("I have a calculator")
  public void iHaveACalculator() {
    calculator = new Calculator();
    System.out.println("Given: Calculator initialized.");
  }

  public static void main(String[] args) {
    StepDefinitions steps = new StepDefinitions();
    steps.iHaveACalculator();
  }
}

Annoteringen @When

Annoteringen @When markerar metoder som beskriver en åtgärd eller händelse. Det är vanligtvis här som systemet som testas interageras med eller utlöses.

Vår kalkylator utför en ”add”-operation här.

import io.cucumber.java.en.Given;
import io.cucumber.java.en.When;

public class StepDefinitions {
  private Calculator calculator;

  @Given("I have a calculator")
  public void iHaveACalculator() {
    calculator = new Calculator();
    System.out.println("Given: Calculator initialized.");
  }

  @When("I add two numbers")
  public void iAddTwoNumbers() {
    // For now, let's hardcode values. We'll make it dynamic soon!
    calculator.add(10, 20);
    System.out.println("When: Added two numbers (10, 20).");
  }

  public static void main(String[] args) {
    StepDefinitions steps = new StepDefinitions();
    steps.iHaveACalculator();
    steps.iAddTwoNumbers();
  }
}

Annoteringen @Then

Annoteringen @Then används för metoder som observerar resultatet av åtgärden. Det är här ni verifierar att systemet betedde sig som förväntat.

Vi kontrollerar om kalkylatorns resultat är korrekt.

import io.cucumber.java.en.Given;
import io.cucumber.java.en.When;
import io.cucumber.java.en.Then;

public class StepDefinitions {
  private Calculator calculator;

  @Given("I have a calculator")
  public void iHaveACalculator() {
    calculator = new Calculator();
    System.out.println("Given: Calculator initialized.");
  }

  @When("I add two numbers")
  public void iAddTwoNumbers() {
    calculator.add(10, 20);
    System.out.println("When: Added two numbers (10, 20).");
  }

  @Then("the result should be 30")
  public void theResultShouldBe30() {
    if (calculator.getResult() == 30) {
      System.out.println("Then: Result is 30. Test PASSED!");
    } else {
      System.out.println("Then: Expected 30, got " + calculator.getResult() + ". Test FAILED!");
    }
  }

  public static void main(String[] args) {
    StepDefinitions steps = new StepDefinitions();
    steps.iHaveACalculator();
    steps.iAddTwoNumbers();
    steps.theResultShouldBe30();
  }
}

Skicka data med argument

Hårdkodade värden är inte flexibla. BDD-ramverk gör det möjligt att hämta data från Gherkin-steget och skicka den som argument till stegdefinitionens metod.

Vi använder reguljära uttryck eller Cucumber Expressions (som {int}) för att definiera platshållare.

import io.cucumber.java.en.Given;
import io.cucumber.java.en.When;
import io.cucumber.java.en.Then;

public class StepDefinitions {
  private Calculator calculator;

  @Given("I have a calculator")
  public void iHaveACalculator() {
    calculator = new Calculator();
    System.out.println("Given: Calculator initialized.");
  }

  @When("I add {int} and {int}")
  public void iAddTwoNumbers(int num1, int num2) {
    calculator.add(num1, num2);
    System.out.println("When: Added " + num1 + " and " + num2 + ".");
  }

  @Then("the result should be {int}")
  public void theResultShouldBe(int expectedResult) {
    if (calculator.getResult() == expectedResult) {
      System.out.println("Then: Result is " + expectedResult + ". Test PASSED!");
    } else {
      System.out.println("Then: Expected " + expectedResult + ", got " + calculator.getResult() + ". Test FAILED!");
    }
  }

  public static void main(String[] args) {
    StepDefinitions steps = new StepDefinitions();
    steps.iHaveACalculator();
    steps.iAddTwoNumbers(5, 7); // Simulating Gherkin "When I add 5 and 7"
    steps.theResultShouldBe(12); // Simulating Gherkin "Then the result should be 12"
  }
}

Flexibel stegsökning med Regex

Även om {int} och {string} är praktiska kan ni använda fullständiga reguljära uttryck för mer komplex matchning.

Om ert Gherkin-steg till exempel var Given I have an (empty|full) wallet kan mönstret för stegdefinitionen vara "^I have an (empty|full) wallet$" för att fånga ”empty” eller ”full”.

Använd \\d+ för en eller flera siffror.
Använd "(.*)" för att fånga valfri text.

Detta gör att en enda stegdefinition kan matcha flera något olika Gherkin-formuleringar.

BDD-hooks: förberedelse och avslut

Ibland behöver ni utföra åtgärder före eller efter varje scenario, eller till och med före eller efter alla funktioner. BDD-ramverk tillhandahåller Hooks för detta.

@Before: Körs före varje scenario. Användbart för att återställa tillståndet.
@After: Körs efter varje scenario. Lämpligt för städning.

import io.cucumber.java.en.Given;
import io.cucumber.java.en.When;
import io.cucumber.java.en.Then;
import io.cucumber.java.Before;
import io.cucumber.java.After;

public class StepDefinitions {
  private Calculator calculator;

  @Before
  public void setupScenario() {
    System.out.println("\n--- Scenario Setup (@Before) ---");
    calculator = new Calculator(); // Ensure a fresh calculator for each scenario
  }

  @After
  public void teardownScenario() {
    System.out.println("--- Scenario Teardown (@After) ---");
    // Optional: add cleanup if needed, e.g., closing resources
  }

  @Given("I have a calculator")
  public void iHaveACalculator() {
    System.out.println("Given: Calculator initialized.");
  }

  @When("I add {int} and {int}")
  public void iAddTwoNumbers(int num1, int num2) {
    calculator.add(num1, num2);
    System.out.println("When: Added " + num1 + " and " + num2 + ".");
  }

  @Then("the result should be {int}")
  public void theResultShouldBe(int expectedResult) {
    if (calculator.getResult() == expectedResult) {
      System.out.println("Then: Result is " + expectedResult + ". Test PASSED!");
    } else {
      System.out.println("Then: Expected " + expectedResult + ", got " + calculator.getResult() + ". Test FAILED!");
    }
  }

  public static void main(String[] args) {
    StepDefinitions steps = new StepDefinitions();
    // Simulate a scenario run
    steps.setupScenario();
    steps.iHaveACalculator();
    steps.iAddTwoNumbers(8, 4); // Simulating Gherkin "When I add 8 and 4"
    steps.theResultShouldBe(12); // Simulating Gherkin "Then the result should be 12"
    steps.teardownScenario();

    // Simulate another scenario run
    steps.setupScenario();
    steps.iHaveACalculator();
    steps.iAddTwoNumbers(10, 0); // Simulating Gherkin "When I add 10 and 0"
    steps.theResultShouldBe(10); // Simulating Gherkin "Then the result should be 10"
    steps.teardownScenario();
  }
}

Kör era feature-filer

I ett verkligt BDD-projekt skulle ni inte anropa stegdefinitionernas metoder manuellt, som vi gjorde i main.

I stället skulle ni ha en Test Runner (ofta en JUnit-testklass) som talar om för BDD-ramverket (till exempel Cucumber) var det ska hitta era feature-filer och stegdefinitioner.

Köraren tolkar sedan Gherkin, hittar matchande stegdefinitioner och kör dem i rätt ordning samtidigt som resultaten rapporteras.

Snabb kontroll: stegdefinitionernas roller

Para ihop BDD-annoteringen med dess huvudsakliga roll i en stegdefinition.

Besvara frågan i den interaktiva lektionen

Repetition: implementera stegdefinitioner

Ni har lärt er att koppla ihop lättlästa Gherkin-steg med körbar kod!

Step Definitions är Java-metoder som annoteras med @Given, @When eller @Then.
De använder reguljära uttryck eller Cucumber Expressions (som {int}) för att matcha Gherkin-text.
Argument kan hämtas från Gherkin-steget och skickas till metoden.
Hooks som @Before och @After hjälper till att hantera förberedelser och avslut av scenarier.

Denna bro mellan språk och kod är grundläggande för BDD och säkerställer att testerna kan förstås av alla som deltar i projektet!

Gratis att börja

Lär dig Testning på avancerad nivå: JUnit, Mockito och integrationstester med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Implementera stegdefinitioner” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Testning på avancerad nivå: JUnit, Mockito och integrationstester, inklusive ”Implementera stegdefinitioner”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Testning på avancerad nivå: JUnit, Mockito och integrationstester innehåller totalt 4 lektioner.

Vad lär jag mig i ”Implementera stegdefinitioner”?

Koppla Gherkin-featurefiler till körbar kod genom att skriva stegdefinitioner med ett BDD-ramverk. Ni övar på Testning på avancerad nivå: JUnit, Mockito och integrationstester med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Testning på avancerad nivå: JUnit, Mockito och integrationstester?

Du behöver inga förkunskaper. Utbildningen i Testning på avancerad nivå: JUnit, Mockito och integrationstester på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Implementera stegdefinitioner”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Testning på avancerad nivå: JUnit, Mockito och integrationstester-lektionen?

Ja. Varje Testning på avancerad nivå: JUnit, Mockito och integrationstester-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Testning på avancerad nivå: JUnit, Mockito och integrationstester