How to mock constructor with PowerMockito

Mocking Constructors with PowerMockito

PowerMockito is a powerful Java mocking library that extends Mockito, providing additional capabilities like mocking static methods, final classes, and constructors. This article will guide you on how to mock constructors using PowerMockito.

Why Mock Constructors?

Mocking constructors can be beneficial in several scenarios:

• Testing complex dependencies: When a class has complex dependencies injected through the constructor, mocking the constructor allows you to isolate the class under test and control the dependencies’ behavior.
• Testing private constructors: PowerMockito enables mocking private constructors, which is not possible with standard Mockito.
• Simulating specific object creation: You can mock constructors to create instances with specific internal states for testing purposes.

Prerequisites

• Java Development Kit (JDK)
• Maven or Gradle build tool
• PowerMockito library

Steps to Mock Constructors

1. Add PowerMockito Dependency

Add the PowerMockito dependency to your project’s build file (Maven or Gradle). For Maven:

<dependency>
  <groupId>org.powermock</groupId>
  <artifactId>powermock-module-junit4</artifactId>
  <version>2.0.9</version>
  <scope>test</scope>
</dependency>
<dependency>
  <groupId>org.powermock</groupId>
  <artifactId>powermock-api-mockito2</artifactId>
  <version>2.0.9</version>
  <scope>test</scope>
</dependency>

2. Prepare Test Class

Create a test class that extends PowerMockTestCase.

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

@RunWith(PowerMockRunner.class)
@PrepareForTest( MyClass.class )
public class MyClassTest {

   @Test
   public void testConstructorMocking() throws Exception {
       // Mock the constructor
       MyClass mockMyClass = PowerMockito.mock(MyClass.class);

       // Set up expectations for constructor arguments
       PowerMockito.whenNew(MyClass.class).withArguments("arg1", 10).thenReturn(mockMyClass);

       // Create an instance using the mocked constructor
       MyClass instance = new MyClass("arg1", 10);

       // Verify the constructor call
       Mockito.verify(mockMyClass, Mockito.times(1));

       // ... perform further assertions
   }
}

3. Mock the Constructor

Use PowerMockito.mock(Class.class) to create a mock instance of the class whose constructor you want to mock.

MyClass mockMyClass = PowerMockito.mock(MyClass.class);

4. Set Up Expectations

Use PowerMockito.whenNew(Class.class).withArguments(...) to define expectations for the constructor arguments. The thenReturn() method specifies the mock instance to be returned when the constructor is called with the matching arguments.

PowerMockito.whenNew(MyClass.class).withArguments("arg1", 10).thenReturn(mockMyClass);

5. Create an Instance

Create an instance of the class using the mocked constructor.

MyClass instance = new MyClass("arg1", 10);

6. Verify Constructor Call

Use Mockito.verify() to ensure the constructor was called with the expected arguments and returned the mocked instance.

Mockito.verify(mockMyClass, Mockito.times(1));

Example

Class to be Tested

public class MyClass {

   private String name;
   private int age;

   public MyClass(String name, int age) {
       this.name = name;
       this.age = age;
   }

   public String getName() {
       return name;
   }

   public int getAge() {
       return age;
   }
}

Test Class

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

@RunWith(PowerMockRunner.class)
@PrepareForTest( MyClass.class )
public class MyClassTest {

   @Test
   public void testConstructorMocking() throws Exception {
       // Mock the constructor
       MyClass mockMyClass = PowerMockito.mock(MyClass.class);

       // Set up expectations for constructor arguments
       PowerMockito.whenNew(MyClass.class).withArguments("John", 30).thenReturn(mockMyClass);

       // Create an instance using the mocked constructor
       MyClass instance = new MyClass("John", 30);

       // Verify the constructor call
       Mockito.verify(mockMyClass, Mockito.times(1));

       // Assert the instance's state
       assert instance.getName().equals("John");
       assert instance.getAge() == 30;
   }
}

Comparison

Conclusion

Mocking constructors using PowerMockito allows you to control the behavior of your classes’ dependencies, test private constructors, and simulate specific object creation. Remember to include the PowerMockito dependency in your project and use the appropriate annotations for test preparation. By mastering this technique, you can enhance your unit tests and ensure comprehensive code coverage.