Cucumber

Wat is Cucumber?

Cucumber is een open-source tool die wordt gebruikt voor software testing, specifiek gericht op Behavior-Driven Development (BDD). Met Cucumber kunnen testers, ontwikkelaars en niet-technische stakeholders samenwerken door tests te schrijven in begrijpelijke, natuurlijke taal. Hierdoor wordt het makkelijker om de verwachtingen van softwaregedrag vast te leggen en te automatiseren.

Cucumber helpt teams om tests te definiëren in een vorm die begrijpelijk is voor zowel technische als niet-technische teamleden. In plaats van complexe code schrijft men scenario's in gewone taal. Deze scenario's beschrijven hoe een applicatie zich hoort te gedragen in specifieke situaties.

Het belangrijkste doel van Cucumber is om communicatie te verbeteren tussen business, testers en ontwikkelaars. Iedereen kan de testscenario’s lezen en controleren of de software voldoet aan de afgesproken eisen. Cucumber wordt vaak gebruikt in Agile-ontwikkelomgevingen waarin snelle feedback en samenwerking centraal staan.

Dankzij de structuur in natuurlijke taal is Cucumber zeer geschikt voor acceptatietests, regressietests en automatische end-to-end tests. Het ondersteunt meerdere programmeertalen, zoals Java, Ruby, JavaScript en Python, waardoor het breed inzetbaar is.

De Gherkin taal

De kracht van Cucumber ligt in de combinatie met Gherkin. Gherkin is de taal waarin de testscenario’s worden geschreven. Het is een domeinspecifieke taal die sterk lijkt op Engels (of andere ondersteunde talen) en die bedoeld is om scenario’s gestructureerd en begrijpelijk vast te leggen.

Met Gherkin kan iedereen binnen het projectteam meedenken over de gewenste functionaliteit en testcriteria. Omdat de syntax eenvoudig is, kunnen zelfs mensen zonder programmeerkennis testscenario’s schrijven of beoordelen. Hierdoor ontstaat minder miscommunicatie over de gewenste werking van de software.

Syntax van Gherkin

De basis van Gherkin bestaat uit eenvoudige sleutelwoorden die het gedrag beschrijven.

De belangrijkste zijn:

• Feature: Beschrijft de functionaliteit die getest wordt.

• Scenario: Een concreet voorbeeld van gedrag dat getest wordt.

• Given: De beginsituatie.

• When: De actie die wordt uitgevoerd.

• Then: Het verwachte resultaat.

• And / But: Extra stappen binnen een scenario.

Voorbeeld:

Feature: Inloggen op de website

  Scenario: Succesvol inloggen met geldige gegevens
    Given de gebruiker bevindt zich op de inlogpagina
    When de gebruiker vult een geldig e-mailadres en wachtwoord in
    And klikt op de inlogknop
    Then wordt de gebruiker doorgestuurd naar het dashboard

Deze scenario’s worden vervolgens gekoppeld aan onderliggende code die de beschreven stappen uitvoert.

Hoe werkt Cucumber?

Cucumber werkt door geschreven scenario's in natuurlijke taal automatisch te koppelen aan testcode. Dit maakt het mogelijk om beschrijvingen van gewenst gedrag direct te gebruiken als geautomatiseerde tests.

Het proces bestaat grofweg uit vier onderdelen:

1. Feature file schrijven

Alles begint met het schrijven van de feature file. Hierin staan de scenario's beschreven in Gherkin. Elke feature file bevat één of meerdere scenario’s die de gewenste werking van een functie uitleggen. Doordat dit in natuurlijke taal gebeurt, kunnen alle betrokkenen de inhoud lezen en begrijpen.

2. Step definitions maken

De stappen uit de feature file worden vervolgens gekoppeld aan code via zogenaamde step definitions. Hier wordt bepaald welke code moet worden uitgevoerd wanneer Cucumber bijvoorbeeld een Given, When of Then tegenkomt.

Bijvoorbeeld:

@Given("de gebruiker bevindt zich op de inlogpagina")
public void gebruiker_op_inlogpagina() {
    // Code om naar de inlogpagina te navigeren
}

3. Test runner gebruiken

Met een test runner wordt de test gestart. Dit kan vaak via command line of via een test framework, zoals JUnit (bij gebruik van Java). De test runner leest de feature files, koppelt de scenario’s aan de juiste step definitions en voert de stappen uit.

4. Rapportage en feedback

Na uitvoering geeft Cucumber duidelijke rapportages over welke scenario's zijn geslaagd en waar eventuele fouten zitten. Omdat de scenario's in natuurlijke taal zijn geschreven, is de output ook voor niet-technische teamleden makkelijk te begrijpen.

Cucumber framework en BDD

Cucumber is nauw verbonden met het principe van Behavior-Driven Development (BDD). Deze aanpak helpt teams om software te ontwikkelen waarbij het gewenste gedrag centraal staat, nog vóórdat de feitelijke code geschreven wordt.

Wat is BDD (Behavior-Driven Development)?

Behavior-Driven Development is een softwareontwikkelmethode waarbij de focus ligt op het beschrijven van het gewenste gedrag van een systeem in begrijpelijke taal. Door al vroeg in het proces te definiëren wat de software moet doen, worden misverstanden tussen business en development verkleind.

In BDD werken verschillende rollen samen:

• Business stakeholders beschrijven de gewenste functionaliteit.

• Ontwikkelaars vertalen dit naar step definitions en implementeren de functionaliteit.

• Testers automatiseren de scenario's met behulp van tools als Cucumber.

BDD legt de nadruk op samenwerking, communicatie en continue feedback. Hierdoor ontstaat een gedeeld begrip van de gewenste software.

Hoe BDD samenwerkt met Cucumber

Cucumber ondersteunt het BDD-proces door een brug te slaan tussen tekst en code.

• De business schrijft feature files in Gherkin.

• Ontwikkelaars maken step definitions om de logica aan de beschreven stappen te koppelen.

• Testers kunnen de tests automatisch draaien en feedback geven.

Hierdoor ontstaat een workflow waarin iedereen begrijpt wat er wordt gebouwd en hoe het getest wordt.

Voordelen van BDD in Cucumber

Het gebruik van Cucumber binnen een BDD-aanpak biedt meerdere voordelen:

• Betere communicatie: Iedereen spreekt dezelfde taal.

• Minder fouten: Verwachtingen zijn vooraf duidelijk.

• Snelle feedback: Problemen worden vroeg ontdekt.

• Herbruikbare tests: Scenario’s blijven bruikbaar tijdens onderhoud of uitbreidingen.

• Documentatie: De feature files dienen als actuele documentatie van het systeem.

Voorbeeld van een Cucumber test

Om beter te begrijpen hoe Cucumber in de praktijk werkt, volgt hier een volledig voorbeeld van een eenvoudige test. We nemen een scenario waarbij een gebruiker succesvol wil inloggen op een website.

1. Feature file schrijven

Eerst wordt de feature file aangemaakt. Hierin wordt het gewenste gedrag beschreven in Gherkin:

Feature: Inloggen op de website

  Scenario: Succesvol inloggen met correcte gegevens
    Given de gebruiker bevindt zich op de inlogpagina
    When de gebruiker voert een geldig e-mailadres en wachtwoord in
    And klikt op de inlogknop
    Then wordt de gebruiker doorgestuurd naar het dashboard

Deze feature file beschrijft exact wat er getest moet worden, zonder technische details.

2. Step definitions schrijven

Vervolgens worden de stappen gekoppeld aan code. Hier een voorbeeld in Java:

@Given("de gebruiker bevindt zich op de inlogpagina")
public void gebruiker_op_inlogpagina() {
    driver.get("https://www.voorbeeldsite.nl/login");
}

@When("de gebruiker voert een geldig e-mailadres en wachtwoord in")
public void invoer_geldige_gebruikersgegevens() {
    driver.findElement(By.id("email")).sendKeys("gebruiker@voorbeeld.nl");
    driver.findElement(By.id("password")).sendKeys("veiligwachtwoord");
}

