Mockito framework

Key Features

1. Mocking Dependencies:

   • Create mock objects for classes and interfaces to simulate their behavior.
   • Helps test a class in isolation without relying on real implementations.

2. Spying on Real Objects:

   • Wrap real objects with a spy to monitor their interactions while retaining their actual behavior.

3. Behavior Verification:

   • Verify that specific methods were called (or not called) with expected arguments.

4. Stubbing Methods:

   • Define custom behavior for mocked methods, e.g., returning specific values when certain inputs are passed.

5. Argument Matchers:

   • Use flexible matchers (like any() or eq()) to verify method calls with dynamic or complex arguments.

6. Exception Handling:

   • Simulate exceptions to test error handling in your code.

7. Annotation Support:

   • Use annotations like @Mock, @Spy, @InjectMocks, and @Captor for cleaner, more readable tests.

Advantages

• Simple API: Easy to use and integrate into projects.
• No Boilerplate: Annotations minimize the need for repetitive setup code.
• Flexible Stubbing: Can stub specific methods or behaviors on mock objects.
• Integration with Testing Frameworks: Works seamlessly with JUnit and TestNG.
• Active Community: Well-documented with active contributions and wide usage.

Common Annotations

• @Mock: Creates a mock object for the specified class.
• @Spy: Creates a spy object that retains the real behavior of the class but allows method stubbing.
• @InjectMocks: Automatically injects mock objects into the class under test.
• @Captor: Captures arguments passed to a mocked method.

Basic Example

Mocking and Stubbing

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

class Service {
    public String fetchData() {
        return "Real Data";
    }
}

public class MockitoExample {

    @Test
    void testMocking() {
        // Create a mock object
        Service serviceMock = mock(Service.class);

        // Stub the fetchData() method
        when(serviceMock.fetchData()).thenReturn("Mock Data");

        // Call the method
        String result = serviceMock.fetchData();

        // Verify behavior
        verify(serviceMock).fetchData();

        // Assert the result
        System.out.println(result); // Output: Mock Data
    }
}

Key Concepts

1. Mocks vs. Spies:

   • Mock: A completely fake implementation.
   • Spy: Partial mock that wraps a real object and monitors its behavior.

2. Verification:

   • Ensures methods were called (or not called) with specific arguments.

verify(mockObject).someMethod("expectedArgument");
verify(mockObject, times(2)).someMethod(); // Called twice
verifyNoInteractions(mockObject); // Ensures no methods were called

Argument Matchers:

• Flexible verification or stubbing with matchers:

when(mockObject.someMethod(anyString())).thenReturn("Matched");
verify(mockObject).someMethod(eq("expectedValue"));

Exception Stubbing:

• Simulate exceptions to test error handling:

when(mockObject.someMethod()).thenThrow(new RuntimeException("Error"));

Advanced Usage

Injecting Mocks:

• • Combine mocks and real objects:

@Mock
private Dependency dependency;

@InjectMocks
private ServiceUnderTest serviceUnderTest;

Capturing Arguments:

• Use ArgumentCaptor to capture method arguments during verification:

@Captor
ArgumentCaptor<String> captor;

verify(mock).someMethod(captor.capture());
assertEquals("ExpectedValue", captor.getValue());