Unit Testing in Spring Boot Project using Mockito and Junit

Spring Boot is built on the top of the spring and contains all the features of spring. And is becoming a favorite of developers these days because of its rapid production-ready environment which enables the developers to directly focus on the logic instead of struggling with the configuration and setup. Spring Boot is a microservice-based framework and making a production-ready application in it takes very little time. Following are some of the features of Spring Boot:

It allows for avoiding heavy configuration of XML which is present in spring.
It provides easy maintenance and creation of REST endpoints.
It includes an embedded Tomcat server.
Deployment is straightforward, war and jar files can be easily deployed in the Tomcat server.

Mockito is an open-source testing framework used for unit testing of Java applications. It plays a vital role in developing testable applications. Mockito is used to mock interfaces so that a dummy functionality can be added to a mock interface used in Unit Testing. Unit Testing is a type of software testing in which individual components of the software are tested. The major objective of using the Mockito framework is to simplify the development of a test by mocking external dependencies and using them in the test code. As a result, Mockito provides a simpler test code that is easier to understand, more readable, and modifiable. Mockito can also be used with other testing frameworks like JUnit and TestNG. JUnit framework is a Java framework that is also used for testing. Now, JUnit is used as a standard when there is a need to perform testing in Java. So, in this article, we are going to perform Unit Testing in Spring Boot Project using Mockito and JUnit.

Step-by-Step Implementation

Step 1: Refer to this article How to Create a Spring Boot Project with IntelliJ IDEA and create a Spring Boot project.

Step 2: Add the following dependency as listed below as follows:

Spring Web
MySQL Database
Lombok
Spring Data JPA

Example: pom.xml File

XML

<?xml version="1.0" encoding="UTF-8"?>

<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <parent>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-parent</artifactId>

        <version>2.5.4</version>

        <relativePath/> <!-- lookup parent from repository -->

    </parent>

    <groupId>com.demo</groupId>

    <artifactId>BootDemoApp</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    <name>BootDemoApp</name>

    <description>BootDemoApp</description>

    <properties>

        <java.version>16</java.version>

    </properties>

    <dependencies>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-web</artifactId>

        </dependency>
 
        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-data-jpa</artifactId>

        </dependency>
 
        <dependency>

            <groupId>mysql</groupId>

            <artifactId>mysql-connector-java</artifactId>

            <scope>runtime</scope>

        </dependency>
 
        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-test</artifactId>

            <scope>test</scope>

        </dependency>
 
        <dependency>

            <groupId>org.projectlombok</groupId>

            <artifactId>lombok</artifactId>

            <optional>true</optional>

        </dependency>
 
    </dependencies>
 
    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>
 
</project>

Step 3: Create the packages and files as seen in the below image. Below is the complete file structure of this project.

Note:

Green Rounded Icon ‘I’ Buttons are Interface.

Blue Rounded Icon ‘C’ Buttons are Classes.

Step 4: Inside the entity package

It is done via creating a simple POJO class inside the Person.java file.

Java

package com.demo.entities;
 
import lombok.AllArgsConstructor;

import lombok.Data;

import lombok.NoArgsConstructor;
 
import javax.persistence.Entity;

import javax.persistence.Id;
 
@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
// Class 

public class Person {

    @Id

    @GeneratedValue(strategy = GenerationType.IDENTITY)

    private Integer personId;

    private String personName;

    private String personCity;
}

Step 5: Inside the repository package

Create a simple interface and name the interface as PersonRepo. This interface is going to extend the JpaRepository.

JpaRepository: It takes two generic Parameters. First of entity and other of Type of Primary Key. Here entity is Person and Integer is Primary Key.

Java

package com.demo.repo;
 
import com.demo.entities.Person;

import org.springframework.data.jpa.repository.JpaRepository;

import org.springframework.data.jpa.repository.Query;
 
// Interface
// Extends JpaRepository

public interface PersonRepo

    extends JpaRepository<Person, Integer> {

  //Spring data jpa  will automatically provide implementation for it when using existsBy{fieldName}

    Boolean existsById(Integer id);
}

Step 6: Inside the service package

Inside the package create one class named as PersonService.

Java

package com.demo.services;
 
import com.demo.entities.Person;

import com.demo.repo.PersonRepo;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;
 
// Annotation
@Service
 
// Class

public class PersonService {

  //No need to use @Autowired when using Constructor Injection 

  //Dependencies are final 
 
   private final PersonRepo repo;

   public PersonService(PersonRepo repo)

    {

        // this keyword refers to current instance

        this.repo = repo;

    }
 
    public List<Person> getAllPerson()

    {   

        return repo.findAll();

    }
 
}

Step 7: Inside the controller package

Inside the package create one class named as PersonController.

Java

package com.demo.controllers;
 
import com.demo.services.PersonService;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.http.ResponseEntity;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.RestController;

import com.demo.entity.Person
@RestController

public class PersonController {

  //Constructor Based Injection No need of using @Autowired

  private final PersonService personService;

  public PersonController(PersonService personService){

  this.personService=personService;
}
 
    @GetMapping("/persons")

    public ResponseEntity<List<Person>> getAllPersons() {

        return ResponseEntity.ok(personService.getAllPerson());

    }
}

Step 8: Below is the code for the application.properties file

server.port=8082
# Configuration for MySQL Database
spring.jpa.hibernate.ddl-auto=update
spring.datasource.url=jdbc:mysql://localhost:3306/schooldb
spring.datasource.username=amiya559
spring.datasource.password=password.123
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.show-sql:true

Now your sample spring boot project is ready, and we are going to perform unit testing in this sample project.

Step 9: Create the following packages and the classes as shown in the below image. (Inside the green color box)

Step 10: Unit Testing of Repository Class

Inside the test > repo package creates one class named as PersonRepoTest.

Java

package com.demo.entities;
 
import lombok.AllArgsConstructor;

import lombok.Data;

import lombok.NoArgsConstructor;

import lombok.Builder;

import javax.persistence.Entity;

import javax.persistence.Id;
 
@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
// Class 

public class Person {

    @Id

    private Integer personId;

    private String personName;

    private String personCity;
}

Step 11: Unit Testing of Service Class

Inside the test > services package creates one class named as PersonServiceTest.

Java

// Java Program to Illustrate Unit Testing of Service Class
 
package com.demo.services;
//USing BDD Mockito 

import static org.mockito.BDDMockito.verify;

import static org.mockito.BDDMockito.given;

import static org.assertj.core.api.Assertions.assertThat;
 
import com.demo.repo.PersonRepo;

import org.junit.jupiter.api.BeforeEach;

import org.junit.jupiter.api.Test;

import org.junit.jupiter.api.extension.ExtendWith;

import org.mockito.Mock;

import org.mockito.junit.jupiter.MockitoExtension;
 
@ExtendWith(MockitoExtension.class)
 
// Main class

class PersonServiceTest {
 
    @Mock

  private PersonRepo personRepo;

  //When using Mockito Use @InjectMocks to inject

  //Mocked beans to following class

    @InjectMocks

  private PersonService personService;
 
    @Test

  void getAllPerson()

    {

      //given

       Person person= new Person( 1,"Ahnis","Gotham");

       Person person2= new Person(2,"Saksham","New york");

      //When

       given(personRepo.findAll())

      .willReturn(List.of(person,person2));

      var  personList = personService.getAllPerson();

       //Then

    //Make sure to import assertThat From org.assertj.core.api package

         assertThat(personList).isNotNull();

         assertThat(personList.size()).isEqualTo(2);

  }
}

Similarly, we can perform testing of different units of your spring boot project.

Article Tags :

Java

Java-Spring-Boot