Injecting Mockito mocks into a Spring bean

Question

I would like to inject a Mockito mock object into a Spring  3   bean for the purposes of unit testing with JUnit  My bean dependencies are currently injected by using the  Autowired annotation on private member fields   I have considered using ReflectionTestUtils setField but the bean instance that I wish to inject is actually a proxy and hence does not declare the private member fields of the target class  I do not wish to create a public setter to the dependency as I will then be modifying my interface purely for the purposes of testing   I have followed some advice given by the Spring community but the mock does not get created and the auto-wiring fails    lt bean id  dao  class  org mockito Mockito  factory-method  mock  gt       lt constructor-arg value  com package Dao    gt   lt  bean gt    The error I currently encounter is as follows       Caused by  org   NoSuchBeanDefinitionException      No matching bean of type  com package Dao  found for dependency      expected at least 1 bean which qualifies as autowire candidate for this dependency      Dependency annotations             org   Autowired required true            org   Qualifier value dao        at org   DefaultListableBeanFactory raiseNoSuchBeanDefinitionException D   y java 901  at org   DefaultListableBeanFactory doResolveDependency D   y java 770    If I set the constructor-arg value to something invalid no error occurs when starting the application context

User · Answer

Update  There are now better  cleaner solutions to this problem  Please consider the other answers first   I eventually found an answer to this by ronen on his blog  The problem I was having is due to the method Mockito mock Class c  declaring a return type of Object  Consequently Spring is unable to infer the bean type from the factory method return type   Ronen s solution is to create a FactoryBean implementation that returns mocks  The FactoryBean interface allows Spring to query the type of objects created by the factory bean   My mocked bean definition now looks like    lt bean id  mockDaoFactory  name  dao  class  com package test MocksFactory  gt       lt property name  type  value  com package Dao    gt   lt  bean gt

User · Answer

Since 1 8 3 Mockito has  InjectMocks - this is incredibly useful  My JUnit tests are  RunWith the MockitoJUnitRunner and I build  Mock objects that satisfy all the dependencies for the class being tested  which are all injected when the private member is annotated with  InjectMocks   I  RunWith the SpringJUnit4Runner for integration tests only now   I will note that it does not seem to be able to inject List lt T gt  in the same manner as Spring  It looks only for a Mock object that satisfies the List  and will not inject a list of Mock objects  The workaround for me was to use a  Spy against a manually instantiated list  and manually  add the mock object s  to that list for unit testing  Maybe that was intentional  because it certainly forced me to pay close attention to what was being mocked together

User · Answer

Given    Service public class MyService        Autowired     private MyDAO myDAO          etc     You can have the class that is being tested loaded via autowiring  mock the dependency with Mockito  and then use Spring s ReflectionTestUtils to inject the mock into the class being tested    ContextConfiguration classes     MvcConfiguration class     RunWith SpringJUnit4ClassRunner class  public class MyServiceTest        Autowired     private MyService myService       private MyDAO myDAOMock        Before     public void before             myDAOMock   Mockito mock MyDAO class           ReflectionTestUtils setField myService   myDAO   myDAOMock                 etc     Please note that before Spring 4 3 1  this method won t work with services behind a proxy  annotated with  Transactional  or Cacheable  for example   This has been fixed by SPR-14050   For earlier versions  a solution is to unwrap the proxy  as described there  Transactional annotation avoids services being mocked  which is what ReflectionTestUtils setField does by default now

User · Answer

The best way is    lt bean id  dao  class  org mockito Mockito  factory-method  mock  gt        lt constructor-arg value  com package Dao    gt    lt  bean gt     Update In the context file this mock must be listed before any autowired field depending on it is declared

User · Answer

Below code works with autowiring - it is not the shortest version but useful when it should work only with standard spring mockito jars    lt bean id  dao  class  org springframework aop framework ProxyFactoryBean  gt      lt property name  target  gt   lt bean class  org mockito Mockito  factory-method  mock  gt   lt constructor-arg value  com package Dao    gt   lt  bean gt   lt  property gt      lt property name  proxyInterfaces  gt   lt value gt com package Dao lt  value gt   lt  property gt   lt  bean gt

User · Answer

Update - new answer here  https   stackoverflow com a 19454282 411229   This answer only applies to those on Spring versions before 3 2   I ve looked for a while for a more definitive solution to this   This blog post seems to cover all my needs and doesn t rely on ordering of bean declarations   All credit to Mattias Severson   http   www jayway com 2011 11 30 spring-integration-tests-part-i-creating-mock-objects   Basically  implement a FactoryBean  package com jayway springmock   import org mockito Mockito  import org springframework beans factory FactoryBean          A   link FactoryBean  for creating mocked beans based on Mockito so that they     can be   link  Autowired  into Spring test configurations         author Mattias Severson  Jayway        see FactoryBean     see org mockito Mockito     public class MockitoFactoryBean lt T gt  implements FactoryBean lt T gt         private Class lt T gt  classToBeMocked                  Creates a Mockito mock instance of the provided class          param classToBeMocked The class to be mocked              public MockitoFactoryBean Class lt T gt  classToBeMocked            this classToBeMocked   classToBeMocked              Override     public T getObject   throws Exception           return Mockito mock classToBeMocked               Override     public Class lt   gt  getObjectType             return classToBeMocked              Override     public boolean isSingleton             return true            Next update your spring config with the following    lt beans    gt       lt context component-scan base-package  com jayway example   gt        lt bean id  someDependencyMock  class  com jayway springmock MockitoFactoryBean  gt           lt constructor-arg name  classToBeMocked  value  com jayway example SomeDependency    gt       lt  bean gt   lt  beans gt

