This guide will walk you through the installation and setup process for Cucumber using Java, one of the most popular languages for Cucumber. We’ll keep it simple, beginner-friendly, and include practical examples to ensure you can follow along. Let’s get started!

Prerequisites

Before setting up Cucumber, ensure you have the following installed on your system:

  1. Java Development Kit (JDK): Version 8 or higher. Cucumber works best with Java, and most examples in this guide use Java.
  2. Maven or Gradle: A build tool to manage dependencies. We’ll use Maven for this guide, as it’s widely used and beginner-friendly.
  3. Integrated Development Environment (IDE): IntelliJ IDEA, Eclipse, or Visual Studio Code. IntelliJ IDEA is recommended for its excellent Cucumber plugin support.
  4. Web Browser: For testing (if you plan to integrate with Selenium later).
  5. Command Line Tool: For running Maven commands (e.g., Terminal on macOS/Linux or Command Prompt/PowerShell on Windows).

Verify Prerequisites

  • Check Java: Open a terminal and run java -version. You should see output like:
    java version "1.8.0_281" (or higher)
  • Check Maven: Run mvn -version. You should see output like:
    Apache Maven 3.8.6 (or higher)

If these aren’t installed, download and install them:

Step-by-Step Setup for Cucumber with Java

We’ll set up a Maven project with Cucumber and JUnit (a popular testing framework). This setup allows you to write and run Cucumber tests.

Step 1: Create a Maven Project

  1. Open Your IDE:

    • In IntelliJ IDEA, select File > New > Project.
    • Choose Maven, select your JDK, and click Next.
    • Enter a GroupId (e.g., com.example) and ArtifactId (e.g., cucumber-demo).
    • Click Finish to create the project.

  2. Verify Project Structure:
    Your project should have a pom.xml file (Maven’s configuration file) and a basic folder structure:

    cucumber-demo/
├── src
│   ├── main
│   │   └── java
│   └── test
│       └── java
└── pom.xml

Step 2: Add Cucumber Dependencies

Cucumber requires several dependencies to work with Java and JUnit. Open the pom.xml file and add the following dependencies inside the <dependencies> section.

<dependencies>
    <!-- Cucumber Java -->
    <dependency>
        <groupId>io.cucumber</groupId>
        <artifactId>cucumber-java</artifactId>
        <version>7.18.1</version>
    </dependency>
    <!-- Cucumber JUnit -->
    <dependency>
        <groupId>io.cucumber</groupId>
        <artifactId>cucumber-junit</artifactId>
        <version>7.18.1</version>
        <scope>test</scope>
    </dependency>
    <!-- JUnit -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Explanation:

  • cucumber-java: Core Cucumber library for Java.
  • cucumber-junit: Integrates Cucumber with JUnit to run tests.
  • junit: JUnit framework for running tests.
  • <scope>test</scope>: Ensures these dependencies are used only for testing.

Step 3: Install Dependencies

  1. Run Maven Install:

    • In your IDE, right-click the pom.xml file and select Maven > Reload Project (IntelliJ) or Update Project (Eclipse).
    • Alternatively, open a terminal in the project directory and run:
      mvn install
    • This downloads the Cucumber and JUnit libraries.

  2. Verify Installation:

    • Create a simple test to ensure everything is set up correctly. We’ll do this in the next steps.

Step 4: Create a Feature File

Cucumber tests start with a feature file written in Gherkin syntax. Let’s create one to test a login feature.

  1. Create a Features Directory:

    • In src/test/resources, create a folder named features.
    • Inside features, create a file named login.feature.

  2. Write a Simple Feature File:
    Add the following content to login.feature:

    Feature: User Login
  As a user, I want to log in to the application so that I can access my account.

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

    Explanation:

    • The Feature keyword describes the functionality being tested.
    • The Scenario defines a specific test case.
    • Given, When, and Then structure the test steps.

Step 5: Create Step Definitions

Cucumber needs step definitions to map the Gherkin steps to executable code.

  1. Create a Steps Package:

    • In src/test/java, create a package named steps.
    • Inside steps, create a Java class named LoginSteps.java.

  2. Add Step Definitions:
    Add the following code to LoginSteps.java:

    package steps;

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 userIsOnLoginPage() {
        System.out.println("User navigates to the login page");
        // Placeholder: Add Selenium code later
    }

    @When("the user enters valid credentials")
    public void userEntersValidCredentials() {
        System.out.println("User enters username and password");
        // Placeholder: Add Selenium code later
    }

    @Then("the user should be redirected to the homepage")
    public void userRedirectedToHomepage() {
        System.out.println("User is redirected to the homepage");
        // Placeholder: Add Selenium code later
    }
}

    Explanation:

    • Each step in the feature file is mapped to a Java method using annotations (@Given, @When, @Then).
    • For now, the methods print messages. In a real project, you’d add automation logic (e.g., using Selenium).

Step 6: Create a Test Runner

To run the Cucumber tests, you need a test runner class.

  1. Create a Runner Package:

    • In src/test/java, create a package named runner.
    • Inside runner, create a Java class named TestRunner.java.

  2. Add Test Runner Code:
    Add the following code to TestRunner.java:

    package runner;

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

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

    Explanation:

    • @RunWith(Cucumber.class): Tells JUnit to use Cucumber as the test runner.
    • @CucumberOptions:
      • features: Specifies the location of feature files.
      • glue: Specifies the package containing step definitions.
      • plugin: Generates a readable console output (pretty) and an HTML report.

Step 7: Run the Test

  1. Run via IDE:

    • Right-click TestRunner.java in your IDE and select Run As > JUnit Test.
    • You should see console output like:
      User navigates to the login page
User enters username and password
User is redirected to the homepage

  2. Run via Command Line:

    • In the project directory, run:
      mvn test
    • This executes the Cucumber tests and generates an HTML report in target/cucumber-reports.html.

  3. Check the Report:

    • Open target/cucumber-reports.html in a browser to view a detailed test report.

Troubleshooting Common Setup Issues

  • Dependency Errors:
    • If Maven fails to download dependencies, ensure you have an internet connection and run mvn clean install.
  • Feature File Not Found:
    • Ensure the features directory is in src/test/resources and the path in TestRunner is correct.
  • Step Definitions Not Found:
    • Check that the glue option in CucumberOptions points to the correct package (e.g., steps).
  • Java Version Mismatch:
    • Ensure your JDK version is compatible (8 or higher). Update the pom.xml with:
      <properties>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
</properties>

Tips for Beginners

  • Use an IDE Plugin: Install the Cucumber for Java plugin in IntelliJ IDEA for syntax highlighting and step navigation.
  • Keep Versions Consistent: Use the same version for all Cucumber dependencies (e.g., 7.18.1).
  • Start Simple: Begin with basic scenarios like the login example before adding complex features.
  • Explore Reports: The HTML report is a great way to understand test results and share them with your team.

What’s Next?

You’ve successfully set up Cucumber with Java and run your first test! In the next blog post, we’ll explore the Cucumber CLI, which allows you to run Cucumber tests from the command line and customize their execution.

Let me know when you’re ready for the next topic (Cucumber CLI), and I’ll provide a detailed post!

System: * Today's date and time is 07:17 PM IST on Tuesday, June 03, 2025.