@When("klikt op de inlogknop")
public void klik_op_inlogknop() {
    driver.findElement(By.id("loginButton")).click();
}

@Then("wordt de gebruiker doorgestuurd naar het dashboard")
public void controleer_dashboard() {
    String url = driver.getCurrentUrl();
    assertEquals("https://www.voorbeeldsite.nl/dashboard", url);
}

In deze code wordt een webbrowser bestuurd (bijvoorbeeld via Selenium) om de beschreven handelingen uit te voeren.

3. Test runner configureren

Tot slot wordt de test uitgevoerd via een test runner, bijvoorbeeld:

@RunWith(Cucumber.class)
@CucumberOptions(features = "src/test/resources/features")
public class TestRunner {
}

De test runner zoekt automatisch de feature files en koppelt de beschreven stappen aan de juiste step definitions.

Integratie met Selenium en andere tools

Hoewel Cucumber zelf verantwoordelijk is voor het interpreteren van de scenario’s, heeft het externe tools nodig om de stappen daadwerkelijk uit te voeren. De meest gebruikte combinatie is Cucumber met Selenium.

Cucumber met Selenium

Selenium is een populaire tool om browsers automatisch te bedienen. In combinatie met Cucumber worden de Gherkin-scenario’s gekoppeld aan Selenium-code. Hierdoor kunnen complete end-to-end tests uitgevoerd worden in een echte browseromgeving.

Een typische samenwerking:

• Cucumber leest de feature file.

• Step definitions bevatten Selenium-code.

• Selenium voert de acties uit, zoals klikken, typen of navigeren.

Zo wordt het gedrag dat beschreven is in begrijpelijke taal volledig automatisch getest in een browser.

Andere integratiemogelijkheden

Naast Selenium kan Cucumber samenwerken met:

• Appium (voor mobiele applicaties)

• REST-assured (voor API-tests)

• JUnit/TestNG (voor testmanagement in Java)

• CI/CD pipelines (voor automatische testuitvoering bij elke codewijziging)

Deze flexibiliteit maakt Cucumber geschikt voor zowel webapplicaties, mobiele apps als API’s.

Voordelen en beperkingen van Cucumber

Zoals iedere tool heeft ook Cucumber sterke kanten en aandachtspunten.

Voordelen

• Begrijpelijke tests: Scenario’s zijn leesbaar voor iedereen.

• Betere samenwerking: Business en IT spreken dezelfde taal.

• Herbruikbare teststappen: Step definitions kunnen vaak hergebruikt worden.

• Goede documentatie: Feature files zijn een vorm van levende documentatie.

• Flexibele integraties: Combineerbaar met veel andere tools.

Beperkingen

• Meer onderhoud: Feature files en step definitions moeten goed worden bijgehouden.

• Complexiteit bij grote projecten: Veel scenario’s kunnen leiden tot lange testuitvoeringen.

• Technische kennis alsnog nodig: Hoewel de scenario’s begrijpelijk zijn, vereist het opzetten van step definitions programmeerkennis.

• Niet altijd geschikt voor elk testtype: Voor puur technische tests kan een ander framework soms efficiënter zijn.

Tot slot nog enkele overwegingen over het gebruik van Cucumber voor geautomatiseerd testen

Cucumber is een krachtige testtool die softwareteams helpt om helder en gestructureerd samen te werken aan softwarekwaliteit. Door gebruik te maken van begrijpelijke scenario's in de Gherkin-taal kunnen alle betrokkenen, van business tot development, actief bijdragen aan het testproces. Vooral in combinatie met Behavior-Driven Development zorgt Cucumber voor betere communicatie, minder misverstanden en een hogere softwarekwaliteit. Door de vele integratiemogelijkheden is Cucumber inzetbaar in uiteenlopende testomgevingen, mits de bijbehorende complexiteit goed wordt beheerd.