Test RESTful Web Service with JUnit and Mockito

Earlier I’ve published a blog post on now to create a RESTful Web Service(JAX-RS) to accept JSON payload with user profile details and how to save user profile details into a MySQL database using Java Hibernate framework. In this blog post I am going to share with you how to test(using JUnit and Mockito) it’s Service Layer Implementation class, which is responsible for storing user profile details. Below, is a short break down on things we are going to cover:

  • Add Mockito Framework for Unit tests mockito-core to our project pom.xml file
  • Add Spring Framework spring-test and spring-context dependencies
  • Create Spring ContextConfiguration Java class to specify base packages for component scanning
  • Create UsersServiceImplTest class, Autowire service class, mock objects, call saveUser method and Assert expected results.

Ok, let’s begin.

Add mockito-core, spring-test and spring-context  to pom.xml

Open https://mvnrepository.com and search each of the below libraries Maven repository. Below are the ones I have copied into my pom.xml:

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>2.8.47</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>4.3.7.RELEASE</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.3.7.RELEASE</version>
</dependency>

The above dependencies should allow you to autowire Spring Beans into your Test class and Mock objects and their behaviour.  After adding the above to my pom.xml file, the complete pom.xml of my RESTful Web Services app looks like this:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.appsdeveloperblog.ws</groupId>
    <artifactId>HibernateExamples</artifactId>
    <packaging>war</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>HibernateExamples Maven Webapp</name>
    <url>http://maven.apache.org</url>
    <dependencies>
        
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.mockito/mockito-core -->
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-core</artifactId>
            <version>2.8.47</version>
            <scope>test</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.glassfish.jersey.bundles/jaxrs-ri -->
        <dependency>
            <groupId>org.glassfish.jersey.bundles</groupId>
            <artifactId>jaxrs-ri</artifactId>
            <version>2.25</version>
        </dependency>
        
        <!-- https://mvnrepository.com/artifact/org.glassfish.jersey.media/jersey-media-moxy -->
        <dependency>
            <groupId>org.glassfish.jersey.media</groupId>
            <artifactId>jersey-media-moxy</artifactId>
            <version>2.25</version>
        </dependency>
    
        <!-- Hibernate Dependencies -->
        <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.2.8.Final</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-validator -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>5.4.0.Final</version>
        </dependency>
        
        <!-- MySQL Dependencies -->
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.41</version>
        </dependency>
        
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-beans -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>4.3.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.3.7.RELEASE</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>4.3.1.Final</version>
        </dependency>

    </dependencies>
    <build>
        <finalName>HibernateExamples</finalName>
    </build>
</project>

Create Spring ContextConfiguration Class 

To be able to @Autowire classes into my Test class, I need to create a new Java class with @Configuration annotation and specify the base package name which will be used by @ComponentScan to find all the Spring Beans which can be autowired. This class needs to be created in a package under the Tests folder in your project.

package com.appsdeveloperblog.ws;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = {"com.appsdeveloperblog.ws"})
public class TestConfiguration {
}

 The UsersServiceImpl class 

Please note the use of @Service(“usersService”) above the class name. The value you specify in @Service annotation should match the value you specify in @Qualifier(“usersService”) when you are auto wiring the Spring Bean in your Test class. Thus the values of @Service(“usersService”) and @Qualifier(“usersService”) in my case match.

Below is my version of the Service class which I am testing with the UsersServiceImplTest class the code of which I am also going to paste below.

package com.appsdeveloperblog.ws.service.impl;

import com.appsdeveloperblog.ws.io.dao.Database;
import com.appsdeveloperblog.ws.io.entity.UserProfileEntity;
import com.appsdeveloperblog.ws.service.UsersService;
import com.appsdeveloperblog.ws.shared.dto.UserProfileDto;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

 
@Service("usersService")
public class UsersServiceImpl implements UsersService {

    Database database;

    public UserProfileDto saveUser(UserProfileDto userDto) {
        
        UserProfileDto returnValue = null;
        
        UserProfileEntity userEntity = new UserProfileEntity();
        BeanUtils.copyProperties(userDto, userEntity);
        
        // Connect to database 
        try {
            this.database.openConnection();
            UserProfileEntity storedUserEntity = this.database.saveUserProfile(userEntity);
            if(storedUserEntity != null && storedUserEntity.getId()>0)
            {
                returnValue = new UserProfileDto();
                BeanUtils.copyProperties(storedUserEntity, returnValue);
            }
        }  finally {
            this.database.closeConnection();
        }
        
        return returnValue;
    }

}

Create the Test class, Autowire Service Class and Mock objects

Because we are creating a test class for UsersServiceImpl class, the name of our test class will be UsersServiceImplTest.

In the code below please note that we are going to test the saveUser() method of UsersService. This is why we add the @Autowired and the @InjectMocks on UsersService object declaration and then we simply mock all other objects and their methods.

Also, please notice the use of @Qualifier(“usersService”). Inside of the @Qualifier annotation we need to specify the value which we have specified in the @Service annotation in the UsersServiceImpl class above.

Below is a complete UsersServiceImplTest class which is testing the saveUser() method of UsersServiceImpl class.

package com.appsdeveloperblog.ws.service.impl;

import com.appsdeveloperblog.ws.TestConfiguration;
import com.appsdeveloperblog.ws.io.dao.Database;
import com.appsdeveloperblog.ws.io.entity.UserProfileEntity;
import com.appsdeveloperblog.ws.service.UsersService;
import com.appsdeveloperblog.ws.shared.dto.UserProfileDto;
import org.junit.*;
import org.junit.runner.RunWith;
import static org.mockito.ArgumentMatchers.any;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.when;
import org.mockito.MockitoAnnotations;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration( classes = TestConfiguration.class )
public class UsersServiceImplTest {

    @Mock
    Database database;

    @Mock
    UserProfileEntity userProfileEntity;
 
    @Autowired
    @InjectMocks
    @Qualifier("usersService")
    UsersService usersService;

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

    @Test
    public void testSaveUser() {
        System.out.println("testing saveUser");
 
        //Mocking Database open and close methods
        doNothing().when(database).openConnection();
        doNothing().when(database).closeConnection();

        // Mocking userProfileEntity methods
        when( userProfileEntity.getFirstName() ).thenReturn( "Sergey" );
        when( userProfileEntity.getLastName()).thenReturn( "Kargopolov" );
        when( userProfileEntity.getId() ).thenReturn( new Long(1) );
        
        // Mocking database saveUserProfile method
        when( database.saveUserProfile( any(UserProfileEntity.class) ) ).thenReturn( userProfileEntity );

        // Create sample UserProfileDto
        UserProfileDto userProfileDto = new UserProfileDto();
        userProfileDto.setFirstName( "Sergey" );
        userProfileDto.setLastName( "Kargopolov" );

        // Call saveUser method
        UserProfileDto result = usersService.saveUser( userProfileDto );
     
        // Assert expected results
        Assert.assertNotNull( result );
        Assert.assertEquals( userProfileDto.getFirstName() , result.getFirstName() );
        Assert.assertEquals( userProfileDto.getLastName() , result.getLastName() );
    }
}

And this is it. Following the example in this blog post you can create Unit tests with JUnit and Mockito for any of your Service layer classes in the project.

To learn more about how to use JUnit and Mockito frameworks to test your Restful Web Services check out these video courses and books below:

Testing Your Code with JUnit

JUnit and Mockito Crash Course

Learn how to use JUnit and Mockito and Unit Test in easy steps.


icon

Mockito Tutorial : Learn mocking with 25 Junit Examples

Learn unit testing and mocking with 25 Junit Examples


icon