Java TDD

Test-Driven Development (TDD) using Java

Test-Driven Development (TDD) is a software development methodology where tests are written before writing the actual code. This practice ensures that the code is thoroughly tested and designed to meet the requirements from the outset. TDD consists of three main steps: write a failing test, write the minimum code to pass the test, and then refactor the code.

Key Concepts in TDD

• Red-Green-Refactor Cycle: The fundamental cycle of TDD.
• Red: Write a test that fails.
• Green: Write the minimal code necessary to pass the test.
• Refactor: Improve the code while keeping the tests green.
• Incremental Development: Develop code in small, incremental steps with continuous feedback from tests.
• Design Improvement: Continuous refactoring to improve code design and maintainability.

TDD Workflow

1. Write a Failing Test: Write a test for the new functionality. This test should fail initially because the functionality has not been implemented yet.
2. Write the Minimum Code to Pass the Test: Write just enough code to make the test pass. Avoid writing extra functionality at this stage.
3. Refactor the Code: Clean up the code while ensuring all tests still pass. Refactor the tests if necessary.

Setting Up TDD in Java with JUnit

Add JUnit Dependency

• Maven:

  <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-engine</artifactId>
      <version>5.7.2</version>
      <scope>test</scope>
  </dependency>

Example: TDD with a Simple Calculator

1. Write a Failing Test

   import org.junit.jupiter.api.Test;
   import static org.junit.jupiter.api.Assertions.*;

   public class CalculatorTest {
       @Test
       public void testAddition() {
           Calculator calculator = new Calculator();
           assertEquals(5, calculator.add(2, 3));
       }
   }

2. Write Minimal Code to Pass the Test

   public class Calculator {
       public int add(int a, int b) {
           return a + b;
       }
   }

3. Refactor the Code In this simple example, there might not be much to refactor. But in more complex scenarios, this step involves cleaning up code, improving design, and optimizing performance while ensuring all tests pass.

Using Cucumber for BDD

Behavior-Driven Development (BDD) is an extension of TDD that encourages collaboration between developers, QA, and non-technical or business participants. Cucumber is a popular BDD framework that allows you to write tests in plain language.

Key Concepts in BDD

• Gherkin Syntax: Plain language structured with Given-When-Then steps.
• Given: Defines the initial context or state.
• When: Specifies the action or event.
• Then: Describes the expected outcome.
• Feature Files: Contain scenarios written in Gherkin syntax.
• Step Definitions: Map Gherkin steps to code.

Setting Up Cucumber

Add Dependencies:

• Maven:

  <dependency>
      <groupId>io.cucumber</groupId>
      <artifactId>cucumber-java</artifactId>
      <version>6.10.2</version>
      <scope>test</scope>
  </dependency>
  <dependency>
      <groupId>io.cucumber</groupId>
      <artifactId>cucumber-junit</artifactId>
      <version>6.10.2</version>
      <scope>test</scope>
  </dependency>

Example: BDD with Cucumber and a Simple Calculator

1. Create a Feature File

• src/test/resources/features/calculator.feature:

Feature: Calculator
  Scenario: Addition
    Given I have a calculator
    When I add 2 and 3
    Then the result should be 5

1. Create Step Definitions

• src/test/java/steps/CalculatorSteps.java

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

public class CalculatorSteps {
    private Calculator calculator;
    private int result;

    @Given("I have a calculator")
    public void i_have_a_calculator() {
        calculator = new Calculator();
    }

    @When("I add {int} and {int}")
    public void i_add_and(int a, int b) {
        result = calculator.add(a, b);
    }

    @Then("the result should be {int}")
    public void the_result_should_be(int expected) {
        assertEquals(expected, result);
    }
}

• Create a Test Runner

• src/test/java/runners/RunCucumberTest.java

import org.junit.platform.suite.api.IncludeEngines;
import org.junit.platform.suite.api.SelectClasspathResource;
import org.junit.platform.suite.api.Suite;

@Suite
@IncludeEngines("cucumber")
@SelectClasspathResource("features")
public class RunCucumberTest {
}

• Implement the Calculator Class

• src/main/java/Calculator.java:

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

• Run the Tests

• Use your IDE’s built-in test runner or run the tests from the command line using Maven: mvn test

Benefits of TDD and BDD

• Improved Code Quality: Writing tests first ensures that code meets requirements and is thoroughly tested.
• Better Design: TDD and BDD encourage writing clean, maintainable, and modular code.
• Faster Debugging: Early detection of issues reduces the time spent on debugging.
• Collaboration: BDD fosters collaboration between developers, testers, and business stakeholders.

Best Practices for TDD and BDD

• Start Simple: Begin with simple tests and gradually add more complex scenarios.
• Refactor Regularly: Continuously improve the codebase by refactoring.
• Write Clear and Concise Tests: Ensure that tests are easy to read and understand.
• Collaborate: Engage all stakeholders in the BDD process to ensure comprehensive requirements coverage.
• Automate: Integrate tests into your CI/CD pipeline for automatic execution.

Summary

Test-Driven Development (TDD) and Behavior-Driven Development (BDD) are powerful methodologies for ensuring high code quality and meeting business requirements. By leveraging tools like JUnit for TDD and Cucumber for BDD, developers can create robust and maintainable Java applications.

• TDD: Write tests first, then code, and refactor. Focus on small, incremental development steps.
• BDD: Write tests in plain language using the Gherkin syntax. Focus on collaboration between technical and non-technical stakeholders.

By adopting these practices, you can improve the quality, maintainability, and reliability of your Java applications.

Additional Example: Advanced TDD with Mocking

Mocking is often used in TDD to isolate the unit of work and ensure that dependencies do not interfere with the test outcomes. Mockito is a popular framework for mocking in Java.

Setting Up Mockito

Add Mockito Dependency:

• Maven:

  <dependency>
      <groupId>org.mockito</groupId>
      <artifactId>mockito-core</artifactId>
      <version>3.9.0</version>
      <scope>test</scope>
  </dependency>

Example: TDD with Mockito

1. Write a Failing Test

   import org.junit.jupiter.api.Test;
   import org.mockito.Mockito;
   import static org.junit.jupiter.api.Assertions.*;
   import static org.mockito.Mockito.*;

   public class UserServiceTest {
       @Test
       public void testGetUserById() {
           UserRepository mockRepository = Mockito.mock(UserRepository.class);
           UserService userService = new UserService(mockRepository);

           User user = new User(1L, "John Doe");
           when(mockRepository.findById(1L)).thenReturn(user);

           User result = userService.getUserById(1L);
           assertEquals("John Doe", result.getName());
       }
   }

2. Write Minimal Code to Pass the Test

   public class UserService {
       private UserRepository userRepository;

       public UserService(UserRepository userRepository) {
           this.userRepository = userRepository;
       }

       public User getUserById(Long id) {
           return userRepository.findById(id);
       }
   }

   public interface UserRepository {
       User findById(Long id);
   }

   public class User {
       private Long id;
       private String name;

       public User(Long id, String name) {
           this.id = id;
           this.name = name;
       }

       public Long getId() {
           return id;
       }

       public String getName() {
           return name;
       }
   }

3. Refactor the Code

• Refactoring might involve cleaning up the UserService or UserRepository implementations, ensuring dependency injection is used correctly, and optimizing the design for maintainability.

By integrating Mockito into your TDD workflow, you can effectively isolate your tests and ensure that each unit is tested independently, leading to more robust and reliable code.