Mockito JUnit and Spring

Question

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 managed beans  What is best practices 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 a good example here Mockito  and here Easier mocking with mockito  We have explanation that Mockito s mock objects are both mock and stub    Here Mockito and here Matchers  you can find more examples    This test   Test public void testReal        List lt String gt  mockedList   mock List class          stubbing        when mockedList get 0   thenReturn  first         mockedList get anyInt         OngoingStubbing lt String gt  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 then 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 to 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       https   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

User · Answer

Your question seems to be asking about which of the three examples you have given is the preferred approach.

Example 1 using the Reflection TestUtils is not a good approach for Unit testing. You really don't want to be loading the spring context at all for a unit test. Just mock and inject what is required as shown by your other examples.

You do want to load the spring context if you want to do some Integration testing, however I would prefer using @RunWith(SpringJUnit4ClassRunner.class) to perform the loading of the context along with @Autowired if you need access to its' beans explicitly.

Example 2 is a valid approach and the use of @RunWith(MockitoJUnitRunner.class) will remove the need to specify a @Before method and an explicit call to MockitoAnnotations.initMocks(this);

Example 3 is another valid approach that doesn't use @RunWith(...). You haven't instantiated your class under test HelloFacadeImpl explicitly, but you could have done the same with Example 2.

My suggestion is to use Example 2 for your unit testing as it reduces the code clutter. You can fall back to the more verbose configuration if and when you're forced to do so.

User · Answer

Here s my short summary    If you want to write a unit test  don t use a Spring applicationContext because you don t want any real dependencies injected in the class you are unit testing  Instead use mocks  either with the  RunWith MockitoJUnitRunner class  annotation on top of the class  or with MockitoAnnotations initMocks this  in the  Before method   If you want to write an integration test  use    RunWith SpringJUnit4ClassRunner class   ContextConfiguration  yourTestApplicationContext xml     To set up your application context with an in-memory database for example  Normally you don t use mocks in integration tests  but you could do it by using the MockitoAnnotations initMocks this  approach described above

User · 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

User · Answer

The introduction of some new testing facilities in Spring 4 2 RC1 lets one write Spring integration tests that don t rely on the SpringJUnit4ClassRunner  Check out this part of the documentation   In your case you could write your Spring integration test and still use mocks like this    RunWith MockitoJUnitRunner class   ContextConfiguration  test-app-ctx xml   public class FooTest         ClassRule     public static final SpringClassRule SPRING CLASS RULE   new SpringClassRule          Rule     public final SpringMethodRule springMethodRule   new SpringMethodRule          Autowired      InjectMocks     TestTarget sut        Mock     Foo mockFoo        Test     public void someTest

User · Answer

If you would migrate your project to Spring Boot 1 4  you could use new annotation  MockBean for faking MyDependentObject  With that feature you could remove Mockito s  Mock and  InjectMocks annotations from your test

User · Answer

You don t really need the MockitoAnnotations initMocks this   if you re using mockito 1 9   or newer   - all you need is this    InjectMocks private MyTestObject testObject    Mock private MyDependentObject mockedObject    The  InjectMocks annotation will inject all your mocks to the MyTestObject object

User · Answer

The difference in whether you have to instantiate your  InjectMocks annotated field is in the version of Mockito  not in whether you use the MockitoJunitRunner or MockitoAnnotations initMocks   In 1 9  which will also handle some constructor injection of your  Mock fields  it will do the instantiation for you   In earlier versions  you have to instantiate it yourself   This is how I do unit testing of my Spring beans   There is no problem   People run into confusion when they want to use Spring configuration files to actually do the injection of the mocks  which is crossing up the point of unit tests and integration tests   And of course the unit under test is an Impl   You need to test a real concrete thing  right  Even if you declared it as an interface you would have to instantiate the real thing to test it   Now  you could get into spies  which are stub mock wrappers around real objects  but that should be for corner cases

[java] Mockito, JUnit and Spring

Examples related to java

Examples related to spring

Examples related to unit-testing

Examples related to mockito