Partner – Jmix-Haulmont – NPI (cat= Spring Boot)
announcement - icon

Whether you're just starting out or have years of experience, Spring Boot is a great choice for building new applications with ease.

Jmix enhances the capabilities of Spring Boot developers, allowing them to build and deliver full-stack web applications without getting their hands dirty with frontend techs. It empowers you to create everything from simple web GUI CRUD applications to complex enterprise solutions, eliminating frontend/backend separation and related security concerns.

Jmix Platform includes a framework built on top of Spring Boot, JPA, and Vaadin, and comes with Jmix Studio, an IntelliJ IDEA plugin equipped with a suite of developer productivity tools. The platform also offers out-of-the-box add-ons for report generation, BPM, maps, and more that you can use in your Jmix application or as a separate service. All technologies are interconnected to empower a single Java developer to perform at the level of a whole team, with minimal knowledge required to get started.

Plus! Jmix can instantly generate a CRUD web application, complete with its JPA data model and UI, directly from an existing database. Then, continue developing with the help of Jmix Studio.

Develop smart, not hard!

>> Become a full-stack developer with Jmix

Course – RWSB – NPI (cat=REST/Spring Boot)
announcement - icon

Now that the new version of REST With Spring - “REST With Spring Boot” is finally out, the current price will be available until the 22nd of June, after which it will permanently increase by 50$

>> GET ACCESS NOW

Course – LS – All
announcement - icon

Get started with Spring Boot and with core Spring, through the Learn Spring course:

>> CHECK OUT THE COURSE

1. Overview

In this tutorial, we’ll explore the usage of Spring Boot’s @Autowired and Mockito’s @InjectMocks while injecting dependencies in Spring Boot Tests. We’ll go over the use cases that require us to use them and look at examples for the same.

2. Understanding Test Annotations

Before starting with the code example, let’s quickly look at the basics of some test annotations.

First, the most commonly used @Mock annotation of Mockito creates a mock instance of a dependency for testing. It’s often used in conjunction with @InjectMocks which injects the mocks marked with @Mock into the target object being tested.

In addition to Mockito’s annotations, Spring Boot’s annotation @MockBean can help create a mocked Spring bean. The mocked bean can then be used by other beans in the context. Moreover, if a Spring context creates beans on its own that can be utilized without mocking, we can use the @Autowired annotation to inject them.

3. Example Setup

In our code example, we’ll create a service having two dependencies. We’ll then explore using the above annotations to test the service.

3.1. Dependencies

Let’s start by adding the required dependencies. We’ll include the Spring Boot Starter Web and Spring Boot Starter Test dependencies:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>3.2.5</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <version>3.2.5</version>
    <scope>test</scope>
</dependency>

In addition to this, we’ll add the Mockito Core dependency that we’ll need to mock our services:

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>5.11.0</version>
</dependency>

3.2. DTO

Next, let’s create a DTO that we’ll use in our services:

public class Book {
    private String id;
    private String name;
    private String author;
    
    // constructor, setters/getters
}

3.3. Services

Next, let’s look at our services. First, let’s define a service that is responsible for database interactions:

@Service
public class DatabaseService {
    public Book findById(String id) {
        // querying a Database and getting a book
        return new Book("id","Name", "Author");
    }
}

We’ll not go into the database interactions as they are irrelevant to the example. We use the @Service annotation to declare the class a Spring bean of Service stereotype.

Next, let’s introduce a service that is dependent on the above service:

@Service
public class BookService {
    private DatabaseService databaseService;
    private ObjectMapper objectMapper;

    BookService(DatabaseService databaseService, ObjectMapper objectMapper) {
        this.databaseService = databaseService;
        this.objectMapper = objectMapper;
    }

    String getBook(String id) throws JsonProcessingException {
        Book book = databaseService.findById(id);
        return objectMapper.writeValueAsString(book);
    }
}

Here we have a small service that has a getBook() method. The method utilizes the DatabaseService to get a book from the database. It then uses the ObjectMapper API of Jackson to convert and return the Book object into a JSON string.

Therefore, this service has two dependencies: DatabaseService and ObjectMapper.

4. Testing

Now that our services are set up, let’s look at ways to test BookService using the annotations we defined earlier.

4.1. Using @Mock and @InjectMocks

The first option is to mock both dependencies of the service using @Mock and inject them into the service using @InjectMocks. Let’s create a test class for the same:

@ExtendWith(MockitoExtension.class)
class BookServiceMockAndInjectMocksUnitTest {
    @Mock
    private DatabaseService databaseService;

    @Mock
    private ObjectMapper objectMapper;

    @InjectMocks
    private BookService bookService;

    @Test
    void givenBookService_whenGettingBook_thenBookIsCorrect() throws JsonProcessingException {
        Book book1 = new Book("1234", "Inferno", "Dan Brown");
        when(databaseService.findById(eq("1234"))).thenReturn(book1);

        when(objectMapper.writeValueAsString(any())).thenReturn(new ObjectMapper().writeValueAsString(book1));

        String bookString1 = bookService.getBook("1234");
        Assertions.assertTrue(bookString1.contains("Dan Brown"));
    }
}

