Mock final class and final method with Mockito

Contents

Introduction

This post explains how to mock final methods and classes. Mockito doesn't support this behavior by default. To stub final methods and mock final classes, we need to enable the inline mock maker first. When you try to mock a final class without the mockito inline mockmaker you get an error message like this: mockito cannot mock/spy because : - final class.

Maven Dependency

For the examples, I used version 4.2.0 of Mockito.

1
2
3
4
5
6
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>4.2.0</version>
    <scope>test</scope>
</dependency>

We also need the inline mock maker to stub final classes/methods. We can add a dependency or create a file inside the test resources to enable the new Mock maker.

Option 1: Inline mock maker dependency

Add this dependency in your pom.

1
2
3
4
5
6
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-inline</artifactId>
    <version>4.2.0</version>
    <scope>test</scope>
</dependency>

Option 2: Adding a file to enable the inline mock maker

Create a resources directory in your test directory if you do not have one already. Inside the resources create the directory mockito-extensions and in that directory the file org.mockito.plugins.MockMaker. The complete path with file should look like this: src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker.

In the file org.mockito.plugins.MockMaker paste this text mock-maker-inline, now the mock maker is available during tests.

Mocking final class and methods

With inline mock maker, mocking a final class or method is the same as mocking a non-final class or method. Below we have an example that mocks the final class Cat. You can't tell from the @Test annotated method that we mock a final class.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
final class Cat {
    String makeSound() {return "Meow";}
}

@Test
void mockingFinalClass() {
    Cat cat = mock(Cat.class);
    when(cat.makeSound()).thenReturn("purr");
    assertThat(cat.makeSound()).isEqualTo("purr");
}

Mocking final methods also doesn't look any different from mocking a non-final method.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
class Bird {
    final String makeSound() {return "chirp";}
}

@Test
void mockFinalMethod(){
    Bird bird = mock(Bird.class);
    when(bird.makeSound()).thenReturn("tweet tweet");
    assertThat(bird.makeSound()).isEqualTo("tweet tweet");
}

Conclusion

In this post, we enabled the inline mock maker to mock final methods and classes. We also saw two examples of how to mock a final class and method and that it looks the same as mocking non-final classes and methods.

If you're curious and want to know more about what you can do with Mockito, please check out their documentation: https://javadoc.io/doc/org.mockito/mockito-core/latest/org/mockito/Mockito.html. It lists all the Mockito features and how to use them.

Join the discussion: follow me on Twitter and share your thoughts

This post is just the beginning. If you're interested in learning more, be sure to follow me on Twitter . And if you have any questions or ideas, don't hesitate to reach out via Twitter or send me an email. I'm always happy to connect and continue the conversation.