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

Escrivint Tests Efectius

Següent ►
►

En aquest tema, aprendrem com escriure tests efectius que no només validin el comportament del nostre codi, sinó que també siguin fàcils de mantenir i comprendre. Els tests efectius són una part crucial del desenvolupament de programari, ja que ens ajuden a detectar errors de manera primerenca i assegurar-nos que el nostre codi funcioni com s'espera.

  1. Principis de Tests Efectius

1.1. Claredat i Simplicitat

  • Nom descriptiu: Els noms dels tests han de ser descriptius i indicar clarament què estan provant.
  • Un sol cas de prova per test: Cada test ha de provar un sol cas de prova per mantenir la simplicitat i facilitar la identificació d'errors.

1.2. Independència

  • Tests independents: Els tests han de ser independents entre si. L'ordre d'execució no ha d'afectar els resultats dels tests.
  • Configuració i neteja: Utilitza les anotacions @Before, @After, @BeforeClass i @AfterClass per configurar i netejar l'entorn de prova.

1.3. Repetibilitat

  • Resultats consistents: Els tests han de produir els mateixos resultats cada vegada que s'executen, independentment de l'entorn o l'ordre d'execució.

1.4. Ràpids

  • Temps d'execució: Els tests han de ser ràpids per permetre una retroalimentació ràpida durant el desenvolupament.

  1. Estructura d'un Test Efectiu

Un test efectiu generalment segueix l'estructura AAA (Arrange, Act, Assert):

2.1. Arrange (Preparació)

  • Configura l'entorn de prova i inicialitza les dades necessàries.

2.2. Act (Acció)

  • Executa el codi que vols provar.

2.3. Assert (Verificació)

  • Verifica que els resultats obtinguts siguin els esperats.

  1. Exemple Pràctic

A continuació, es mostra un exemple pràctic d'un test efectiu utilitzant JUnit:

import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

public class CalculatorTest {

    private Calculator calculator;

    @BeforeEach
    public void setUp() {
        calculator = new Calculator();
    }

    @Test
    public void testAddition() {
        // Arrange
        int a = 5;
        int b = 3;

        // Act
        int result = calculator.add(a, b);

        // Assert
        assertEquals(8, result, "5 + 3 should equal 8");
    }

    @Test
    public void testSubtraction() {
        // Arrange
        int a = 5;
        int b = 3;

        // Act
        int result = calculator.subtract(a, b);

        // Assert
        assertEquals(2, result, "5 - 3 should equal 2");
    }
}

Explicació del Codi

  • @BeforeEach: Configura l'entorn de prova inicialitzant una instància de Calculator abans de cada test.
  • testAddition: Prova la funcionalitat d'addició de la calculadora.
    • Arrange: Inicialitza les variables a i b.
    • Act: Executa el mètode add de la calculadora.
    • Assert: Verifica que el resultat sigui 8.
  • testSubtraction: Prova la funcionalitat de substracció de la calculadora.
    • Arrange: Inicialitza les variables a i b.
    • Act: Executa el mètode subtract de la calculadora.
    • Assert: Verifica que el resultat sigui 2.

  1. Exercicis Pràctics

Exercici 1: Test de Multiplicació

Escriu un test per a la funcionalitat de multiplicació de la classe Calculator.

Solució

@Test
public void testMultiplication() {
    // Arrange
    int a = 5;
    int b = 3;

    // Act
    int result = calculator.multiply(a, b);

    // Assert
    assertEquals(15, result, "5 * 3 should equal 15");
}

Exercici 2: Test de Divisió

Escriu un test per a la funcionalitat de divisió de la classe Calculator, assegurant-te de manejar la divisió per zero.

Solució

@Test
public void testDivision() {
    // Arrange
    int a = 6;
    int b = 3;

    // Act
    int result = calculator.divide(a, b);

    // Assert
    assertEquals(2, result, "6 / 3 should equal 2");
}

@Test
public void testDivisionByZero() {
    // Arrange
    int a = 6;
    int b = 0;

    // Act & Assert
    assertThrows(ArithmeticException.class, () -> {
        calculator.divide(a, b);
    }, "Division by zero should throw ArithmeticException");
}

  1. Errors Comuns i Consells

Errors Comuns

  • No inicialitzar correctament l'entorn de prova: Assegura't que cada test comenci amb un entorn net.
  • Provar múltiples casos en un sol test: Divideix els tests en múltiples mètodes per mantenir la claredat.
  • No manejar excepcions esperades: Utilitza assertThrows per verificar que es llencin les excepcions esperades.

Consells

  • Utilitza noms descriptius: Els noms dels tests han de ser clars i indicar què estan provant.
  • Refactoritza els tests: Mantingues els tests nets i llegibles, refactoritzant-los quan sigui necessari.
  • Executa els tests freqüentment: Executa els tests sovint per detectar errors de manera primerenca.

Conclusió

Escriure tests efectius és una habilitat essencial per a qualsevol desenvolupador. Seguint els principis i les pràctiques descrites en aquest tema, podràs crear tests que no només validin el teu codi, sinó que també siguin fàcils de mantenir i comprendre. Practica escrivint tests per a diferents casos i escenaris per millorar les teves habilitats en testing.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats