Pruebas unitarias en Spring Boot Project usando Mockito y Junit

Spring Boot está construido en la parte superior del resorte y contiene todas las características del resorte. Y se está convirtiendo en el favorito de los desarrolladores en estos días debido a su rápido entorno listo para producción que les permite concentrarse directamente en la lógica en lugar de luchar con la configuración y la instalación. Spring Boot es un marco basado en microservicios y crear una aplicación lista para producción lleva muy poco tiempo. Las siguientes son algunas de las características de Spring Boot:

• Permite evitar la configuración pesada de XML que está presente en primavera.
• Proporciona fácil mantenimiento y creación de puntos finales REST
• Incluye servidor Tomcat incorporado
• La implementación es muy fácil, los archivos war y jar se pueden implementar fácilmente en el servidor tomcat

Mockito es un marco de prueba de código abierto que se utiliza para la prueba unitaria de aplicaciones Java. Desempeña un papel vital en el desarrollo de aplicaciones comprobables. Mockito se usa para simular interfaces para que se pueda agregar una funcionalidad ficticia a una interfaz simulada que se puede usar en pruebas unitarias. La prueba unitaria es un tipo de prueba de software en la que se prueban los componentes individuales del software. El objetivo principal de usar el marco Mockito es simplificar el desarrollo de una prueba burlándose de las dependencias externas y usándolas en el código de prueba. Y como resultado, Mockito proporciona un código de prueba más simple que es más fácil de entender, más legible y modificable. Mockito también se puede usar con otros marcos de prueba como JUnit y TestNG . JUnitframework es un marco de Java que también se utiliza para realizar pruebas. Ahora, JUnit se usa como estándar cuando es necesario realizar pruebas en Java. Entonces, en este artículo, vamos a realizar pruebas unitarias en Spring Boot Project usando Mockito y Junit.

Implementación paso a paso

Paso 1: Consulte este artículo Cómo crear un proyecto Spring Boot con IntelliJ IDEA y cree un proyecto Spring Boot. 

Paso 2: agregue la siguiente dependencia como se indica a continuación de la siguiente manera:

• Telaraña de primavera
• Base de datos MySQL
• Lombok
• JPA de datos de primavera

Ejemplo: archivo pom.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>

Paso 3 : Cree los paquetes y archivos como se ve en la imagen de abajo. A continuación se muestra la estructura completa de archivos para este proyecto.

Nota :

• Icono verde redondeado ‘I’ Los botones son interfaz
• Los botones ‘C’ de icono redondeado azul son clases

Paso 4: dentro del paquete de entidad

Se realiza mediante la creación de una clase POJO simple dentro del archivo Person.java.

package com.demo.entites;
 
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
    private Integer personId;
    private String personName;
    private String personCity;
}

Paso 5: dentro del paquete del repositorio

Cree una interfaz simple y nombre la interfaz como PersonRepo. Esta interfaz va a extender el JpaRepository.

package com.demo.repo;
 
import com.demo.entites.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> {
    @Query(
        "SELECT CASE WHEN COUNT(s) > 0 THEN TRUE ELSE FALSE END FROM Person s WHERE s.personId = ?1")
    Boolean
    isPersonExitsById(Integer id);
}

Paso 6: Dentro del paquete de servicios

Dentro del paquete, cree una clase llamada PersonService . 

package com.demo.services;
 
import com.demo.entites.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 {
 
    @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;
    }
}

Paso 7: Dentro del paquete del controlador

Dentro del paquete, cree una clase llamada PersonController.

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;
 
@RestController
public class PersonController {
 
    @Autowired
    private PersonService personService;
 
    @GetMapping("/persons")
    public ResponseEntity<?> getAllPersons() {
        return ResponseEntity.ok(this.personService.getAllPerson());
    }
}

Paso 8: a continuación se muestra el código para el archivo application.properties

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

Ahora su proyecto de arranque de primavera de muestra está listo y vamos a realizar pruebas unitarias en este proyecto de muestra. 

Paso 9: cree los siguientes paquetes y las clases como se muestra en la imagen a continuación. (Dentro de la caja de color verde)

Paso 10: Prueba unitaria de la clase de repositorio

Dentro del paquete test > repo crea una clase llamada PersonRepoTest . 

package com.demo.repo;
 
import com.demo.entites.Person;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
 
import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
 
@SpringBootTest
class PersonRepoTest {
 
    @Autowired
    private PersonRepo personRepo;
 
    @Test
    void isPersonExitsById() {
        Person person = new Person(1001, "Amiya", "Bhubaneswar");
        personRepo.save(person);
        Boolean actualResult = personRepo.isPersonExitsById(1001);
        assertThat(actualResult).isTrue();
    }
}

Paso 11: Prueba unitaria de la clase de servicio

Dentro del paquete test > services crea una clase llamada PersonServiceTest . 

// Java Program to Illustrate Unit Testing of Service Class
 
package 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 class
class 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();
    }
}

Del mismo modo, podemos realizar pruebas de diferentes unidades de su proyecto Spring Boot.