Testen beheersen: JUnit, Mockito en integratietesten · Les

Step definitions implementeren

Verbind Gherkin-featurebestanden met uitvoerbare code door step definitions te schrijven met een BDD-framework.

Les 3 van 411 stappen

Step definitions implementeren is een gratis Testen beheersen: JUnit, Mockito en integratietesten-les op CoddyKit. Dit is les 3 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Testen beheersen: JUnit, Mockito en integratietesten. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Testen beheersen: JUnit, Mockito en integratietesten bevat in totaal 4 lessen.

Stapdefinities: de codebrug

Bij Behavior-Driven Development (BDD) beschrijven Gherkin-functiebestanden gedrag in gewone taal. Maar hoe begrijpt je toepassing deze instructies?

Daar komen Step Definitions om de hoek kijken! Ze vormen de cruciale verbinding en vertalen elke Gherkin-stap (Given, When, Then) naar uitvoerbare code.

Het zijn methoden die overeenkomen met Gherkin-patronen.
BDD-frameworks (zoals Cucumber) zoeken deze methoden en voeren ze uit.

Ons voorbeeld: een eenvoudige rekenmachine

Laten we een eenvoudige Calculator gebruiken om te demonstreren hoe stapdefinities werken. Deze klasse bevat de status en logica waarmee onze stappen werken.

Probeer deze eenvoudige rekenmachine uit te voeren:

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

De annotatie @Given

De annotatie @Given wordt gebruikt voor methoden die de eerste context of vereisten vooraf voor een scenario instellen. Hiermee wordt de 'wereld' voorbereid voordat er een actie plaatsvindt.

We maken een klasse StepDefinitions om onze stapmethoden in onder te brengen. Let erop hoe de tekenreeks in @Given overeenkomt met een Gherkin-stap.

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

De annotatie @When

De annotatie @When markeert methoden die een actie of gebeurtenis beschrijven. Hier vindt doorgaans de interactie met het systeem dat wordt getest plaats, of wordt dit systeem geactiveerd.

Onze rekenmachine voert hier een bewerking voor optellen uit.

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

De annotatie @Then

De annotatie @Then is bedoeld voor methoden die de uitkomst van de actie observeren. Hier beweer je dat het systeem zich zoals verwacht heeft gedragen.

We controleren of het resultaat van de rekenmachine correct is.

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

Gegevens doorgeven met argumenten

Waarden hardcoderen is niet flexibel. Met BDD-frameworks kun je gegevens uit de Gherkin-stap vastleggen en als argumenten doorgeven aan je methode voor de stapdefinitie.

We gebruiken reguliere expressies of Cucumber Expressions (zoals {int}) om plaatshouders te definiëren.

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

Flexibele stapherkenning met regex

Hoewel {int} en {string} handig zijn, kun je volledige reguliere expressies gebruiken voor complexere herkenningspatronen.

Als je Gherkin-stap bijvoorbeeld Given I have an (empty|full) wallet was, kan het patroon van je stapdefinitie "^I have an (empty|full) wallet$" zijn om 'empty' of 'full' vast te leggen.

Gebruik \\d+ voor een of meer cijfers.
Gebruik "(.*)" om willekeurige tekst vast te leggen.

Zo kan één stapdefinitie overeenkomen met verschillende, licht afwijkende Gherkin-zinnen.

BDD-hooks: instellen en opruimen

Soms moet je acties uitvoeren vóór of na elk scenario, of zelfs vóór of na alle functies. BDD-frameworks bieden hiervoor Hooks.

@Before: wordt vóór elk scenario uitgevoerd. Handig om de status opnieuw in te stellen.
@After: wordt na elk scenario uitgevoerd. Goed voor het opruimen.

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

Je functiebestanden uitvoeren

In een echt BDD-project zou je niet handmatig methoden voor stapdefinities aanroepen zoals we in main hebben gedaan.

In plaats daarvan gebruik je een testrunner (vaak een JUnit-testklasse) die het BDD-framework (bijvoorbeeld Cucumber) vertelt waar het je functiebestanden en stapdefinities kan vinden.

De testrunner verwerkt vervolgens de Gherkin, zoekt overeenkomende stapdefinities en voert ze in de juiste volgorde uit, waarbij de resultaten worden gerapporteerd.

Snelle controle: rollen van stapdefinities

Koppel de BDD-annotatie aan de belangrijkste rol ervan in een stapdefinitie.

Beantwoord dit in de interactieve les

Samenvatting: stapdefinities implementeren

Je hebt geleerd hoe je voor mensen leesbare Gherkin-stappen koppelt aan uitvoerbare code!

Step Definitions zijn Java-methoden met de annotatie @Given, @When of @Then.
Ze gebruiken reguliere expressies of Cucumber Expressions (zoals {int}) om Gherkin-tekst te herkennen.
Argumenten kunnen uit de Gherkin-stap worden vastgelegd en aan de methode worden doorgegeven.
Hooks zoals @Before en @After helpen bij het beheren van het instellen en opruimen van scenario's.

Deze verbinding tussen taal en code is fundamenteel voor BDD en zorgt ervoor dat tests begrijpelijk zijn voor iedereen die bij het project betrokken is!

Gratis beginnen

Leer Testen beheersen: JUnit, Mockito en integratietesten met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Step definitions implementeren” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Testen beheersen: JUnit, Mockito en integratietesten, waaronder “Step definitions implementeren”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Testen beheersen: JUnit, Mockito en integratietesten bevat in totaal 4 lessen.

Wat leer ik in “Step definitions implementeren”?

Verbind Gherkin-featurebestanden met uitvoerbare code door step definitions te schrijven met een BDD-framework. Je oefent met Testen beheersen: JUnit, Mockito en integratietesten door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Testen beheersen: JUnit, Mockito en integratietesten te beginnen?

Ervaring vooraf is niet nodig. Testen beheersen: JUnit, Mockito en integratietesten op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Step definitions implementeren”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Testen beheersen: JUnit, Mockito en integratietesten?

Ja. Elke les over Testen beheersen: JUnit, Mockito en integratietesten bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Testen beheersen: JUnit, Mockito en integratietesten