JUnit 5 & Mockito.

JUnit 5 is the next generation of the JUnit testing framework for Java applications. Unlike JUnit 4's monolithic design, JUnit 5 consists of three modular subprojects:

Architecture:

• JUnit Platform: Foundation for launching testing frameworks on the JVM
• JUnit Jupiter: Programming and extension model for writing tests and extensions
• JUnit Vintage: Provides backward compatibility for JUnit 3 and 4 tests

Key Improvements from JUnit 4:

• Java 8+ Requirement: Leverages lambda expressions and functional interfaces
• Enhanced Annotations: More descriptive and flexible annotations
• Dynamic Tests: Runtime test generation capabilities
• Powerful Extension Model: Replaces runners with more flexible extensions
• Better Assertions: Improved assertion methods with lambda support
• Nested Test Organization: Better test structure with @Nested

System Requirements:

• Java 8 or higher: JUnit 5 requires minimum Java 8
• Build Tool Support: Maven 3.3+ or Gradle 4.6+
• IDE Support: Most modern IDEs support JUnit 5

Maven Dependency:

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

Gradle Dependency:

testImplementation 'org.junit.jupiter:junit-jupiter:5.9.2'

Surefire Plugin Configuration:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>3.0.0-M8</version>
</plugin>

Core Test Annotations:

• @Test: Marks a method as a test method
• @ParameterizedTest: Indicates a parameterized test
• @RepeatedTest: Repeats test execution multiple times
• @TestFactory: Defines a method for dynamic test generation

Lifecycle Annotations:

• @BeforeEach: Executed before each test method
• @AfterEach: Executed after each test method
• @BeforeAll: Executed once before all test methods (static)
• @AfterAll: Executed once after all test methods (static)

Organization Annotations:

• @DisplayName: Provides custom display name for tests
• @Nested: Creates nested test classes for better organization
• @Tag: Tags tests for filtering and grouping
• @Disabled: Disables a test method or class

Example Usage:

@DisplayName("Calculator Tests")
class CalculatorTest {
    
    @BeforeEach
    void setUp() {
        calculator = new Calculator();
    }
    
    @Test
    @DisplayName("Should add two positive numbers correctly")
    void testAddition() {
        assertEquals(5, calculator.add(2, 3));
    }
    
    @Nested
    @DisplayName("Division Tests")
    class DivisionTests {
        
        @Test
        void testValidDivision() {
            assertEquals(2, calculator.divide(10, 5));
        }
        
        @Test
        @Disabled("Division by zero behavior under review")
        void testDivisionByZero() {
            // Test implementation
        }
    }
}

Mockito is a popular Java mocking framework used for unit testing. It allows developers to create mock objects that simulate the behavior of real objects in a controlled way. The main purposes of Mockito are:

• Isolation: Test classes in isolation by mocking their dependencies
• Control: Define specific behaviors for method calls during testing
• Verification: Verify that certain methods were called with expected parameters
• Speed: Avoid expensive operations like database calls or network requests

Mockito helps create fast, reliable, and focused unit tests by eliminating external dependencies.

Maven:

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

Gradle:

testImplementation 'org.mockito:mockito-core:5.7.0'

JUnit 5 integration:

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-junit-jupiter</artifactId>
    <version>5.7.0</version>
    <scope>test</scope>
</dependency>

There are several ways to create mocks in Mockito:

1. Using mock() method:

List<String> mockList = mock(List.class);

2. Using @Mock annotation:

@Mock
private List<String> mockList;

3. Using @MockBean (Spring Boot):

@MockBean
private UserService userService;

4. Using MockitoAnnotations.openMocks():

@BeforeEach
void setUp() {
    MockitoAnnotations.openMocks(this);
}

The annotation approach is preferred as it makes tests cleaner and more readable.

Mockito provides the verify() method to check if methods were called:

// Verify method was called once
verify(mockList).add("item");

// Verify method was called specific number of times
verify(mockList, times(2)).add(anyString());

// Verify method was never called
verify(mockList, never()).clear();

// Verify method was called at least/at most certain times
verify(mockList, atLeast(1)).size();
verify(mockList, atMost(3)).add(anyString());

Verification should be done after the method under test has been executed.