El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Proves unitàries amb JUnit

Següent ►
►

Les proves unitàries són una part fonamental del desenvolupament de programari, ja que permeten verificar que les unitats individuals de codi funcionen com s'espera. JUnit és un dels marcs de proves més populars per a Java, i s'integra perfectament amb Spring Boot per facilitar la creació i execució de proves unitàries.

Objectius del tema

  • Entendre què són les proves unitàries i per què són importants.
  • Aprendre a configurar JUnit en un projecte Spring Boot.
  • Escriure i executar proves unitàries bàsiques amb JUnit.
  • Utilitzar anotacions de JUnit per gestionar el cicle de vida de les proves.
  • Comprendre com utilitzar Mockito per simular dependències en les proves.

Què són les proves unitàries?

Les proves unitàries són proves automàtiques que verifiquen el funcionament d'una unitat de codi, com ara una funció o un mètode. L'objectiu és assegurar-se que cada unitat de codi funcioni correctament de manera aïllada.

Beneficis de les proves unitàries

  • Detecció primerenca d'errors: Les proves unitàries permeten detectar errors en una fase primerenca del desenvolupament.
  • Facilitat de manteniment: Les proves unitàries ajuden a assegurar que els canvis en el codi no introdueixin nous errors.
  • Documentació: Les proves unitàries poden servir com a documentació del comportament esperat del codi.

Configuració de JUnit en un projecte Spring Boot

Spring Boot ve amb suport integrat per a JUnit. Per començar a utilitzar JUnit, assegura't que el teu projecte tingui les següents dependències en el fitxer pom.xml (per a Maven) o build.gradle (per a Gradle).

Maven

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

Gradle

testImplementation 'org.springframework.boot:spring-boot-starter-test'

Escriure una prova unitària bàsica amb JUnit

A continuació, veurem com escriure una prova unitària bàsica per a un servei de Spring Boot.

Exemple de servei

Suposem que tenim un servei senzill que calcula la suma de dos nombres.

@Service
public class CalculatorService {
    public int add(int a, int b) {
        return a + b;
    }
}

Prova unitària per al servei

Crearem una prova unitària per verificar que el mètode add funciona correctament.

@RunWith(SpringRunner.class)
@SpringBootTest
public class CalculatorServiceTest {

    @Autowired
    private CalculatorService calculatorService;

    @Test
    public void testAdd() {
        int result = calculatorService.add(2, 3);
        assertEquals(5, result);
    }
}

Explicació del codi

  • @RunWith(SpringRunner.class): Indica que la classe de prova utilitza SpringRunner per executar les proves.
  • @SpringBootTest: Carrega el context de l'aplicació de Spring Boot per a les proves.
  • @Autowired: Injecta el CalculatorService en la classe de prova.
  • @Test: Marca el mètode testAdd com una prova unitària.
  • assertEquals(5, result): Verifica que el resultat de calculatorService.add(2, 3) sigui 5.

Utilitzant Mockito per simular dependències

Mockito és una biblioteca popular per a la simulació de dependències en proves unitàries. A continuació, veurem com utilitzar Mockito per simular una dependència en una prova unitària.

Exemple de servei amb dependència

Suposem que el nostre servei de calculadora depèn d'un altre servei per obtenir un valor inicial.

@Service
public class CalculatorService {

    @Autowired
    private InitialValueService initialValueService;

    public int add(int a, int b) {
        return a + b + initialValueService.getInitialValue();
    }
}

Prova unitària amb Mockito

Crearem una prova unitària que simuli el InitialValueService.

@RunWith(SpringRunner.class)
@SpringBootTest
public class CalculatorServiceTest {

    @MockBean
    private InitialValueService initialValueService;

    @Autowired
    private CalculatorService calculatorService;

    @Test
    public void testAdd() {
        Mockito.when(initialValueService.getInitialValue()).thenReturn(10);
        int result = calculatorService.add(2, 3);
        assertEquals(15, result);
    }
}

Explicació del codi

  • @MockBean: Crea una simulació de InitialValueService i l'injecta en el context de Spring.
  • Mockito.when(initialValueService.getInitialValue()).thenReturn(10): Configura la simulació perquè getInitialValue retorni 10.
  • assertEquals(15, result): Verifica que el resultat de calculatorService.add(2, 3) sigui 15, tenint en compte el valor inicial simulat.

Exercicis pràctics

Exercici 1: Escriure una prova unitària per a un mètode de resta

  1. Crea un mètode subtract en el CalculatorService que resti dos nombres.
  2. Escriu una prova unitària per verificar que el mètode subtract funciona correctament.

Exercici 2: Simular una dependència en una prova unitària

  1. Afegeix una nova dependència al CalculatorService que multipliqui el resultat per un factor.
  2. Utilitza Mockito per simular aquesta nova dependència en una prova unitària.

Solucions

Solució a l'exercici 1

Mètode subtract en el CalculatorService

public int subtract(int a, int b) {
    return a - b;
}

Prova unitària per al mètode subtract

@Test
public void testSubtract() {
    int result = calculatorService.subtract(5, 3);
    assertEquals(2, result);
}

Solució a l'exercici 2

Nova dependència en el CalculatorService

@Service
public class CalculatorService {

    @Autowired
    private InitialValueService initialValueService;

    @Autowired
    private MultiplicationFactorService multiplicationFactorService;

    public int add(int a, int b) {
        return (a + b + initialValueService.getInitialValue()) * multiplicationFactorService.getFactor();
    }
}

Prova unitària amb Mockito per a la nova dependència

@RunWith(SpringRunner.class)
@SpringBootTest
public class CalculatorServiceTest {

    @MockBean
    private InitialValueService initialValueService;

    @MockBean
    private MultiplicationFactorService multiplicationFactorService;

    @Autowired
    private CalculatorService calculatorService;

    @Test
    public void testAddWithMultiplicationFactor() {
        Mockito.when(initialValueService.getInitialValue()).thenReturn(10);
        Mockito.when(multiplicationFactorService.getFactor()).thenReturn(2);
        int result = calculatorService.add(2, 3);
        assertEquals(30, result); // (2 + 3 + 10) * 2 = 30
    }
}

Conclusió

En aquesta secció, hem après què són les proves unitàries i com utilitzar JUnit per escriure i executar proves unitàries en un projecte Spring Boot. També hem vist com utilitzar Mockito per simular dependències en les proves. Les proves unitàries són una eina poderosa per assegurar la qualitat del codi i facilitar el manteniment del projecte. En el següent tema, explorarem les proves d'integració per verificar el funcionament conjunt de diverses unitats de codi.

◄ Anterior
◄
Següent ►
►

Curs de Spring Boot

Mòdul 1: Introducció a Spring Boot

Mòdul 2: Conceptes bàsics de Spring Boot

Mòdul 3: Construint serveis web RESTful

Mòdul 4: Accés a dades amb Spring Boot

Mòdul 5: Seguretat a Spring Boot

Mòdul 6: Proves a Spring Boot

Mòdul 7: Funcions avançades de Spring Boot

Mòdul 8: Desplegant aplicacions Spring Boot

Mòdul 9: Rendiment i monitorització

Mòdul 10: Millors pràctiques i consells

El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats