alexsmail alexsmail - 3 months ago 20
Java Question

Mockito, JUnit and Spring

I started to learn about Mockito only today. I wrote some simple test (with JUnit, see below), but I can't figure out how can I use mock object inside Spring's manages beans. What is best practise for working with Spring. How should I inject mocked dependency to my bean?

You can skip this till back to my question.

First of all, what I've learned.
This is very good article Mocks Aren't Stubs that explains the basics (Mock's checks behavior verification not state verification). Then there is good example here Mockito
Here Easier mocking with mockito we have explanation that Mockito's mock objects are both mock and stubs.

Here Mockito and here Matchers you can find more examples.

This test

@Test
public void testReal(){
List<String> mockedList = mock(List.class);
//stubbing
//when(mockedList.get(0)).thenReturn("first");

mockedList.get(anyInt());
OngoingStubbing<String> stub= when(null);
stub.thenReturn("first");

//String res = mockedList.get(0);
//System.out.println(res);

//you can also verify using argument matcher
//verify(mockedList).get(anyInt());

verify(mockedList);
mockedList.get(anyInt());
}


works just fine.

Back to my question. Here Injecting Mockito mocks into a Spring bean somebody tries to use Springs
ReflectionTestUtils.setField()
, but than here Spring Integration Tests, Creating Mock Objects we have recommendation to change Spring's context.

I didn't really understand last two links... Can somebody explain me what problem does Spring have with Mockito? What's wrong with this solution?

@InjectMocks
private MyTestObject testObject

@Mock
private MyDependentObject mockedObject

@Before
public void setup() {
MockitoAnnotations.initMocks(this);
}


http://stackoverflow.com/a/8742745/1137529

EDIT: I wasn't really clear. I will provide 3 examples of code to clarify my self:
Suppose, we have bean HelloWorld with method
printHello()
and bean HelloFacade with method
sayHello
that forward calls to HelloWorld's method
printHello()
.

First example is using Spring's context and without custom runner, using ReflectionTestUtils for dependency injection (DI):

public class Hello1Test {
private ApplicationContext ctx;

@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
this.ctx = new ClassPathXmlApplicationContext("META-INF/spring/ServicesImplContext.xml");
}



@Test
public void testHelloFacade() {
HelloFacade obj = (HelloFacade) ctx.getBean(HelloFacadeImpl.class);
HelloWorld mock = mock(HelloWorld.class);
doNothing().when(mock).printHello();

ReflectionTestUtils.setField(obj, "hello", mock);
obj.sayHello();

verify(mock, times(1)).printHello();
}

}


As @Noam pointed out thereis way to run it wihtout explicit call to
MockitoAnnotations.initMocks(this);
. I will also drop using of the Spring's context on this example.

@RunWith(MockitoJUnitRunner.class)
public class Hello1aTest {


@InjectMocks
private HelloFacade obj = new HelloFacadeImpl();

@Mock
private HelloWorld mock;


@Test
public void testHelloFacade() {
doNothing().when(mock).printHello();
obj.sayHello();
}

}


Another way to do this

public class Hello1aTest {

@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}


@InjectMocks
private HelloFacadeImpl obj;

@Mock
private HelloWorld mock;


@Test
public void testHelloFacade() {
doNothing().when(mock).printHello();
obj.sayHello();
}

}


Noth, that in preivious example we have to manually instaniate HelloFacadeImpl and assign it to HelloFacade, beacuse HelloFacade is interface. In the last example, we can just declare HelloFacadeImpl and Mokito will instantiate it for us. The drawback of this approach that now, unit-under-test is impl-class and not interface.

Answer

Honestly I am not sure if I really understand your question :P I will try to clarify as much as I can, from what I get from your original question:

First, in most case, you should NOT have any concern on Spring. You rarely need to have spring involved in writing your unit test. In normal case, you only need to instantiate the system under test (SUT, the target to be tested) in your unit test, and inject dependencies of SUT in the test too. The dependencies are usually a mock/stub.

Your original suggested way, and example 2, 3 is precisely doing what I am describing above.

In some rare case (like, integration tests, or some special unit tests), you need to create a Spring app context, and get your SUT from the app context. In such case, I believe you can:

1) Create your SUT in spring app ctx, get reference to it, and inject mocks to it

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("test-app-ctx.xml")
public class FooTest {

    @Autowired
    @InjectMocks
    TestTarget sut;

    @Mock
    Foo mockFoo;

    @Before
    /* Initialized mocks */
    public void setup() {
        MockitoAnnotations.initMocks(this);
    }

    @Test
    public void someTest() {
         // ....
    }
}

or

2) follow the way described in your link Spring Integration Tests, Creating Mock Objects. This approach is to create mocks in Spring's app context, and you can get the mock object from the app ctx to do your stubbing/verification:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("test-app-ctx.xml")
public class FooTest {

    @Autowired
    TestTarget sut;

    @Autowired
    Foo mockFoo;

    @Test
    public void someTest() {
         // ....
    }
}

Both ways should work. The main difference is the former case will have the dependencies injected after going through spring's lifecycle etc. (e.g. bean initialization), while the latter case is injected beforehands. For example, if your SUT implements spring's InitializingBean, and the initialization routine involves the dependencies, you will see the difference between these two approach. I believe there is no right or wrong for these 2 approaches, as long as you know what you are doing.

Just a supplement, @Mock, @Inject, MocktoJunitRunner etc are all unnecessary in using Mockito. They are just utilities to save you typing the Mockito.mock(Foo.class) and bunch of setter invocations.