Mock unit testing with Mockito and Spring (Ejb and Rest service)

In this tutorial we are going to learn about mock unit testing. We are using here Mockito with Spring to write unit tests. We will also see how to mock an EJB session bean inside mocked service without constructor/setters injection.

What is mocking

Mocking is a technique to replace the actual implementation with some dummy or provided code chunk during unit testing. For example if we need to unit test some service which persist data to database then we can mock that persist method to add it to some in-memory collection. Also we can mock data retrieval to get the data from same collection or so. Mockito provide various class and features to implement the mocking seamlessly.

Maven dependency

We are using Spring (XML base configuration) and mockito for mock testing. Below dependencies are required.

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>4.1.9.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>4.1.9.RELEASE</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-core</artifactId>
        <version>1.10.19</version>
        <scope>test</scope>
    </dependency>

Spring configuration XML

Below is our configuration for spring where we enable annotation based processing. Also we are creating a bean for EJB session bean.

1. Spring namespace and schema declaration

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:jee="http://www.springframework.org/schema/jee"

    xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd
            http://www.springframework.org/schema/mvc
            http://www.springframework.org/schema/mvc/spring-mvc.xsd
            http://www.springframework.org/schema/jee
            http://www.springframework.org/schema/jee/spring-jee.xsd">

2. Configure annotation processing

    <context:component-scan base-package="com.ttj.rest"/>
    <context:component-scan base-package="com.ttj.misc"/>

    <mvc:annotation-driven/>

3. Bean declaration for EJB Session Bean

    <jee-local-slsb id="ejbSessionBean" jndi-name="ejb/MyEjbSessionBean"
        business-interface="com.ttj.ejb.MyBusinessInterface" />

Rest Service

Below is the Rest service where we inject the ejb session bean using business interface. We invoke the method on EJB bean and then return the same response as a service call response.

@RestController
public class MyController{
    @Resource(name="ejbSessionBean")
    private MyBusinessInterface ejbSessionBean;

    @RequestMapping(value="/message", method=RequestMethod.GET,
                produces=MediaType.APPLICATION_JSON_VALUE)
    public String getUserMessageFromEjb(){
        return ejbSessionBean.getUserMessage();
    }
}

Unit Test using Mockito

Now we will create out unit test using mockito where we will mock the EJB session bean which will be injected in Rest service. Then this rest service will use mocked ejb bean to provide the response.

1. Required annotations

Here we are using @RunWith annotation to enable the Spring's dependency injection and @ContextConfiguration to makes Spring to scan mentioned classes. Please note that Spring will not load context configuration XML from WEB-INF by default, so we need to configure the scanning of required classes.


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(class={MyController.class, MyControllerTest.class})
public class MyControllerTest{

2. Mocking EJB bean

In below code we are creating a mocked bean which will automatically bind with controller class as controller class binds it using the bean ID.

    @Bean
    public MyBusinessInterface ejbSessionBean(){
        MyBusinessInterface bean = Mockito.mock(MyBusinessInterface.class);
        Mockito.when(bean.getUserMessage()).thenReturn("Dummy message");
        return bean;
    } 

3. Writing Test case

In below code we autowire the controller class and then uses it to write the unit test.

    @Autowired
    private MyController controller;

    @Test
    public void getUserMessageFromEjbTest(){
        String exp = "Dummy message");
        Assert.assertEquals(exp, controller.getUserMessageFromEjb());
    }

Now you can execute the maven build to run the test.