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 avoiding heavy configuration of XML which is present in spring
- It provides easy maintenance and creation of REST endpoints
- It includes embedded Tomcat-server
- Deployment is very easy, 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 that can be 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. And 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// Classpublic class Person { @Id 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.
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 JpaRepositorypublic interface PersonRepo extends JpaRepository<Person, Integer> { @Query( "SELECT CASE WHEN COUNT(s) > 0 THEN TRUE ELSE FALSE END FROM Person s WHERE s.personId = ?1") Boolean isPersonExitsById(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// Classpublic class PersonService { @Autowired private PersonRepo repo; public List<Person> getAllPerson() { return this.repo.findAll(); } public PersonService(PersonRepo repo) { // this keyword refers to current instance this.repo = repo; }} |
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;@RestControllerpublic class PersonController { @Autowired private PersonService personService; @GetMapping("/persons") public ResponseEntity<?> getAllPersons() { return ResponseEntity.ok(this.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 create one class named as PersonRepoTest.
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// Classpublic class Person { @Id private Integer personId; private String personName; private String personCity;} |
Step 11: Unit Testing of Service Class
Inside the test > services package create one class named as PersonServiceTest.
Java
// Java Program to Illustrate Unit Testing of Service Classpackage com.demo.services;import static org.mockito.Mockito.verify;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 classclass PersonServiceTest { @Mock private PersonRepo personRepo; private PersonService personService; @BeforeEach void setUp() { this.personService = new PersonService(this.personRepo); } @Test void getAllPerson() { personService.getAllPerson(); verify(personRepo).findAll(); }} |
Similarly, we can perform testing of different units of your spring boot project.
