Cucumber Best Practices

Cucumber is a valuable tool for Behavior-Driven Development (BDD) that enables teams to write tests in simple, plain language. Here are the best practices for using Cucumber in real-world projects, focusing on making the process clear, easy to maintain, and efficient.

Here are some best practices to follow:

1. Write Clear and Concise Gherkin Scenarios

Gherkin is the language used in Cucumber to describe scenarios. To make your scenarios effective:

• Follow the Given-When-Then structure: This structure ensures clarity and consistency in your scenarios.
• Keep scenarios short: Limit each scenario to under 10 steps to keep it focused and easy to understand.
• Avoid technical details: Focus on describing the behavior, not the specific implementation steps.
• Use clear, meaningful names: Step names should convey the action or expected outcome.
• Be consistent: Use consistent language and terms across all scenarios to avoid confusion.

Feature: User Login

  Scenario: Successful login with valid credentials
    Given the user is on the login page
    When the user enters "standard_user" and "secret_sauce"
    Then the user should be redirected to the homepage

This scenario is straightforward, to the point, and emphasizes the behavior without getting into technical specifics.

2. Organize Step Definitions Effectively

As your project expands, organizing step definitions becomes essential:

• Group related steps: Keep step definitions related to specific features or modules together for easier navigation.
• Avoid large step definition files: Break down large files into smaller, more manageable ones to improve readability and maintainability.
• Use helper methods: Extract repeated functionality into helper methods to reduce redundancy and keep the code clean.

package stepdefinitions;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

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

public class LoginSteps {

    private WebDriver driver;
    private String url = "https://www.saucedemo.com/";

    // Setup: Initialize WebDriver
    @Before
    public void setup() {
        System.setProperty("webdriver.chrome.driver", "path_to_chromedriver");
        driver = new ChromeDriver();
    }

    @Given("the user is on the login page")
    public void userOnLoginPage() {
        driver.get(url);
    }

    @When("the user enters {string} and {string}")
    public void userEntersCredentials(String username, String password) {
        WebElement userName = driver.findElement(By.id("user-name"));
        userName.sendKeys(username);

        WebElement passWord = driver.findElement(By.id("password"));
        passWord.sendKeys(password);

        WebElement loginBtn = driver.findElement(By.id("login-button"));
        loginBtn.click();
    }

    @Then("the user should be redirected to the homepage")
    public void userRedirectedToHomepage() {
        String currentUrl = driver.getCurrentUrl();
        assert currentUrl.equals("https://www.saucedemo.com/inventory.html");
    }

    // Teardown: Close browser
    @After
    public void tearDown() {
        if (driver != null) {
            driver.quit();
        }
    }
}

By organizing step definitions this way, each step becomes self-contained, making it easier to manage and maintain.

3. Reuse Step Definitions

Reusing step definitions helps with maintainability and reduces redundancy:

• Identify common steps: Some steps, like "the user is on the login page," are used in multiple scenarios. Spot these repetitive steps and reuse them.
• Avoid duplication: Rather than writing the same step in different scenarios, reuse existing step definitions to keep your tests clean and concise.
• Parameterize steps when needed: Use placeholders for variable parts of steps to make them more flexible and reusable.

@When("the user enters {string} and {string}")
public void userEntersCredentials(String username, String password) {
    WebElement userName = driver.findElement(By.id("user-name"));
    userName.sendKeys(username);

    WebElement passWord = driver.findElement(By.id("password"));
    passWord.sendKeys(password);

    WebElement loginBtn = driver.findElement(By.id("login-button"));
    loginBtn.click();
}

You can reuse this step for multiple scenarios by passing different values for username and password.

4. Utilize Backgrounds for Common Setup

The Background section allows you to define steps that are common across all scenarios in a feature file:

• Place common setup steps in the Background: This helps avoid repetition and ensures each scenario focuses only on its unique steps.
• Keep Backgrounds concise: Only include steps that are shared across all scenarios in the feature to maintain clarity.

Feature: User Login

  Background:
    Given the user is on the login page

  Scenario: Successful login with valid credentials
    When the user enters "standard_user" and "secret_sauce"
    Then the user should be redirected to the homepage

  Scenario: Unsuccessful login with invalid credentials
    When the user enters "wrong_user" and "wrong_pass"
    Then an error message should be displayed

The Background section allows you to write common setup steps once, improving readability and reducing code duplication..

5. Use Data Tables for Multiple Inputs

When a step requires handling multiple sets of data, Data Tables are very helpful:

• Define inputs in a tabular format: This approach makes it easier to read and understand multiple sets of data at once.
• Map each row to a test case: Each row in the table represents a different set of inputs and the expected outcome.

Feature: User Login

  Scenario Outline: Successful login with valid credentials
    Given the user is on the login page
    When the user enters "<username>" and "<password>"
    Then the user should be redirected to the homepage

  Examples:
    | username       | password       |
    | standard_user  | secret_sauce   |
    | locked_out_user| secret_sauce   |

In this example table provides different sets of credentials to test, helping ensure that the login functionality works with various input combinations.

6. Implement Page Object Model (POM)

Combining Cucumber with the Page Object Model (POM) improves test maintainability and organization:

• Separate UI interactions from test logic: POM helps isolate UI elements and interactions, making tests easier to read and understand.
• Promote reusability: Page objects can be reused across multiple tests, reducing code duplication and making the tests more efficient.
• Simplify maintenance: When the UI changes, you only need to update the page object, not every individual test.

package stepdefinitions;

import pageobjects.LoginPage;

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

public class LoginSteps {

    private WebDriver driver;
    private LoginPage loginPage;

    @Before
    public void setup() {
        System.setProperty("webdriver.chrome.driver", "path_to_chromedriver");
        driver = new ChromeDriver();
        loginPage = new LoginPage(driver);
    }

    @Given("the user is on the login page")
    public void userOnLoginPage() {
        driver.get("https://www.saucedemo.com/");
    }

    @When("the user enters {string} and {string}")
    public void userEntersCredentials(String username, String password) {
        loginPage.enterUsername(username);
        loginPage.enterPassword(password);
        loginPage.clickLogin();
    }

    @Then("the user should be redirected to the homepage")
    public void userRedirectedToHomepage() {
        assert driver.getCurrentUrl().equals("https://www.saucedemo.com/inventory.html");
    }

    @After
    public void tearDown() {
        if (driver != null) {
            driver.quit();
        }
    }
}

POM reduces code duplication and makes it easier to maintain and update tests, especially when UI changes occur.

7. Maintain Consistent Naming Conventions

Consistent naming improves readability and reduces confusion:

• Use clear and descriptive names: The names should clearly indicate the purpose or action.
• Follow a naming pattern: Create a consistent naming convention for your step definitions and methods to maintain clarity.
• Avoid ambiguous names: Ensure names are specific and unambiguous to prevent misinterpretation.

@When("the user enters {string} and {string}")
public void whenUserEntersCredentials(String username, String password) {
    loginPage.enterUsername(username);
    loginPage.enterPassword(password);
    loginPage.clickLogin();
}

Consistent naming improves readability, making it easier for teams to understand what each step does and how the test flows.