User · Answer

I have a very simple solution using Spring Java Config and Mockito    Configuration public class TestConfig         Mock BeanA beanA       Mock BeanB beanB       public TestConfig             MockitoAnnotations initMocks this     This is a key              You basically generate getters and add  Bean annotation everywhere      Bean     public BeanA getBeanA             return beanA              Bean     public BeanB getBeanB             return beanB

User · Answer

Today I found out that a spring context where I declared a  before the Mockito  beans  was failing to load   After moving the  AFTER the mocks  the app context was loaded successfully   Take care

User · Answer

Posting a few examples based on the above approaches  With Spring    ContextConfiguration locations      classpath context xml      RunWith SpringJUnit4ClassRunner class  public class TestServiceTest        InjectMocks     private TestService testService       Mock     private TestService2 testService2      Without Spring    RunWith MockitoJUnitRunner class  public class TestServiceTest        InjectMocks     private TestService testService   new TestServiceImpl         Mock     private TestService2 testService2

User · Answer

If you re using spring    3 0  try using Springs  Configuration annotation to define part of the application context   Configuration  ImportResource  com blah blurk rest-of-config xml   public class DaoTestConfiguration         Bean     public ApplicationService applicationService             return mock ApplicationService class              If you don t want to use the  ImportResource  it can be done the other way around too    lt beans gt       lt  -- rest of your config -- gt        lt  -- the container recognize this as a Configuration and adds it s beans           to the container -- gt       lt bean class  com package DaoTestConfiguration   gt   lt  beans gt    For more information  have a look at spring-framework-reference   Java-based container configuration

User · Answer

Looking at Springockito pace of development and number of open issues  I would be little bit worried to introduce it into my test suite stack nowadays  Fact that last release was done before Spring 4 release brings up questions like  quot Is it possible to easily integrate it with Spring 4  quot   I don t know  because I didn t try it  I prefer pure Spring approach if I need to mock Spring bean in integration test  There is an option to fake Spring bean with just plain Spring features  You need to use  Primary   Profile and  ActiveProfiles annotations for it  I wrote a blog post on the topic

User · Answer

As of Spring 3 2  this is no longer an issue   Spring now supports Autowiring of the results of generic factory methods   See the section entitled  Generic Factory Methods  in this blog post  http   spring io blog 2012 11 07 spring-framework-3-2-rc1-new-testing-features    The key point is       In Spring 3 2  generic return types for factory methods are now   properly inferred  and autowiring by type for mocks should work as   expected  As a result  custom work-arounds such as a   MockitoFactoryBean  EasyMockFactoryBean  or Springockito are likely no   longer necessary    Which means this should work out of the box    lt bean id  dao  class  org mockito Mockito  factory-method  mock  gt       lt constructor-arg value  com package Dao    gt   lt  bean gt

User · Answer

I found a similar answer as teabot to create a MockFactory that provides the mocks  I used the following example to create the mock factory  since the link to narkisr are dead   http   hg randompage org java src 407e78aa08a0 projects bookmarking backend spring src test java org randompage bookmarking backend testUtils MocksFactory java   lt bean id  someFacade  class  nl package test MockFactory  gt       lt property name  type  value  nl package someFacade   gt   lt  bean gt    This also helps to prevent that Spring wants to resolve the injections from the mocked bean

User · Answer

I can do the following using Mockito    lt bean id  stateMachine  class  org mockito Mockito  factory-method  mock  gt       lt constructor-arg value  com abcd StateMachine   gt   lt  bean gt

User · Answer

For the record  all my tests correctly work by just making the fixture lazy-initialized  e g     lt bean id  fixture        class  it tidalwave northernwind rca embeddedserver impl DefaultEmbeddedServer        lazy-init  true    gt   lt  -- To solve Mockito   Spring problems -- gt    lt bean class  it tidalwave messagebus aspect spring MessageBusAdapterFactory    gt    lt bean id  applicationMessageBus        class  org mockito Mockito  factory-method  mock  gt       lt constructor-arg value  it tidalwave messagebus MessageBus    gt   lt  bean gt    lt bean class  org mockito Mockito  factory-method  mock  gt       lt constructor-arg value  javax servlet ServletContext    gt   lt  bean gt    I suppose the rationale is the one Mattias explains here  at the bottom of the post   that a workaround is changing the order the beans are declared - lazy initialization is  sort of  having the fixture declared at the end

User · Answer

