The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Creating Mocks

Next ►
►

In this section, we will delve into the concept of creating mocks in JUnit using the Mockito framework. Mocking is a crucial technique in unit testing that allows you to simulate the behavior of complex objects and control their interactions. This is particularly useful when testing components that depend on external systems or services.

What is Mocking?

Mocking is the process of creating a simulated version of an object that mimics the behavior of a real object. This allows you to:

  • Isolate the unit of work being tested.
  • Control the behavior of dependencies.
  • Verify interactions between objects.

Why Use Mockito?

Mockito is a popular mocking framework for Java that integrates seamlessly with JUnit. It provides a simple API to create, configure, and verify mocks.

Key Features of Mockito:

  • Creating Mocks: Easily create mock objects.
  • Stubbing: Define the behavior of mock methods.
  • Verification: Check if certain methods were called on the mock.

Setting Up Mockito

Before we start creating mocks, ensure that you have added the Mockito dependency to your project. If you are using Maven, add the following to your pom.xml:

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

Creating a Mock Object

To create a mock object, use the Mockito.mock() method. Here’s a simple example:

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

public class MockExampleTest {

    @Test
    public void testMockCreation() {
        // Create a mock object of the List class
        List<String> mockedList = Mockito.mock(List.class);

        // Define the behavior of the mock
        Mockito.when(mockedList.size()).thenReturn(10);

        // Use the mock in a test
        assertEquals(10, mockedList.size());
    }
}

Explanation:

  1. Creating the Mock: Mockito.mock(List.class) creates a mock object of the List class.
  2. Stubbing: Mockito.when(mockedList.size()).thenReturn(10) defines the behavior of the size() method to return 10.
  3. Using the Mock: The mock is used in the test, and we assert that the size() method returns 10.

Stubbing Methods

Stubbing is the process of defining the behavior of mock methods. You can stub methods to return specific values or throw exceptions.

Example: Stubbing Methods

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

public class StubbingExampleTest {

    @Test
    public void testStubbing() {
        // Create a mock object of the List class
        List<String> mockedList = Mockito.mock(List.class);

        // Stub the get method to return "Hello" when called with index 0
        Mockito.when(mockedList.get(0)).thenReturn("Hello");

        // Stub the get method to throw an exception when called with index 1
        Mockito.when(mockedList.get(1)).thenThrow(new RuntimeException("Index out of bounds"));

        // Use the mock in a test
        assertEquals("Hello", mockedList.get(0));
        assertThrows(RuntimeException.class, () -> mockedList.get(1));
    }
}

Explanation:

  1. Stubbing Return Value: Mockito.when(mockedList.get(0)).thenReturn("Hello") defines that calling get(0) will return "Hello".
  2. Stubbing Exception: Mockito.when(mockedList.get(1)).thenThrow(new RuntimeException("Index out of bounds")) defines that calling get(1) will throw a RuntimeException.
  3. Using the Mock: The mock is used in the test, and we assert the expected behavior.

Verifying Interactions

Mockito allows you to verify if certain methods were called on the mock object. This is useful to ensure that your code interacts with dependencies as expected.

Example: Verifying Interactions

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

public class VerificationExampleTest {

    @Test
    public void testVerification() {
        // Create a mock object of the List class
        List<String> mockedList = Mockito.mock(List.class);

        // Use the mock
        mockedList.add("Hello");
        mockedList.clear();

        // Verify that the add method was called with "Hello"
        verify(mockedList).add("Hello");

        // Verify that the clear method was called
        verify(mockedList).clear();
    }
}

Explanation:

  1. Using the Mock: The mock is used in the test by calling add("Hello") and clear().
  2. Verifying Interactions: verify(mockedList).add("Hello") checks if the add("Hello") method was called. verify(mockedList).clear() checks if the clear() method was called.

Practical Exercise

Exercise: Create and Verify a Mock

  1. Create a mock object of the Map class.
  2. Stub the get method to return "value" when called with the key "key".
  3. Verify that the get method was called with the key "key".

Solution:

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

public class MockExerciseTest {

    @Test
    public void testMockExercise() {
        // Create a mock object of the Map class
        Map<String, String> mockMap = Mockito.mock(Map.class);

        // Stub the get method to return "value" when called with the key "key"
        Mockito.when(mockMap.get("key")).thenReturn("value");

        // Use the mock in a test
        assertEquals("value", mockMap.get("key"));

        // Verify that the get method was called with the key "key"
        verify(mockMap).get("key");
    }
}

Explanation:

  1. Creating the Mock: Mockito.mock(Map.class) creates a mock object of the Map class.
  2. Stubbing: Mockito.when(mockMap.get("key")).thenReturn("value") defines that calling get("key") will return "value".
  3. Using the Mock: The mock is used in the test, and we assert that the get("key") method returns "value".
  4. Verifying Interactions: verify(mockMap).get("key") checks if the get("key") method was called.

Conclusion

In this section, we covered the basics of creating mocks using Mockito in JUnit. We learned how to:

  • Create mock objects.
  • Stub methods to define their behavior.
  • Verify interactions with mock objects.

Mocking is a powerful technique that helps you write effective unit tests by isolating the unit of work and controlling the behavior of dependencies. In the next section, we will explore how to verify interactions in more detail.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved