Mockito Tutorial for Beginners (2026) – Step-by-Step Guide with Examples

Prerequisites for Learning Mockito
Deep Dive into Mockito Concepts
Step-by-Step Guide to Using Mockito
Full Example of Using Mockito in a Real-World Scenario
Common Mistakes to Avoid When Using Mockito
Mistake 1: Not Initializing the Mock Object
Mistake 2: Not Verifying the Mock Object
Production-Ready Tips for Using Mockito
Testing Strategies with Mockito
Key Takeaways from the Mockito Tutorial
Advanced Features of Mockito

Prerequisites for Learning Mockito

To learn Mockito, you should have a solid understanding of **Java** fundamentals, including classes, objects, and interfaces. You should also be familiar with **JUnit**, a popular testing framework for Java. Unit testing is a crucial concept in software development, and **JUnit** provides a robust framework for writing and running tests.

A key concept in unit testing is the idea of isolating dependencies, which is where **Mockito** comes in. Before diving into Mockito, make sure you have a good grasp of **JUnit** basics, such as writing test classes and methods, and using assertions to verify expected behavior. For more information on **JUnit**, you can visit our JUnit tutorial page.

To get started with Mockito, you should also understand the concept of **dependency injection**, which is a design pattern that allows components to be loosely coupled. This is important because Mockito relies on **dependency injection** to create mock objects.

Here is an example of a simple **JUnit** test class that demonstrates the concept of unit testing:

public class CalculatorTest {
 @Test
 public void testAdd() {
 // Create a Calculator object
 Calculator calculator = new Calculator();
 // Call the add method and store the result
 int result = calculator.add(2, 3);
 // Use an assertion to verify the expected result
 assertEquals(5, result); // Why: Verifying that the add method returns the correct result
 }
}

The expected output of this test would be:

OK (1 test)

This indicates that the test passed, and the `add` method returned the expected result. For further reading on **unit testing concepts**, you can visit our unit testing best practices page.

Deep Dive into Mockito Concepts

Mockito is a popular mocking framework for Java that allows developers to create and configure mock objects. A mock object is a simulated object that mimics the behavior of a real object in a controlled environment. This is useful for isolating dependencies and testing specific components of an application. The Mockito.mock() method is used to create a mock object.

Understanding stubbing is crucial in Mockito, as it allows developers to define the behavior of a mock object. Stubbing involves specifying the return values or exceptions that a mock object should throw when a particular method is invoked. The when() method is used to stub a mock object, and the thenReturn() method is used to specify the return value. For example, when(userService.getUser()).thenReturn(user) stubs the getUser() method of the userService mock object to return a user object.

Verification is another important concept in Mockito, as it allows developers to verify that a mock object was invoked correctly. The verify() method is used to verify that a mock object was invoked with the correct arguments. For further reading on Mockito advanced features, including verification modes and argument matchers, please refer to our previous article. Verification can be used to ensure that a mock object was invoked the correct number of times, or that it was invoked with the correct arguments.

The Mockito.verify() method can be used in conjunction with the times() method to specify the number of times a mock object should be invoked. For example, verify(userService, times(2)).getUser() verifies that the getUser() method of the userService mock object was invoked exactly twice. By mastering mock objects, stubbing, and verification, developers can write more effective unit tests using Mockito.

Step-by-Step Guide to Using Mockito

To get started with Mockito, you need to set it up in your project. This involves adding the Mockito dependency to your pom.xml file if you’re using Maven, or your build.gradle file if you’re using Gradle. For more information on setting up a Java project, visit our Java Project Setup guide.

Once you have Mockito set up, you can start creating mock objects. A mock object is a fake object that mimics the behavior of a real object. You can create a mock object using the mock() method provided by Mockito.
To write a unit test using Mockito, you need to create a test class that contains methods annotated with @Test.

Here’s an example of how to use Mockito to write a unit test:

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;

import static org.mockito.Mockito.when;
import static org.junit.Assert.assertEquals;

@RunWith(MockitoJUnitRunner.class)
public class MockitoExample {
 @Mock
 private Dependency dependency; // create a mock object for the dependency

 @Test
 public void testMethod() {
 // stub the mock object to return a specific value
 when(dependency.getData()).thenReturn("Mock Data"); // return "Mock Data" when getData() is called
 String result = new MyClass(dependency).getMethod(); // call the method that uses the mock object
 assertEquals("Mock Data", result); // verify that the result is as expected
 }
}

The expected output of this test will be:

No output, the test will pass if the result is "Mock Data"

For more information on unit testing and test-driven development, visit our Unit Testing Best Practices guide.

When writing unit tests with Mockito, it’s essential to understand the different types of mocks available, such as stubbing and verifying. You can learn more about these concepts in our Mockito Advanced Features article.

