Mocking two objects of the same type with Mockito

Question

I\'m writing unit tests using Mockito and I\'m having problems mocking the injected classes. The problem is that two of the injected classes are the same type, and only diff

Answer 1

I have tried mocking two objects with the same type with Mockito 1.9.5 using JUnit and it works.

See: http://static.javadoc.io/org.mockito/mockito-core/1.9.5/org/mockito/InjectMocks.html

Relevant type info from the doc:

"Field injection; mocks will first be resolved by type, then, if there is several property of the same type, by the match of the field name and the mock name."

And this one which seems to say you should make the mock name match the field name for all your mocks when you have two of the same type:

"Note 1: If you have fields with the same type (or same erasure), it's better to name all @Mock annotated fields with the matching fields, otherwise Mockito might get confused and injection won't happen."

Perhaps this latter one is biting you?

Answer 2

Just confirmed what Splonk pointed out and it works that way in Mockito 1.9.5, as soon as I removed one of the mocked classes, it failed.

So, in your case, make sure you have both of the mocked classes with the same name as in the class in your test:

@Mock
private SomeClass someClassA;
@Mock
private SomeClass someClassB;

Answer 3

If you don't use annotation, you get something like

public class MyClass {
    private MyDependency myDependency;

    public void setMyDependency(MyDependency myDependency){
        this.myDependency = myDependency;
    }
}

and

import org.junit.Before;
import org.junit.Test;

import static org.mockito.Mockito.*;

public class MyTest {

    private MyClass myClass;
    private MyDependency myDependency;

    @Before
    public void setUp(){
        myClass = new MyClass();
        myDependency = mock(MyDependency.class);
        myClass.setMyDependency(myDependency);
    }

    @Test
    public void test(){
        // Given

        // When

        // Then
    }
}

You can do just the same if your object has its dependencies specified via constructor rather than via setter. I guess your dependency injection framework can annotate the setters the same way you annotate private fields, but now your tests don't rely on any dependency injection framework.