Behavior-Driven Development (BDD) with JUnit, Mockito, and Cucumber

Behavior-Driven Development (BDD) bridges the gap between technical and non-technical stakeholders by making tests readable and executable specifications. In Java, this approach is widely supported by JUnit 5, Mockito, and Cucumber, enabling developers to write test cases in plain English (Gherkin syntax) that map directly to Java methods.

In this tutorial, you will learn how to set up and use BDD with JUnit, Mockito, and Cucumber, and integrate them seamlessly in real-world Java projects.

---

What is Behavior-Driven Development (BDD)?

• TDD vs. BDD: While Test-Driven Development (TDD) focuses on unit tests, BDD emphasizes the behavior of the system in business terms.
• Readable tests: With Cucumber’s Gherkin syntax, tests become easy for business analysts, QA engineers, and developers to understand.
• Collaboration: Encourages shared understanding between developers, testers, and product owners.

Analogy: Think of BDD like writing a movie script—every stakeholder can read it, but developers know how to direct and act it out.

---

Project Setup

Add the required dependencies to your Maven pom.xml:

<dependencies>
    <!-- JUnit 5 -->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>5.9.3</version>
        <scope>test</scope>
    </dependency>

    <!-- Mockito -->
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-core</artifactId>
        <version>5.5.0</version>
        <scope>test</scope>
    </dependency>

    <!-- Cucumber -->
    <dependency>
        <groupId>io.cucumber</groupId>
        <artifactId>cucumber-java</artifactId>
        <version>7.11.0</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>io.cucumber</groupId>
        <artifactId>cucumber-junit</artifactId>
        <version>7.11.0</version>
        <scope>test</scope>
    </dependency>
</dependencies>

---

Writing a Feature File in Gherkin

Example: login.feature

Feature: Login functionality

  Scenario: Successful login with valid credentials
    Given the user has a valid account
    When the user logs in with correct credentials
    Then the login should be successful

---

Step Definitions in Java

import io.cucumber.java.en.*;
import static org.junit.jupiter.api.Assertions.*;

public class LoginSteps {

    private String username;
    private String password;
    private boolean loginResult;

    @Given("the user has a valid account")
    public void userHasValidAccount() {
        username = "admin";
        password = "password";
    }

    @When("the user logs in with correct credentials")
    public void userLogsIn() {
        loginResult = "admin".equals(username) && "password".equals(password);
    }

    @Then("the login should be successful")
    public void loginShouldBeSuccessful() {
        assertTrue(loginResult, "Login should succeed with correct credentials");
    }
}

---

Using Mockito with Cucumber

You can inject mocks to simulate dependencies:

import static org.mockito.Mockito.*;

public class LoginServiceTest {

    @Test
    void testLoginWithMock() {
        UserRepository repo = mock(UserRepository.class);
        when(repo.isValidUser("admin", "password")).thenReturn(true);

        LoginService service = new LoginService(repo);
        boolean result = service.login("admin", "password");

        assertTrue(result);
        verify(repo).isValidUser("admin", "password");
    }
}

---

Running Tests with JUnit 5

Use a CucumberTestRunner:

import org.junit.platform.suite.api.*;

@Suite
@IncludeEngines("cucumber")
@SelectClasspathResource("features")
@ConfigurationParameter(key = "cucumber.glue", value = "com.example.steps")
public class CucumberTestRunner {}

---

Best Practices for BDD with JUnit, Mockito, and Cucumber

1. Keep feature files readable and concise.
2. Use Mockito for isolating dependencies.
3. Avoid overly technical language in Gherkin files.
4. Maintain one-to-one mapping between scenarios and step definitions.
5. Automate BDD tests in your CI/CD pipeline.

---

Conclusion & Key Takeaways

• BDD improves collaboration by making tests business-readable.
• JUnit + Mockito ensure strong unit and integration testing.
• Cucumber bridges the gap between business and code.
• Integrating these tools helps build scalable, maintainable test suites.

---

FAQ

1. What is the main benefit of BDD?
BDD makes tests readable for both technical and non-technical stakeholders.

2. Can I use Mockito with Cucumber?
Yes, Mockito can be used for dependency mocking in step definitions.

3. What is the difference between TDD and BDD?
TDD focuses on implementation, while BDD focuses on system behavior.

4. How do I run Cucumber tests in JUnit 5?
Use a JUnit Platform @Suite runner with Cucumber engine integration.

5. Can Testcontainers be used with Cucumber?
Yes, for spinning up databases or services needed for integration tests.

6. Is BDD suitable for microservices testing?
Absolutely. BDD ensures services meet user-facing expectations.

7. Should every project adopt BDD?
Not necessarily. It’s most useful in collaborative, business-critical domains.

8. How do I integrate BDD in CI/CD?
Add Cucumber test execution into Jenkins, GitHub Actions, or GitLab pipelines.

9. What’s the difference between feature and scenario in Cucumber?
A feature is a high-level requirement, while a scenario is a specific test case.

10. Can I mix TDD and BDD?
Yes, you can use TDD for unit tests and BDD for higher-level system behavior.

---