Full Example of Using Mockito in a Real-World Scenario

To demonstrate the use of Mockito in a real-world scenario, we will consider a complex Java class with dependencies. We will test the PaymentProcessor class, which depends on the PaymentGateway class. For a thorough understanding of dependency injection, please refer to our article on Dependency Injection in Java.

The PaymentProcessor class is responsible for processing payments, and it uses the PaymentGateway class to interact with the payment gateway. We will use Mockito to mock the PaymentGateway class and test the PaymentProcessor class in isolation.

public class PaymentProcessor {
 private PaymentGateway paymentGateway;

 public PaymentProcessor(PaymentGateway paymentGateway) {
 this.paymentGateway = paymentGateway;
 }

 public boolean processPayment(Payment payment) {
 // Check if the payment is valid
 if (payment.getAmount() <= 0) {
 return false;
 }
 // Use the payment gateway to process the payment
 return paymentGateway.chargeCard(payment);
 }
}

To test the PaymentProcessor class, we will create a test class that uses Mockito to mock the PaymentGateway class. We will then use the mocked PaymentGateway object to test the PaymentProcessor class.

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;

import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.when;

@RunWith(MockitoJUnitRunner.class)
public class PaymentProcessorTest {
 @Mock
 private PaymentGateway paymentGateway;

 @InjectMocks
 private PaymentProcessor paymentProcessor;

 @Test
 public void testProcessPayment() {
 // Create a payment object
 Payment payment = new Payment(10.0);
 // Mock the payment gateway to return true
 when(paymentGateway.chargeCard(payment)).thenReturn(true);
 // Process the payment
 boolean result = paymentProcessor.processPayment(payment);
 // Verify the result
 assertTrue(result);
 }
}

The expected output of the test is:

true

For further reading on unit testing and integration testing, please refer to our article on Unit Testing and Integration Testing in Java.

Common Mistakes to Avoid When Using Mockito

When writing unit tests with Mockito, there are several pitfalls to watch out for. One of the most common mistakes is not properly initializing the mock object.
For more information on setting up Mockito in your project, see our Mockito setup guide.

Mistake 1: Not Initializing the Mock Object

The following code demonstrates the incorrect way to initialize a mock object:

public class UserServiceTest {
 @Test
 public void testGetUser() {
 // WRONG
 UserService userService = new UserService();
 UserDAO userDAO = new UserDAO(); // not initialized as a mock
 userService.setUserDAO(userDAO);
 // ...
 }
}

This will result in a No Such Method Exception because the UserDAO is not a mock object.
The correct way to initialize the mock object is by using the @Mock annotation and the MockitoAnnotations.initMocks(this) method:

public class UserServiceTest {
 @Mock
 private UserDAO userDAO;
 private UserService userService;
 
 @Before
 public void setup() {
 MockitoAnnotations.initMocks(this); // initialize the mock
 userService = new UserService();
 userService.setUserDAO(userDAO);
 }
 
 @Test
 public void testGetUser() {
 // ...
 }
}

The expected output will be a successful test run.

Mistake 2: Not Verifying the Mock Object

Another common mistake is not verifying the mock object after the test is run.
For more information on verifying mock objects, see our guide on Mockito verification.
The following code demonstrates the incorrect way to verify the mock object:

public class UserServiceTest {
 @Mock
 private UserDAO userDAO;
 private UserService userService;
 
 @Before
 public void setup() {
 MockitoAnnotations.initMocks(this);
 userService = new UserService();
 userService.setUserDAO(userDAO);
 }
 
 @Test
 public void testGetUser() {
 // WRONG
 userService.getUser(1);
 // no verification
 }
}

This will result in an Unverified Mock warning because the mock object is not verified.
The correct way to verify the mock object is by using the verify method:

public class UserServiceTest {
 @Mock
 private UserDAO userDAO;
 private UserService userService;
 
 @Before
 public void setup() {
 MockitoAnnotations.initMocks(this);
 userService = new UserService();
 userService.setUserDAO(userDAO);
 }
 
 @Test
 public void testGetUser() {
 userService.getUser(1);
 // verify that the getUser method was called with the correct argument
 verify(userDAO, times(1)).getUser(1); // verify the mock
 }
}

The expected output will be:

Mock verified successfully

For further reading on best practices for using Mockito, see our guide on Mockito best practices.

Production-Ready Tips for Using Mockito

When using Mockito in large-scale Java applications, it is essential to follow best practices to ensure efficient and effective testing. One of the key aspects of Mockito is its ability to create mock objects, which can be used to isolate dependencies and test specific components of the application. The Mockito.mock() method is used to create mock objects, and it can be used in conjunction with the @Mock annotation to simplify the process.

