{"id":50846,"date":"2016-01-08T13:00:39","date_gmt":"2016-01-08T11:00:39","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=50846"},"modified":"2016-01-07T20:22:36","modified_gmt":"2016-01-07T18:22:36","slug":"mock-spring-bean-version-2","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2016\/01\/mock-spring-bean-version-2.html","title":{"rendered":"How to mock Spring bean (version 2)"},"content":{"rendered":"

About a year ago, I wrote a blog post how to mock Spring Bean<\/a>. Patterns described there were little bit invasive to the production code.\u00a0 As one of the readers Colin correctly pointed out in comment<\/a>, there is better alternative to spy\/mock Spring bean based on @Profile<\/code><\/strong> annotation. This blog post is going to describe this technique. I used this approach with success at work and also in my side projects.<\/p>\n

Note that widespread mocking in your application is often considered as design smell.<\/strong><\/p>\n

Introducing production code<\/h2>\n

First of all we need code under test to demonstrate mocking. We will use these simple classes:<\/p>\n

@Repository\r\npublic class AddressDao {\r\n\tpublic String readAddress(String userName) {\r\n\t\treturn \"3 Dark Corner\";\r\n\t}\r\n}\r\n\r\n@Service\r\npublic class AddressService {\r\n\tprivate AddressDao addressDao;\r\n\t\r\n\t@Autowired\r\n\tpublic AddressService(AddressDao addressDao) {\r\n\t\tthis.addressDao = addressDao;\r\n\t}\r\n\t\r\n\tpublic String getAddressForUser(String userName){\r\n\t\treturn addressDao.readAddress(userName);\r\n\t}\r\n}\r\n\r\n@Service\r\npublic class UserService {\r\n\tprivate AddressService addressService;\r\n\r\n\t@Autowired\r\n\tpublic UserService(AddressService addressService) {\r\n\t\tthis.addressService = addressService;\r\n\t}\r\n\t\r\n\tpublic String getUserDetails(String userName){\r\n\t\tString address = addressService.getAddressForUser(userName);\r\n\t\treturn String.format(\"User %s, %s\", userName, address);\r\n\t}\r\n}<\/pre>\n
Of course this code doesn\u2019t make much sense, but will be good to demonstrate how to mock Spring bean. AddressDao<\/code><\/strong> just returns string and thus simulates read from some data source. It is autowired into AddressService<\/code><\/strong>. This bean is autowired into UserService<\/code><\/strong>, which is used to construct string with user name and address.<\/p>\n
Notice that we are using constructor injection<\/strong> as field injection is considered as bad practice. If you want to enforce constructor injection for your application, Oliver Gierke (Spring ecosystem developer and Spring Data lead) recently created very nice project Ninjector<\/a>.<\/p>\n
Configuration which scans all these beans is pretty standard Spring Boot main class:<\/p>\n
@SpringBootApplication\r\npublic class SimpleApplication {\r\n\u00a0\u00a0 \u00a0public static void main(String[] args) {\r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0SpringApplication.run(SimpleApplication.class, args);\r\n\u00a0\u00a0 \u00a0}\r\n}<\/pre>\n
Mock Spring bean (without AOP)<\/h2>\n
Let\u2019s test the AddressService<\/strong><\/code> class where we mock AddressDao<\/code><\/strong>. We can create this mock via Spring\u2019 @Profiles<\/code><\/strong> and @Primary<\/strong> annotations this way:<\/p>\n
@Profile(\"AddressService-test\")\r\n@Configuration\r\npublic class AddressDaoTestConfiguration {\r\n\t@Bean\r\n\t@Primary\r\n\tpublic AddressDao addressDao() {\r\n\t\treturn Mockito.mock(AddressDao.class);\r\n\t}\r\n}<\/pre>\n
This test configuration will be applied only when Spring profile AddressService-test<\/strong><\/code> is active. When it\u2019s applied, it registers bean of type AddressDao<\/code><\/strong>, which is mock instance created by Mockito<\/strong>. @Primary<\/code><\/strong> annotation tells Spring to use this instance instead of real one when somebody autowire AddressDao<\/strong><\/code> bean.<\/p>\n
Test class is using JUnit<\/strong> framework:<\/p>\n
@ActiveProfiles(\"AddressService-test\")\r\n@RunWith(SpringJUnit4ClassRunner.class)\r\n@SpringApplicationConfiguration(SimpleApplication.class)\r\npublic class AddressServiceITest {\r\n\t@Autowired \r\n\tprivate AddressService addressService;\r\n\r\n\t@Autowired\r\n\tprivate AddressDao addressDao;\r\n\r\n\t@Test\r\n\tpublic void testGetAddressForUser() {\r\n\t\t\/\/ GIVEN\r\n\t\tMockito.when(addressDao.readAddress(\"john\"))\r\n\t\t\t.thenReturn(\"5 Bright Corner\");\r\n\r\n\t\t\/\/ WHEN \r\n\t\tString actualAddress = addressService.getAddressForUser(\"john\");\r\n  \r\n\t\t\/\/ THEN   \r\n\t\tAssert.assertEquals(\"5 Bright Corner\", actualAddress);\r\n\t}\r\n}<\/pre>\n
We activate profile AddressService-test<\/code><\/strong> to enable AddressDao<\/code><\/strong> mocking. Annotation @RunWith<\/code><\/strong> is needed for Spring integration tests and @SpringApplicationConfiguration<\/code><\/strong> defines which Spring configuration will be used to construct context for testing. Before the test, we autowire instance of AddressService<\/code><\/strong> under test and AddressDao<\/code><\/strong> mock.<\/p>\n
Subsequent testing method should be clear if you are using Mockito. In GIVEN<\/code><\/strong> phase, we record desired behavior into mock instance. In WHEN<\/code><\/strong> phase, we execute testing code and in THEN<\/code><\/strong> phase, we verify if testing code returned value we expect.<\/p>\n
Spy on Spring Bean (without AOP)<\/h2>\n
For spying example, will be spying on AddressService<\/code><\/strong> instance:<\/p>\n
@Profile(\"UserService-test\")\r\n@Configuration\r\npublic class AddressServiceTestConfiguration {\r\n\t@Bean\r\n\t@Primary\r\n\tpublic AddressService addressServiceSpy(AddressService addressService) {\r\n\t\treturn Mockito.spy(addressService);\r\n\t}\r\n}<\/pre>\n
This Spring configuration will be component scanned only if profile UserService-test<\/code><\/strong> will be active. It defines primary bean of type AddressService<\/code><\/strong>. @Primary<\/code><\/strong> tells Spring to use this instance in case two beans of this type are present in Spring context.\u00a0 During construction of this bean we autowire existing instance of AddressService<\/code><\/strong> from Spring context and use Mockito\u2019s spying feature. The bean we are registering is effectively delegating all the calls to original instance, but Mockito spying allows us to verify interactions on spied instance.
 
<\/div> <\/div><\/p>\n
We will test behavior of UserService<\/code><\/strong> this way:<\/p>\n
@ActiveProfiles(\"UserService-test\")\r\n@RunWith(SpringJUnit4ClassRunner.class)\r\n@SpringApplicationConfiguration(SimpleApplication.class)\r\npublic class UserServiceITest {\r\n\t@Autowired\r\n\tprivate UserService userService;\r\n\r\n\t@Autowired\r\n\tprivate AddressService addressService;\r\n \r\n\t@Test\r\n\tpublic void testGetUserDetails() {\r\n\t\t\/\/ GIVEN - Spring scanned by SimpleApplication class\r\n\r\n\t\t\/\/ WHEN\r\n\t\tString actualUserDetails = userService.getUserDetails(\"john\");\r\n \r\n\t\t\/\/ THEN\r\n\t\tAssert.assertEquals(\"User john, 3 Dark Corner\", actualUserDetails);\r\n\t\tMockito.verify(addressService).getAddressForUser(\"john\");\r\n\t}\r\n}<\/pre>\n
For testing we activate UserService-test<\/code><\/strong> profile so our spying configuration will be applied. We autowire UserService<\/code><\/strong> which is under test and AddressService<\/code><\/strong>, which is being spied via Mockito.<\/p>\n
We don\u2019t need to prepare any behavior for testing in GIVEN<\/code><\/strong> phase. W<\/code>HEN<\/code><\/strong> phase is obviously executing code under test. In THEN<\/strong><\/code> phase we verify if testing code returned value we expect and also if addressService<\/code><\/strong> call was executed with correct parameter.<\/p>\n
Problems with Mockito and Spring AOP<\/h2>\n
Let say now we want to use Spring AOP module to handle some cross-cutting concerns. For example to log calls on our Spring beans this way:<\/p>\n
package net.lkrnac.blog.testing.mockbeanv2.aoptesting;\r\n\r\nimport org.aspectj.lang.JoinPoint;\r\nimport org.aspectj.lang.annotation.Aspect;\r\nimport org.aspectj.lang.annotation.Before;\r\nimport org.springframework.context.annotation.Profile;\r\nimport org.springframework.stereotype.Component;\r\n\r\nimport lombok.extern.slf4j.Slf4j;\r\n\u00a0\u00a0 \u00a0\r\n@Aspect\r\n@Component\r\n@Slf4j\r\n@Profile(\"aop\") \/\/only for example purposes\r\npublic class AddressLogger {\r\n\u00a0\u00a0 \u00a0@Before(\"execution(* net.lkrnac.blog.testing.mockbeanv2.beans.*.*(..))\")\r\n\u00a0\u00a0 \u00a0public void logAddressCall(JoinPoint jp){\r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0log.info(\"Executing method {}\", jp.getSignature());\r\n\u00a0\u00a0 \u00a0}\r\n}<\/pre>\n
This AOP Aspect is applied before call on Spring beans from package net.lkrnac.blog.testing.mockbeanv2<\/code><\/strong>. It is using Lombok\u2019s annotation @Slf4j<\/code><\/strong> to log signature of called method. Notice that this bean is created only when aop<\/code><\/strong> profile is defined. We are using this profile to separate AOP and non-AOP testing examples. In a real application you wouldn\u2019t want to use such profile.<\/p>\n
We also need to enable AspectJ for our application, therefore all the following examples will be using this Spring Boot main class:<\/p>\n
@SpringBootApplication\r\n@EnableAspectJAutoProxy\r\npublic class AopApplication {\r\n\u00a0\u00a0 \u00a0public static void main(String[] args) {\r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0SpringApplication.run(AopApplication.class, args);\r\n\u00a0\u00a0 \u00a0}\r\n}<\/pre>\n
AOP constructs are enabled by @EnableAspectJAutoProxy<\/code><\/strong>.<\/p>\n
But such AOP constructs may be problematic if we combine Mockito for mocking with Spring AOP. It is because both use CGLIB to proxy real instances and when Mockito proxy is wrapped into Spring proxy, we can experience type mismatch problems. These can be mitigated by configuring bean\u2019s scope with\u00a0ScopedProxyMode.TARGET_CLASS<\/code><\/strong>, but Mockito verify<\/code>()<\/code><\/strong> calls still fail with NotAMockException<\/code><\/strong>. Such problems can be seen if we enable aop<\/code><\/strong> profile for UserServiceITest<\/code><\/strong>.<\/p>\n
Mock Spring bean proxied by Spring AOP<\/h2>\n
To overcome these problems, we will wrap mock into this Spring bean:<\/p>\n
package net.lkrnac.blog.testing.mockbeanv2.aoptesting;\r\n\r\nimport org.mockito.Mockito;\r\nimport org.springframework.context.annotation.Primary;\r\nimport org.springframework.context.annotation.Profile;\r\nimport org.springframework.stereotype.Repository;\r\n\r\nimport lombok.Getter;\r\nimport net.lkrnac.blog.testing.mockbeanv2.beans.AddressDao;\r\n\r\n@Primary\r\n@Repository\r\n@Profile(\"AddressService-aop-mock-test\")\r\npublic class AddressDaoMock extends AddressDao{\r\n\u00a0\u00a0 \u00a0@Getter\r\n\u00a0\u00a0 \u00a0private AddressDao mockDelegate = Mockito.mock(AddressDao.class);\r\n\u00a0\u00a0 \u00a0\r\n\u00a0\u00a0 \u00a0public String readAddress(String userName) {\r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0return mockDelegate.readAddress(userName);\r\n\u00a0\u00a0 \u00a0}\r\n}<\/pre>\n
@Primary<\/code><\/strong> annotation makes sure that this bean will take precedence before real AddressDao<\/code><\/strong> bean during injection. To make sure it will be applied only for specific test, we define profile AddressService-aop-mock-test<\/code><\/strong> for this bean. It inherits AddressDao<\/code><\/strong> class, so that it can act as full replacement of that type.<\/p>\n
In order to fake behavior, we define mock instance of type AddressDao<\/code><\/strong>, which is exposed via getter defined by Lombok\u2019s @Getter<\/code><\/strong> annotation. We also implement readAddress()<\/strong><\/code> method which is expected to be called during test. This method just delegates the call to mock instance.<\/p>\n
The test where this mock is used can look like this:<\/p>\n
@ActiveProfiles({\"AddressService-aop-mock-test\", \"aop\"})\r\n@RunWith(SpringJUnit4ClassRunner.class)\r\n@SpringApplicationConfiguration(AopApplication.class)\r\npublic class AddressServiceAopMockITest {\r\n\u00a0\u00a0 \u00a0@Autowired\r\n\u00a0\u00a0 \u00a0private AddressService addressService; \r\n\r\n\u00a0\u00a0 \u00a0@Autowired\r\n\u00a0\u00a0 \u00a0private AddressDao addressDao;\r\n\u00a0\u00a0 \u00a0\r\n\u00a0\u00a0 \u00a0@Test\r\n\u00a0\u00a0 \u00a0public void testGetAddressForUser() {\r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0\/\/ GIVEN\r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0AddressDaoMock addressDaoMock = (AddressDaoMock) addressDao;\r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0Mockito.when(addressDaoMock.getMockDelegate().readAddress(\"john\"))\r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0.thenReturn(\"5 Bright Corner\");\r\n\u00a0\r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0\/\/ WHEN \r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0String actualAddress = addressService.getAddressForUser(\"john\");\r\n\u00a0\r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0\/\/ THEN \u00a0\r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0Assert.assertEquals(\"5 Bright Corner\", actualAddress);\r\n\u00a0\u00a0 \u00a0}\r\n}<\/pre>\n
In the test we define AddressService-aop-mock-test<\/code><\/strong> profile to activate AddressDaoMock<\/code><\/strong> and aop<\/code><\/strong> profile to activate AddressLogger<\/code><\/strong> AOP aspect. For testing, we autowire testing bean addressService<\/code><\/strong> and its faked dependency addressDao<\/code><\/strong>. As we know, addressDao<\/code><\/strong> will be of type AddressDaoMock<\/strong><\/code>, because this bean was marked as @Primary<\/code><\/strong>. Therefore we can cast it and record behavior into mockDelegate<\/code><\/strong>.<\/p>\n
When we call testing method, recorded behavior should be used because we expect testing method to use AddressDao<\/code><\/strong> dependency.<\/p>\n
Spy on Spring bean proxied by Spring AOP<\/h2>\n
Similar pattern can be used for spying the real implementation. This is how our spy can look like:<\/p>\n
package net.lkrnac.blog.testing.mockbeanv2.aoptesting;\r\n\r\nimport org.mockito.Mockito;\r\nimport org.springframework.beans.factory.annotation.Autowired;\r\nimport org.springframework.context.annotation.Primary;\r\nimport org.springframework.context.annotation.Profile;\r\nimport org.springframework.stereotype.Service;\r\n\r\nimport lombok.Getter;\r\nimport net.lkrnac.blog.testing.mockbeanv2.beans.AddressDao;\r\nimport net.lkrnac.blog.testing.mockbeanv2.beans.AddressService;\r\n\r\n@Primary\r\n@Service\r\n@Profile(\"UserService-aop-test\")\r\npublic class AddressServiceSpy extends AddressService{\r\n\u00a0\u00a0 \u00a0@Getter\r\n\u00a0\u00a0 \u00a0private AddressService spyDelegate;\r\n\u00a0\u00a0 \u00a0\r\n\u00a0\u00a0 \u00a0@Autowired\r\n\u00a0\u00a0 \u00a0public AddressServiceSpy(AddressDao addressDao) {\r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0super(null);\r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0spyDelegate = Mockito.spy(new AddressService(addressDao));\r\n\u00a0\u00a0 \u00a0}\r\n\u00a0\u00a0 \u00a0\r\n\u00a0\u00a0 \u00a0public String getAddressForUser(String userName){\r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0return spyDelegate.getAddressForUser(userName);\r\n\u00a0\u00a0 \u00a0}\r\n}<\/pre>\n
As we can see this spy is very similar to AddressDaoMock<\/code><\/strong>. But in this case real bean is using constructor injection to autowire its dependency. Therefore we\u2019ll need to define non-default constructor and do constructor injection also. But we wouldn\u2019t pass injected dependency into parent constructor.<\/p>\n
To enable spying on real object, we construct new instance with all the dependencies, wrap it into Mockito spy instance and store it into spyDelegate<\/code><\/strong> property. We expect call of method getAddressForUser()<\/code><\/strong> during test, therefore we delegate this call to spyDelegate<\/code><\/strong>. This property can be accessed in test via getter defined by Lombok\u2019s @Getter<\/code><\/strong> annotation.<\/p>\n
Test itself would look like this:<\/p>\n
@ActiveProfiles({\"UserService-aop-test\", \"aop\"})\r\n@RunWith(SpringJUnit4ClassRunner.class)\r\n@SpringApplicationConfiguration(AopApplication.class)\r\npublic class UserServiceAopITest {\r\n\u00a0\u00a0 \u00a0@Autowired\r\n\u00a0\u00a0 \u00a0private UserService userService;\r\n\r\n\u00a0\u00a0 \u00a0@Autowired\r\n\u00a0\u00a0 \u00a0private AddressService addressService;\r\n\u00a0\u00a0 \u00a0\r\n\u00a0\u00a0 \u00a0@Test\r\n\u00a0\u00a0 \u00a0public void testGetUserDetails() {\r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0\/\/ GIVEN\r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0AddressServiceSpy addressServiceSpy = (AddressServiceSpy) addressService;\r\n\r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0\/\/ WHEN\r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0String actualUserDetails = userService.getUserDetails(\"john\");\r\n\u00a0 \r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0\/\/ THEN \r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0Assert.assertEquals(\"User john, 3 Dark Corner\", actualUserDetails);\r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0Mockito.verify(addressServiceSpy.getSpyDelegate()).getAddressForUser(\"john\");\r\n\u00a0\u00a0 \u00a0}\r\n}<\/pre>\n
It is very straight forward. Profile UserService-aop-test<\/code><\/strong> ensures that AddressServiceSpy<\/code><\/strong> will be scanned. Profile aop<\/code><\/strong> ensures same for AddressLogger<\/code><\/strong> aspect. When we autowire testing object UserService<\/code><\/strong> and its dependency AddressService<\/code><\/strong>, we know that we can cast it to AddressServiceSpy<\/code><\/strong> and verify the call on its spyDelegate<\/code><\/strong> property after calling the testing method.<\/p>\n
Fake Spring bean proxied by Spring AOP<\/h2>\n
It is obvious that delegating calls into Mockito mocks or spies complicates the testing. These patterns are often overkill if we simply need to fake the logic. We can use such fake in that case:<\/p>\n
@Primary\r\n@Repository\r\n@Profile(\"AddressService-aop-fake-test\")\r\npublic class AddressDaoFake extends AddressDao{\r\n\u00a0\u00a0 \u00a0public String readAddress(String userName) {\r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0return userName + \"'s address\";\r\n\u00a0\u00a0 \u00a0}\r\n}<\/pre>\n
and used it for testing this way:<\/p>\n
@ActiveProfiles({\"AddressService-aop-fake-test\", \"aop\"})\r\n@RunWith(SpringJUnit4ClassRunner.class)\r\n@SpringApplicationConfiguration(AopApplication.class)\r\npublic class AddressServiceAopFakeITest {\r\n\u00a0\u00a0 \u00a0@Autowired\r\n\u00a0\u00a0 \u00a0private AddressService addressService; \r\n\r\n\u00a0\u00a0 \u00a0@Test\r\n\u00a0\u00a0 \u00a0public void testGetAddressForUser() {\r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0\/\/ GIVEN - Spring context\r\n\u00a0\r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0\/\/ WHEN \r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0String actualAddress = addressService.getAddressForUser(\"john\");\r\n\u00a0\r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0\/\/ THEN \u00a0\r\n\u00a0\u00a0 \u00a0\u00a0\u00a0 \u00a0Assert.assertEquals(\"john's address\", actualAddress);\r\n\u00a0\u00a0 \u00a0}\r\n}<\/pre>\n
I don\u2019t think this test needs explanation.<\/p>\n