Mockito: Mocking Private Methods in Java

Mockito is a popular Java testing framework used for unit testing. It helps developers in creating an isolated testing environment where they can validate the functionality of their application, without affecting other parts of the code. However, Mockito has some limitations when it comes to testing private methods. Since private methods can only be accessed by the class that defines them, there is no direct way to test them. In this blog post, we’ll explore some workarounds for this problem using Mockito.

Why testing private methods is difficult

Testing private methods can be difficult for several reasons. First, private methods are only accessible within the class, so testing them requires either reflection or exposing the method as public. Both of these options can be risky and lead to poor maintainability. Second, private methods are implementation details and not part of the public API, so testing them can lead to test duplication and brittle tests. Finally, private methods are often tightly coupled to other private methods or instance variables, making it difficult to isolate them for testing. All of these factors can make testing private methods a challenging and potentially detrimental part of the testing process.

Understanding Mockito and mocking private methods

Mockito is a popular testing framework in Java that allows developers to create mock objects for unit testing. A mock object is a fake object that imitates a real object but only contains the methods used for testing. With Mockito, developers can create mock objects to test methods without calling actual methods.

However, mocking private methods in Mockito is not possible as it is designed for testing public methods only. But there are workarounds to mock private methods in Mockito. One way is to make the private method protected or package-protected, and then create a subclass of the class containing the private methods to override the method to public. Then, the method can be mocked using Mockito.

Another way to mock private methods in Mockito is to use PowerMockito, an extension of Mockito. PowerMockito is designed to mock private, final, static methods, and constructors in Java. With PowerMockito, developers can mock private methods by using the spy() method to create a partial mock of the object and then calling the method using reflection.

Maven dependencies for Mockito

To use Mockito with Maven, the following dependency needs to be added to the pom.xml file:

This dependency can be added within the dependencies tag in the pom.xml file. Ensure that your build system is configured to use Maven Central repository as the source for this dependency.

Maven dependencies for Mockito can easily be declared by replacing the ‘+’, after the version, to a desired Mockito version. Using the latest version of Mockito will ensure that you have the most up-to-date features for testing private methods.

Mockito example

Mockito is a popular Java testing framework that allows developers to mock objects and methods to create unit tests in Java. Mockito provides a range of methods that can be used to mock private methods in Java, however, there are some limitations to keep in mind when using Mockito for private method mocking.

One way to mock a private method in Java using Mockito is by changing the accessibility of the method to protected. By changing the accessibility of the method to protected, it is possible to create a subclass that can be used to access the method and provide the mocked behavior. Here’s an example code snippet that demonstrates how to use Mockito to mock a private method by changing accessibility:

public class MyClass {

 private String myPrivateMethod(String input) {
  // code here
 }

 public String doSomething() {
  String result = myPrivateMethod("test");
  // code here
  return result;
 }
}

public class MyClassTest {

 @Test
 public void testPrivateMethod() throws Exception {
  MyClass mc = Mockito.mock(MyClass.class);
  Mockito.when(mc, Mockito.method(MyClass.class, 
                "myPrivateMethod", String.class)).withArguments("test").thenReturn("mocked");
  Assert.assertEquals("mocked", mc.doSomething());
 }
}

As shown in the example above, it is possible to mock a private method in Java using Mockito by changing the method accessibility to protected. However, it is important to keep in mind that this approach can introduce some coupling between the test and implementation code, which might make the tests more fragile to implementation changes.

Another way to mock private methods using Mockito is by using reflection, although this approach is generally not recommended due to its complexity and potential side effects. By using reflection, it is possible to bypass the accessibility checks of the Java language and directly access the method through its reflection API. Here’s an example code snippet that demonstrates how to use Mockito to mock a private method using reflection:

public class MyClass {

 private String myPrivateMethod(String input) {
  // code here
 }

 public String doSomething() {
  String result = myPrivateMethod("test");
  // code here
  return result;
 }
}

public class MyClassTest {

 @Test
 public void testPrivateMethod() throws Exception {
  MyClass mc = Mockito.mock(MyClass.class);
  Method method = MyClass.class.getDeclaredMethod("myPrivateMethod", String.class);
  method.setAccessible(true);
  Mockito.when(method.invoke(mc, "test")).thenReturn("mocked"); 
  Assert.assertEquals("mocked", mc.doSomething());
 }
}

In conclusion, Mockito provides a range of methods that can be used to mock private methods in Java, although using reflection should be avoided due to its complexities and potential side effects. While it is possible to mock private methods using Mockito, it is generally not recommended as it can introduce coupling between the test and implementation code, which can make the tests more fragile to implementation changes.

How to mock method with no arguments but with return value