Production tip: Use the MockitoAnnotations.initMocks() method to initialize mock objects annotated with @Mock to ensure that they are properly set up before use.

To get the most out of Mockito, it is crucial to understand the different types of mock objects that can be created, including stubbed and spy objects. For more information on Mockito basics, including how to create and use mock objects, see our Mockito Basics tutorial.

Production tip: Use stubbed objects to define specific behavior for mock objects, and use spy objects to wrap existing objects and stub out specific methods.

When using Mockito to test complex applications, it is essential to keep the tests organized and easy to maintain. This can be achieved by using test-driven development principles and keeping each test focused on a specific piece of functionality. For more information on test-driven development, see our Test-Driven Development tutorial.

Production tip: Use Mockito to test specific components of the application in isolation, and use integration testing to test how the different components work together.

Testing Strategies with Mockito

When using Mockito to test different scenarios and edge cases, it’s essential to understand the various testing strategies available. One common approach is to use mock objects to isolate dependencies and focus on the unit being tested. This can be achieved by using the Mockito.mock() method to create a mock object.

To demonstrate this, let’s consider an example where we have a UserService class that depends on a UserRepository interface. We can use Mockito to mock the UserRepository and test the UserService in isolation.
For more information on Mockito basics, you can refer to our previous article.

public class UserServiceTest {
 @Test
 public void testGetUser() {
 // Create a mock UserRepository
 UserRepository userRepository = Mockito.mock(UserRepository.class);
 
 // Define the behavior of the mock object
 Mockito.when(userRepository.findById(1)).thenReturn(new User(1, "John Doe"));
 
 // Create a UserService instance with the mock UserRepository
 UserService userService = new UserService(userRepository);
 
 // Call the method being tested
 User user = userService.getUser(1);
 
 // Verify the result
 Assert.assertEquals("John Doe", user.getName());
 }
}

The expected output of this test would be:

User [id=1, name=John Doe]

By using Mockito to mock the UserRepository, we can test the UserService in isolation and ensure that it behaves as expected. This approach can be applied to various scenarios and edge cases, making it a powerful tool for unit testing. For further reading on unit testing best practices, you can refer to our article on the subject.

Key Takeaways from the Mockito Tutorial

The Mockito framework is a powerful tool for unit testing Java applications, allowing developers to isolate dependencies and focus on testing specific components. By using Mockito.mock() to create mock objects, developers can decouple their code from external dependencies and ensure reliable test results. This approach enables the creation of more efficient and effective tests. The Mockito API provides a range of features for customizing mock behavior, including when() and verify() methods.

Effective use of Mockito requires a solid understanding of dependency injection and test-driven development principles. Developers should prioritize loose coupling and high cohesion in their design to maximize the benefits of Mockito. By doing so, they can write more focused, efficient tests that target specific components or behaviors. For more information on test-driven development, see our article on Test-Driven Development with JUnit.

When applying Mockito to real-world projects, developers should be mindful of mocking best practices, such as avoiding over-mocking and using MockitoAnnotations.initMocks() to simplify test setup. By following these guidelines and leveraging Mockito’s features, developers can create robust, maintainable tests that improve overall code quality. The Mockito.verify() method is particularly useful for ensuring that mock objects are interacted with as expected.

To get the most out of Mockito, developers should also understand how to use argument matchers and answer objects to customize mock behavior. By using ArgumentMatchers and Answer objects, developers can create more sophisticated tests that account for complex scenarios and edge cases. With practice and experience, developers can master Mockito and integrate it into their continuous integration pipelines to ensure consistent, high-quality test results.

Advanced Features of Mockito

Mockito provides several advanced features that can be used to write more complex and robust unit tests. One of these features is argument matchers, which allow you to specify the expected arguments of a method call. For example, you can use the any() method to match any argument, or the eq() method to match a specific argument. This can be useful when you want to test a method that takes multiple arguments.

Another advanced feature of Mockito is callbacks, which allow you to specify a block of code that should be executed when a method is called. This can be useful when you want to test a method that has a side effect, such as writing to a database or sending a network request. You can use the thenAnswer() method to specify a callback that should be executed when a method is called. For more information on using callbacks, see our article on Mockito best practices.

Mockito also provides several other advanced features, including verification modes and stubbing. Verification modes allow you to specify how Mockito should verify that a method was called, such as times() or never(). Stubbing allows you to specify a return value for a method, such as when() or given(). These features can be used to write more complex and robust unit tests.

To use these advanced features effectively, you need to have a good understanding of how Mockito works and how to use its API. You can learn more about the basics of Mockito in our article on Mockito tutorial for beginners. With practice and experience, you can become proficient in using Mockito’s advanced features to write robust and effective unit tests. By mastering these features, you can take your unit testing to the next level and ensure that your code is reliable and maintainable.