Java Unit Testing: JUnit and Mockito Tutorial

To get started with JUnit and Mockito, you need to add the necessary dependencies to your project. If you're using Maven, include the following in your pom.xml:

Edit Copy

<dependencies>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.10.0</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-engine</artifactId>
        <version>5.10.0</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-core</artifactId>
        <version>5.5.0</version>
        <scope>test</scope>
    </dependency>
</dependencies>

For Gradle, add the following to your build.gradle:

Edit Copy

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.0'
    testImplementation 'org.junit.jupiter:junit-jupiter-engine:5.10.0'
    testImplementation 'org.mockito:mockito-core:5.5.0'
}

JUnit provides annotations and assertions to write and run unit tests. Here's an example of a simple unit test:

Edit Copy

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

class CalculatorTest {
    @Test
    void testAdd() {
        Calculator calculator = new Calculator();
        assertEquals(5, calculator.add(2, 3), "2 + 3 should equal 5");
    }
}

• Annotations:
  • @Test: Marks a method as a test method.
  • @BeforeEach: Executed before each test method.
  • @AfterEach: Executed after each test method.
  • @BeforeAll: Executed once before all test methods.
  • @AfterAll: Executed once after all test methods.
• Assertions:
  • assertEquals(expected, actual): Checks if two values are equal.
  • assertTrue(condition): Checks if a condition is true.
  • assertFalse(condition): Checks if a condition is false.
  • assertNull(object): Checks if an object is null.
  • assertNotNull(object): Checks if an object is not null.

Mockito allows you to create mock objects to isolate the code under test from its dependencies. Here's an example:

Edit Copy

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

class UserServiceTest {
    @Test
    void testGetUser() {
        // Create a mock UserRepository
        UserRepository userRepository = Mockito.mock(UserRepository.class);

        // Define behavior for the mock
        when(userRepository.findUserById(1)).thenReturn(new User(1, "John Doe"));

        // Inject the mock into the service
        UserService userService = new UserService(userRepository);

        // Test the service
        User user = userService.getUser(1);
        assertEquals("John Doe", user.getName(), "User name should be John Doe");

        // Verify the mock was called
        verify(userRepository, times(1)).findUserById(1);
    }
}

• Mocking:
  • Mockito.mock(Class): Creates a mock object of the specified class.
  • when(mock.method()).thenReturn(value): Defines the behavior of the mock.
• Verification:
  • verify(mock, times(n)).method(): Verifies that a method was called a specific number of times.
  • verify(mock, never()).method(): Verifies that a method was never called.

Follow these best practices to write effective unit tests:

• Test One Thing at a Time: Each test should focus on a single functionality.
• Use Descriptive Test Names: Test method names should clearly describe what they test.
• Isolate Dependencies: Use mocking to isolate the code under test from external dependencies.
• Keep Tests Fast: Unit tests should run quickly to provide immediate feedback.
• Test Edge Cases: Include tests for boundary conditions and error scenarios.