First, we annotate the test class with @ExtendWith(MockitoExtension.class). The MockitoExtenstion extension allows us to mock and inject objects in our test.

Next, we declare the DatabaseService and ObjectMapper fields and annotate them with @Mock. This creates mocked objects for both of them. We add the @InjectMocks annotation when declaring our BookService instance that we’ll test. This injects any dependencies that the service requires and have been declared earlier with @Mocks.

Finally, in our test, we mock the behavior of our mocked objects and test the getBook() method of our service.

It’s mandatory to mock all the dependencies of the service when using this method. For example, if we don’t mock ObjectMapper, it leads to a NullPointerException when it’s called in the tested method.

4.2. Using @Autowired With @MockBean

In the above method, we mocked both the dependencies. However, it may be required to mock some of the dependencies and not mock the others. Let’s assume we don’t need to mock the behavior of ObjectMapper and mock only DatabaseService.

Since we’re loading the Spring context in our test, we can use the combination of @Autowired and @MockBean annotations to do so:

@SpringBootTest
class BookServiceAutowiredAndInjectMocksUnitTest {
    @MockBean
    private DatabaseService databaseService;

    @Autowired
    private BookService bookService;

    @Test
    void givenBookService_whenGettingBook_thenBookIsCorrect() throws JsonProcessingException {
        Book book1 = new Book("1234", "Inferno", "Dan Brown");
        when(databaseService.findById(eq("1234"))).thenReturn(book1);

        String bookString1 = bookService.getBook("1234");
        Assertions.assertTrue(bookString1.contains("Dan Brown"));
    }
}

First, to use beans from the Spring context, we need to annotate our test class with @SpringBootTest.Next, we annotate DatabaseService with @MockBean. Then we get the BookService instance from the application context using @Autowired.

When the BookService bean is injected, the actual DatabaseService bean will be replaced by the mocked bean. Conversely, the ObjectMapper bean remains the same as originally created by the application.

When we test this instance now, we don’t need to mock any behavior for ObjectMapper.

This method is useful when we need to test the behavior of nested beans and don’t want to mock every dependency.

4.3. Using @Autowired and @InjectMocks Together

We could also use @InjectMocks instead of @MockBean for the above use case.

Let’s look at the code to see the difference between the two methods:

@Mock
private DatabaseService databaseService;

@Autowired
@InjectMocks
private BookService bookService;

@Test
void givenBookService_whenGettingBook_thenBookIsCorrect() throws JsonProcessingException {
    Book book1 = new Book("1234", "Inferno", "Dan Brown");

    MockitoAnnotations.openMocks(this);

    when(databaseService.findById(eq("1234"))).thenReturn(book1);
    String bookString1 = bookService.getBook("1234");
    Assertions.assertTrue(bookString1.contains("Dan Brown"));
}

Here, we mock the DatabaseService using @Mock instead of @MockBean. In addition to @Autowired, we add the @InjectMocks annotation to the BookService instance.

When both annotations are used together, @InjectMocks doesn’t inject the mocked dependency automatically and the auto-wired BookService object is injected when the test starts.

However, we can inject the mocked instance of DatabaseService later in our test by calling the MockitoAnnotations.openMocks() method. This method looks for fields marked with @InjectMocks and injects mocked objects into it.

We call it in our test just before we need to mock the behavior of DatabaseService. This method is useful when we want to dynamically decide when to use mocks and when to use the actual bean for the dependency.

5. Comparison of Approaches

Now that we’ve looked at multiple approaches, let’s summarise a comparison between them:

Approach Description Usage
@Mock with @InjectMocks Uses Mockito’s @Mock annotation to create a mock instance of a dependency and @InjectMocks to inject these mocks into the target object being tested. Suitable for unit testing where we want to mock all dependencies of the class under test.
@MockBean with @Autowired Utilizes Spring Boot’s @MockBean annotation to create a mocked Spring bean and @Autowired to inject these beans. Ideal for integration testing in Spring Boot applications. It allows mocking some Spring beans while getting the other beans from Spring’s dependency injection.
@InjectMocks with @Autowired  Uses Mockito’s @Mock annotation to create mock instances, and @InjectMocks to inject these mocks into target beans already auto-wired using Spring. Provides flexibility in scenarios where we need to mock some dependencies temporarily using Mockito to override injected Spring Beans. Useful for testing complex scenarios in Spring applications.

6. Conclusion

In this article, we looked at different use cases of Mockito and Spring Boot annotations – @Mock, @InjectMocks, @Autowired and @MockBean. We explored when to use different combinations of the annotations as per our testing needs.

As usual, the code examples for this tutorial are available over on GitHub.

Course – RWSB – NPI (cat=REST/Spring/Spring Boot)
announcement - icon

Now that the new version of REST With Spring - “REST With Spring Boot” is finally out, the current price will be available until the 22nd of June, after which it will permanently increase by 50$

>> GET ACCESS NOW

Course – LS – All
announcement - icon

Get started with Spring Boot and with core Spring, through the Learn Spring course:

>> CHECK OUT THE COURSE

res – REST with Spring (eBook) (everywhere)
Subscribe
Notify of
guest
2 Comments
Oldest
Newest
Inline Feedbacks
View all comments