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

Organitzant el Codi de Test

Següent ►
►

Organitzar el codi de test és crucial per mantenir la claredat, la mantenibilitat i l'eficàcia dels teus tests. En aquesta secció, explorarem les millors pràctiques per estructurar i organitzar el codi de test en els teus projectes.

  1. Estructura de Directoris

Una bona pràctica és mantenir els tests en un directori separat del codi de producció. Això ajuda a mantenir el codi net i facilita la navegació. Una estructura comuna és la següent:

/project-root
    /src
        /main
            /java
                /com
                    /example
                        /app
                            App.java
        /test
            /java
                /com
                    /example
                        /app
                            AppTest.java

Avantatges:

  • Separació clara: Manté el codi de producció i el codi de test separats.
  • Facilita la navegació: És fàcil trobar els tests corresponents a cada classe de producció.

  1. Nomenclatura de Classes de Test

Utilitza una convenció de nomenclatura consistent per a les classes de test. Una pràctica comuna és afegir el sufix Test al nom de la classe que s'està testant.

Exemple:

// Classe de producció
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

// Classe de test
public class CalculatorTest {
    @Test
    public void testAdd() {
        Calculator calculator = new Calculator();
        assertEquals(5, calculator.add(2, 3));
    }
}

  1. Agrupació de Tests

Agrupa els tests relacionats en la mateixa classe de test. Això ajuda a mantenir el codi organitzat i facilita la comprensió de què s'està testant.

Exemple:

public class CalculatorTest {
    @Test
    public void testAdd() {
        Calculator calculator = new Calculator();
        assertEquals(5, calculator.add(2, 3));
    }

    @Test
    public void testSubtract() {
        Calculator calculator = new Calculator();
        assertEquals(1, calculator.subtract(3, 2));
    }
}

  1. Utilització de Mètodes de Configuració

Utilitza les anotacions @Before, @After, @BeforeClass i @AfterClass per configurar i netejar els recursos necessaris per als tests. Això ajuda a evitar la duplicació de codi i a mantenir els tests nets.

Exemple:

public class CalculatorTest {
    private Calculator calculator;

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

    @After
    public void tearDown() {
        calculator = null;
    }

    @Test
    public void testAdd() {
        assertEquals(5, calculator.add(2, 3));
    }

    @Test
    public void testSubtract() {
        assertEquals(1, calculator.subtract(3, 2));
    }
}

  1. Utilització de Suites de Test

Les suites de test permeten agrupar múltiples classes de test i executar-les juntes. Això és útil per organitzar tests relacionats i executar-los de manera eficient.

Exemple:

@RunWith(Suite.class)
@Suite.SuiteClasses({
    CalculatorTest.class,
    AnotherTest.class
})
public class AllTests {
    // Aquesta classe roman buida, només s'utilitza com a contenidor per a les anotacions.
}

  1. Comentaris i Documentació

Afegeix comentaris i documentació als teus tests per explicar el propòsit de cada test i qualsevol configuració especial. Això ajuda altres desenvolupadors a comprendre el codi de test i facilita la seva mantenibilitat.

Exemple:

public class CalculatorTest {
    private Calculator calculator;

    @Before
    public void setUp() {
        // Inicialitza la instància de Calculator abans de cada test
        calculator = new Calculator();
    }

    @After
    public void tearDown() {
        // Neteja la instància de Calculator després de cada test
        calculator = null;
    }

    @Test
    public void testAdd() {
        // Test per verificar la suma de dos números
        assertEquals(5, calculator.add(2, 3));
    }

    @Test
    public void testSubtract() {
        // Test per verificar la resta de dos números
        assertEquals(1, calculator.subtract(3, 2));
    }
}

Exercici Pràctic

Exercici:

  1. Crea una classe StringUtils amb un mètode isPalindrome(String str) que retorni true si la cadena és un palíndrom i false en cas contrari.
  2. Escriu una classe de test StringUtilsTest per verificar el comportament del mètode isPalindrome.

Solució:

// Classe de producció
public class StringUtils {
    public boolean isPalindrome(String str) {
        if (str == null) {
            return false;
        }
        String reversed = new StringBuilder(str).reverse().toString();
        return str.equals(reversed);
    }
}

// Classe de test
public class StringUtilsTest {
    private StringUtils stringUtils;

    @Before
    public void setUp() {
        stringUtils = new StringUtils();
    }

    @After
    public void tearDown() {
        stringUtils = null;
    }

    @Test
    public void testIsPalindrome() {
        assertTrue(stringUtils.isPalindrome("madam"));
        assertFalse(stringUtils.isPalindrome("hello"));
        assertTrue(stringUtils.isPalindrome("racecar"));
        assertFalse(stringUtils.isPalindrome(null));
    }
}

Conclusió

Organitzar el codi de test de manera efectiva és essencial per mantenir la qualitat i la mantenibilitat dels teus tests. Seguint aquestes pràctiques, podràs escriure tests més clars, nets i fàcils de mantenir. En el proper tema, explorarem el Desenvolupament Guiat per Tests (TDD) i com pot ajudar-te a escriure codi de millor qualitat.

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