I would suggest to migrate your project to Spring Boot 1 4  After that you can use new annotation  MockBean to fake your com package Dao

User · Answer

I developed a solution based on the proposal of Kresimir Nesek  I added a new annotation  EnableMockedBean in order to make the code a bit cleaner and modular    EnableMockedBean  SpringBootApplication  RunWith SpringJUnit4ClassRunner class   SpringApplicationConfiguration classes MockedBeanTest class  public class MockedBeanTest         MockedBean     private HelloWorldService helloWorldService        Autowired     private MiddleComponent middleComponent        Test     public void helloWorldIsCalledOnlyOnce              middleComponent getHelloMessage                THEN HelloWorldService is called only once         verify helloWorldService  times 1   getHelloMessage               I have written a post explaining it

User · Answer

lt bean id  mockDaoFactory  name  dao  class  com package test MocksFactory  gt       lt property name  type  value  com package Dao    gt   lt  bean gt    this   works perfectly well if declared first early in the XML file  Mockito 1 9 0 Spring 3 0 5

User · Answer

If you re using Spring Boot 1 4  it has an awesome way of doing this  Just use new brand  SpringBootTest on your class and  MockBean on the field  and Spring Boot will create a mock of this type and it will inject it into the context  instead of injecting the original one     RunWith SpringRunner class   SpringBootTest public class MyTests         MockBean     private RemoteService remoteService        Autowired     private Reverser reverser        Test     public void exampleTest                RemoteService has been injected into the reverser bean         given this remoteService someCall    willReturn  mock            String reverse   reverser reverseSomeCall            assertThat reverse  isEqualTo  kcom               On the other hand  if you re not using Spring Boot or are you using a previous version  you ll have to do a bit more work       Create a  Configuration bean that injects your mocks into Spring context    Configuration  Profile  useMocks   public class MockConfigurer         Bean      Primary     public MyBean myBeanSpy             return mock MyBean class             Using  Primary annotation you re telling spring that this bean has priority if no qualifier are specified   Make sure you annotate the class with  Profile  useMocks   in order to control which classes will use the mock and which ones will use the real bean   Finally  in your test  activate userMocks profile    RunWith SpringJUnit4ClassRunner class   SpringApplicationConfiguration classes    Application class    WebIntegrationTest  ActiveProfiles profiles   useMocks    public class YourIntegrationTestIT         Inject     private MyBean myBean    It will be the mock         Test     public void test                            If you don t want to use the mock but the real bean  just don t activate useMocks profile    RunWith SpringJUnit4ClassRunner class   SpringApplicationConfiguration classes    Application class    WebIntegrationTest public class AnotherIntegrationTestIT         Inject     private MyBean myBean    It will be the real implementation         Test     public void test

User · Answer

Perhaps not the perfect solution  but I tend not to use spring to do DI for unit tests  the dependencies for a single bean  the class under test  usually aren t overly complex so I just do the injection directly in the test code

User · Answer

InjectMocks private MyTestObject testObject    Mock private MyDependentObject mockedObject    Before public void setup             MockitoAnnotations initMocks this       This will inject any mocked objects into the test class  In this case it will inject mockedObject into the testObject  This was mentioned above but here is the code

User · Answer

I use a combination of the approach used in answer by Markus T and a simple helper implementation of ImportBeanDefinitionRegistrar that looks for a custom annotation   MockedBeans  in which one can specify which classes are to be mocked  I believe that this approach results in a concise unit test with some of the boilerplate code related to mocking removed   Here s how a sample unit test looks with that approach    RunWith SpringJUnit4ClassRunner class   ContextConfiguration loader AnnotationConfigContextLoader class  public class ExampleServiceIntegrationTest          our service under test  with mocked dependencies injected      Autowired     ExampleService exampleService         we can autowire mocked beans if we need to used them in tests      Autowired     DependencyBeanA dependencyBeanA        Test     public void testSomeMethod                         exampleService someMethod                        verify dependencyBeanA  times 1   someDependencyMethod                          Inner class configuration object for this test  Spring will read it thanks to         ContextConfiguration loader AnnotationConfigContextLoader class  annotation on the test class               Configuration      Import TestAppConfig class    TestAppConfig may contain some common integration testing configuration      MockedBeans  DependencyBeanA class  DependencyBeanB class  AnotherDependency class     Beans to be mocked     static class ContextConfiguration             Bean         public ExampleService exampleService                 return new ExampleService      our service under test                     To make this happen you need to define two simple helper classes - custom annotation   MockedBeans  and a custom  ImportBeanDefinitionRegistrar implementation   MockedBeans annotation definition needs to be annotated with  Import CustomImportBeanDefinitionRegistrar class  and the ImportBeanDefinitionRgistrar needs to add mocked beans definitions to the configuration in it s registerBeanDefinitions method   If you like the approach you can find sample implementations on my blogpost

[spring] Injecting Mockito mocks into a Spring bean

Examples related to spring

Examples related to dependency-injection

Examples related to junit

Examples related to annotations

Examples related to mockito