When it comes to mocking private methods that return a value without any arguments, using the Mockito framework requires a few steps. First, declare a spy object with the help of the Mockito.spy method. This method allows testers to create a new instance of the object they are testing. Next, use the when() method to mock the private method in question. This method takes the private method as a parameter and returns the expected output value. For example, if the private method is named “isValidUser()” and returns a boolean value of “true”, the code snippet using Mockito would look like this:

TestClass sut = new TestClass();
TestClass spied = Mockito.spy(sut);
Mockito.when(spied, "isValidUser").thenReturn(true);

Here, “TestClass” is an example class and “sut” is a new instance of this class. Also, “spied” is a spy object created from “sut”. Finally, “isValidUser” is the private method being mocked and its expected output value is “true”.

By following these steps, testers can now mock private methods that return values without arguments using the Mockito framework.

How to mock method with argument and return value

Mocking a private method that takes an argument and returns a value with Mockito can be done by changing the access level of the method to protected or package-private. Once done, the method can be tested using the spy and mocked object method.

First, create a spy object of the class under test. Then, use the doReturn() method to return the desired value when the method is called. Pass the argument value inside the parentheses. Finally, call the method with the argument and assert that it returns the expected value.

For example, suppose we have a private method called ‘calculate’ inside a class called ‘Calculator.’ The method calculates the sum of two integers and returns its value. We want to mock this method for a Unit Test. We can do it by changing the access level of the method to protected or package-private like:

Then create a spy object of the class ‘Calculator’ and use the doReturn () method to mock the ‘calculate’ method. Pass the argument values inside the parentheses like:

Now, call the method with the argument like:

Finally, assert that it returns the expected value:

By following these simple steps, you can mock private methods that take arguments and return values using Mockito.

Verification of invocation of a method

Mockito provides us with a way to verify whether a private method has been called or not during testing. However, Mockito does not allow us to directly mock or stub private methods. As a workaround, we can use the ‘spy’ and ‘doCallRealMethod’ methods of Mockito to verify the invocation of private methods. Here’s how:

1. Create a spy object of the class that contains the private method.
2. Call the method that triggers the private method.
3. Use ‘doCallRealMethod’ to call the private method.
4. Verify that the private method was called using ‘verify’.

Let’s look at an example:

Example:

// The class that contains the private method
public class MyClass {
  private void myPrivateMethod() {
    // Some implementation
  }
  
  public void myPublicMethod() {
    // Some implementation
    myPrivateMethod();
    // Some implementation
  }
}

// The test case
@Test
public void testMyPublicMethod() {
  MyClass myObject = Mockito.spy(new MyClass());
  
  myObject.myPublicMethod();
  
  Mockito.doCallRealMethod().when(myObject).myPrivateMethod();
  
  Mockito.verify(myObject).myPrivateMethod();
}

In this example, we create a spy object of the ‘MyClass’ and call its ‘myPublicMethod’. Then, we use ‘doCallRealMethod’ to call the private method ‘myPrivateMethod’. Finally, we verify that the private method was called using ‘verify’.

By using this technique, we can test private methods without exposing them to the public interface. This also helps in keeping the test cases separate from the implementation details of the class.

A word of caution

When it comes to mocking private methods, it’s important to note that it can sometimes indicate a poorly designed codebase. Testing private methods can increase test duplication and may not provide enough test coverage for the public interface, which is how the client will call and use the class’s methods. Additionally, Mockito does not directly support mocking private and static methods, which means that you’ll need to refactor your code to change the access to protected or package and avoid using static/final methods. It’s important to weigh the potential benefits and drawbacks of mocking private methods before proceeding.

Conclusion

Mockito is a powerful Java testing framework that allows for efficient and effective testing of code. While it does not directly support mocking of private and static methods, it is important to consider re-evaluating the design of the code if this is necessary. In order to test private methods, one strategy is to refactor the code to change the access to protected or package, and then avoid static and final methods. Implementing Mockito in testing practices can lead to cleaner and easier-to-understand tests, allowing for more effective debugging and troubleshooting.

For those looking to optimize their testing practices, it is highly recommended to declare a dependency on “mockito-core” library using your preferred build system, as it provides an easy and efficient way to mock objects in your tests. With a focus on creating engaging and easy-to-understand testing practices, incorporating Mockito can lead to long-term successes in ensuring operational efficiency and accuracy.

References

For readers who are interested in exploring and learning more about Mockito and testing private methods, the following references are highly recommended:

• Baeldung Mockito Tutorial
• InfoQ Mockito Best Practices
• Vogella Mockito Tutorial

These resources provide comprehensive guides on how to use Mockito to test Java applications, including private methods. They offer step-by-step instructions, best practices, and examples that are easy to follow and implement. Additionally, they cover advanced topics such as listening invocations, matchers, argument captors, and more. By utilizing these resources, readers can gain a deeper understanding of Mockito and how to effectively write unit tests for their Java code.