What is Cucumber Testing? A Guide To Testing With Cucumber Tool

Traditional testing approaches often fail to connect these perspectives. Typically, stakeholders relay their requirements to the Product Owner, who then communicates them to developers and testers. Developers translate these requirements into code, while testers convert them into test cases. This sequential process is time-consuming and can lead to miscommunication and misunderstandings.

In contrast, BDD encourages the "tres amigos" to collaborate directly, discussing the requirements together and documenting their insights using a shared language. This collaborative approach ensures a common understanding of the problem and allows testers to create test cases using a BDD framework, reducing the risk of misunderstandings and improving the overall development process.

Read More: What is BDD Testing?

How Does Cucumber Work?

Cucumber operates through a process that bridges the gap between human-readable specifications and automated testing code.

Step 1: Gherkin Language Parsing

Cucumber begins by reading feature files written in Gherkin, a language that uses plain English-like syntax to describe software behavior. Each feature file contains one or more scenarios that describe different use cases or functionalities of the application.

The Gherkin syntax is parsed into a structured format that Cucumber can understand, breaking down the scenarios into individual steps such as Given, When, and Then

Step 2: Step Definition Mapping

Each step in the Gherkin file is mapped to a corresponding piece of code, known as a step definition. These are written in a programming language (e.g., Java, Ruby, Python) and include logic that interacts with the application under test. Cucumber uses annotations (such as @Given, @When, @Then in Java) to bind Gherkin steps to specific methods in the code. When Cucumber parses a step like “Given the user is on the login page,” it looks for a method annotated with @Given that matches the text.

Here’s an example of how Gherkin steps are mapped to step definitions in Cucumber. Let's say we have this feature file:

Feature: User Login

  Scenario: Successful login with valid credentials
    Given the user is on the login page
    When the user enters a valid username and password
    Then the user should be redirected to their dashboard

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

public class LoginSteps {

    @Given("the user is on the login page")
    public void the_user_is_on_the_login_page() {
        // Code to navigate to the login page
        System.out.println("User navigates to the login page.");
    }

    @When("the user enters a valid username and password")
    public void the_user_enters_a_valid_username_and_password() {
        // Code to enter username and password
        System.out.println("User enters valid credentials.");
    }

    @Then("the user should be redirected to their dashboard")
    public void the_user_should_be_redirected_to_their_dashboard() {
        // Code to verify redirection to the dashboard
        System.out.println("User is redirected to the dashboard.");
    }
}

Step 3: Test Execution

To run Cucumber tests, you need a test runner. You can create a class that will be the entry point for running your Cucumber tests. The test runner class here uses JUnit's @RunWith annotation to specify that JUnit should run the tests, and the @CucumberOptions annotation to configure the execution.

import org.junit.runner.RunWith;
import io.cucumber.junit.Cucumber;
import io.cucumber.junit.CucumberOptions;

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

When executing, you can run the test runner class directly from your IDE, or use Maven or Gradle to run the tests (mvn test for Maven or gradle test for Gradle).

Examples of Cucumber Tests

Let's say you are testing a banking application which allows users to log in to their accounts using a username and password. The goal is to ensure that only registered users with the correct credentials can log in, and users with incorrect credentials are denied access.

We'll start by writing a feature file that describes the behavior of the login functionality in plain language.

Feature: User Login

  As a registered user of the banking application,
  I want to log in to my account
  So that I can access my personal banking dashboard

  Scenario: Successful login with valid credentials
    Given the user is on the login page
    When the user enters a valid username and password
    And clicks the login button
    Then the user should be redirected to their banking dashboard

  Scenario: Unsuccessful login with invalid credentials
    Given the user is on the login page
    When the user enters an invalid username or password
    And clicks the login button
    Then the user should see an error message indicating invalid login credentials

  Scenario: Unsuccessful login with empty credentials
    Given the user is on the login page
    When the user leaves the username or password field empty
    And clicks the login button
    Then the user should see an error message indicating that both fields are required

The next step is to write the step definitions that will map the Gherkin steps to the actual code that interacts with the application. Below is an example of how you might write these in Java.

import io.cucumber.java.en.Given;
import io.cucumber.java.en.When;
import io.cucumber.java.en.Then;
import static org.junit.Assert.*;

public class LoginSteps {

    private LoginPage loginPage;
    private DashboardPage dashboardPage;
    private String errorMessage;

    @Given("the user is on the login page")
    public void the_user_is_on_the_login_page() {
        loginPage = new LoginPage();
        loginPage.navigateToLoginPage();
    }

    @When("the user enters a valid username and password")
    public void the_user_enters_a_valid_username_and_password() {
        loginPage.enterUsername("validUser");
        loginPage.enterPassword("validPassword");
    }

    @When("the user enters an invalid username or password")
    public void the_user_enters_an_invalid_username_or_password() {
        loginPage.enterUsername("invalidUser");
        loginPage.enterPassword("invalidPassword");
    }

    @When("the user leaves the username or password field empty")
    public void the_user_leaves_the_username_or_password_field_empty() {
        loginPage.enterUsername("");
        loginPage.enterPassword("");
    }

    @When("clicks the login button")
    public void clicks_the_login_button() {
        loginPage.clickLoginButton();
    }

    @Then("the user should be redirected to their banking dashboard")
    public void the_user_should_be_redirected_to_their_banking_dashboard() {
        dashboardPage = new DashboardPage();
        assertTrue(dashboardPage.isDashboardDisplayed());
    }

    @Then("the user should see an error message indicating invalid login credentials")
    public void the_user_should_see_an_error_message_indicating_invalid_login_credentials() {
        errorMessage = loginPage.getErrorMessage();
        assertEquals("Invalid username or password.", errorMessage);
    }

    @Then("the user should see an error message indicating that both fields are required")
    public void the_user_should_see_an_error_message_indicating_that_both_fields_are_required() {
        errorMessage = loginPage.getErrorMessage();
        assertEquals("Username and password are required.", errorMessage);
    }
}

Once the feature file and step definitions are set up, you can run the Cucumber tests. In most setups, this is done using a test runner (e.g., JUnit in Java).

import org.junit.runner.RunWith;
import io.cucumber.junit.Cucumber;
import io.cucumber.junit.CucumberOptions;

@RunWith(Cucumber.class)
@CucumberOptions(
    features = "src/test/resources/features",
    glue = "com.example.steps",
    plugin = {"pretty", "html:target/cucumber-reports"},
    monochrome = true
)
public class RunCucumberTest {
}

Katalon is a comprehensive automation testing tool that enables QA teams to:

👉 Create codeless tests
👉 Manage them in a centralized repository
👉 Execute tests across multiple browsers in the cloud
👉 Produce detailed reports for data-driven decision-making

Katalon also supports BDD testing with Cucumber, allowing you to import BDD feature files, create scripts with low-code features, link BDD steps to test scripts, and generate BDD-style reports.

To create a Cucumber feature file in Katalon Studio, go to File > New > BDD Feature File after installation.
 

Next, you can use Katalon's fast test authoring features to convert the BDD feature file into a complete test script in seconds. Two key methods are:

• Built-in Keywords: Drag and drop pre-written code snippets to build the test case.
• Record-and-Playback: Record actions on your screen, capture object xPaths, and generate Selenium scripts for re-execution.

Katalon allows viewing and editing the full script, enabling you to finalize the step definitions. Once complete, click Run to execute the test and view the BDD test results in Katalon TestOps.

With Katalon, Cucumber’s capabilities are enhanced by:

• Low-code, fast test authoring
• Customizable coding options
• Cross-browser testing for broader coverage
• Easier script maintenance through centralized management
• Detailed BDD-style test results