Mockito: how to test that a constructor was called?

Question

I am using Mockito to test methods within my Java application.

How can I test that a constructor was called once?

I am trying to do a verification similar to this:

verify(myClass, times(1)).doSomething(anotherObject);

But I can't verify that the constructor was called as it doesn't have a method similar to e.g. doSomething().

Answer 1

You can do it with Mockito and PowerMockito.

Say you have ClassUnderTest with a constructor

public class ClassUnderTest {
    String name;
    boolean condition;

    public ClassUnderTest(String name, boolean condition) {
       this.name = name;
       this.condition = condition;
       init();
    }

    ...
}

And another class that calls that constructor

public class MyClass {

    public MyClass() { } 

    public void createCUTInstance() {
       // ...
       ClassUnderTest cut = new ClassUnderTest("abc", true);
       // ...
    }

    ...
}

At the Test class we could...

(1) use PowerMockRunner and cite both target classes above in the PrepareForTest annotation:

@RunWith(PowerMockRunner.class)
@PrepareForTest({ ClassUnderTest.class, MyClass.class })
public class TestClass {

(2) intercept the constructor to return a mock object:

@Before
public void setup() {
    ClassUnderTest cutMock = Mockito.mock(ClassUnderTest.class);
    PowerMockito.whenNew(ClassUnderTest.class)
                .withArguments(Matchers.anyString(), Matchers.anyBoolean())
                .thenReturn(cutMock);
}

(3) validate the constructor call:

@Test
public void testMethod() {
    // prepare
    MyClasss myClass = new MyClass();

    // execute
    myClass.createCUTInstance();

    // checks if the constructor has been called once and with the expected argument values:
    String name = "abc";
    String condition = true;
    PowerMockito.verifyNew(ClassUnderTest.class).withArguments(name, condition);
}

Answer 2

This can't be done with Mockito, since the object being created is not a mocked object. This also means that you won't be able to verify anything on that new object either.

I've worked around this scenario in the past by using a Factory to create the object rather than newing it up. You're then able to mock the Factory to return the object required for your test.

Whether you're happy changing your design to suit your tests is up to you!

Answer 3

With Mockito can do something

try (MockedConstruction<MyClass> myclass = Mockito.mockConstruction(
        MyClass.class)) {
    ........
    Assert.assertEquals(1, myClass.constructed().size());
}

Answer 4

verify() method waits for mocked object(already created object). And constructor can not be called on created object.

Answer 5

This is not possible with Mockito and sounds like a bad design.

You can use a factory and pass it to the object under test. After that you can easily mock the factory and verify that its create method was called.

By directly creating objects in your code you are making a hard dependency to concrete implementations, which makes the code harder and sometimes impossible to unit test. This is addressed with Dependency Injection (DI) and Inversion of Control (IoC).

Answer 6

A constructor won't return an object if it failed... and if it fails the program will most likely crash.

Tough i suppose this would do it:

Object obj = null;

obj = new Object();

if (obj == null) {
  //... Didn't Work
} else {
  //... Worked
}

Answer 7

you will not be able to mock the constructor with mockito, but using powermockito you should be able to and then verify it. Setup would be something like this

public class MyClass{

   public MyClass(String name){}

   public void doSomethingUseFul(){
      //.......
   }

}

public class Helper {

   public void goHelp(){
       new MyClass("apple").doSomethingUseFul();
   } 

}

//Mock

    @RunWith(PowerMockRunner.class)
    @PrepareForTest(MyClass.class)
    public class MockMyClass {
    @InjectMocks
    private Helper helper;

        @Test
        public void testDoSomethingUseFul() {
             MyClass  c = mock(MyClass.class); 
             doNothing().when(c).doSomethingUseFul();
             PowerMockito.whenNew(MyClass. class).withArguments(anyString()).thenReturn(c);
             helper.goHelp(); 
             verifyNew(MyClass.class).withArguments(anyString())


        }
    }

Answer 8

We can test using Mockito with

verify(MyClass.class,times(1)).newInstance();