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

Proves Unitàries amb Groovy

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 funcionin correctament. En aquest mòdul, aprendrem com escriure i executar proves unitàries en Groovy utilitzant el framework de proves Spock, que és molt popular en l'ecosistema Groovy.

Continguts

  1. Introducció a les Proves Unitàries
  2. Configuració de Spock
  3. Estructura d'una Prova Spock
  4. Escriure Proves Bàsiques
  5. Assertions i Expectatives
  6. Proves Parametritzades
  7. Exercicis Pràctics

  1. Introducció a les Proves Unitàries

Les proves unitàries són proves automàtiques que verifiquen el comportament d'una petita part del codi, com ara una funció o un mètode. Aquestes proves ajuden a detectar errors de manera primerenca i faciliten el manteniment del codi.

Beneficis de les Proves Unitàries

  • Detecció primerenca d'errors: Les proves unitàries permeten identificar errors en fases inicials del desenvolupament.
  • Facilitat de manteniment: Amb proves unitàries, és més fàcil refactoritzar el codi sense introduir nous errors.
  • Documentació: Les proves unitàries serveixen com a documentació viva del comportament del codi.

  1. Configuració de Spock

Spock és un framework de proves per a Groovy i Java que combina les millors característiques de JUnit i Mockito. Per començar a utilitzar Spock, necessitem afegir les dependències necessàries al nostre projecte.

Configuració amb Gradle

Afegiu les següents dependències al fitxer build.gradle:

dependencies {
    testImplementation 'org.spockframework:spock-core:2.0-groovy-3.0'
    testImplementation 'org.codehaus.groovy:groovy-all:3.0.7'
}

Configuració amb Maven

Afegiu les següents dependències al fitxer pom.xml:

<dependencies>
    <dependency>
        <groupId>org.spockframework</groupId>
        <artifactId>spock-core</artifactId>
        <version>2.0-groovy-3.0</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.codehaus.groovy</groupId>
        <artifactId>groovy-all</artifactId>
        <version>3.0.7</version>
    </dependency>
</dependencies>

  1. Estructura d'una Prova Spock

Una prova Spock es compon de diverses seccions que descriuen el comportament esperat del codi. Les seccions més comunes són:

  • setup: Inicialitza l'estat necessari per a les proves.
  • when: Descriu l'acció que es vol provar.
  • then: Verifica el resultat de l'acció.
  • expect: Combina les seccions when i then en una sola.

Exemple Bàsic

import spock.lang.Specification

class CalculatorSpec extends Specification {

    def "sumar dos nombres"() {
        setup:
        def calculator = new Calculator()

        when:
        def result = calculator.add(2, 3)

        then:
        result == 5
    }
}

  1. Escriure Proves Bàsiques

Exemple de Prova Bàsica

Suposem que tenim una classe Calculator amb un mètode add que suma dos nombres. Escriurem una prova per verificar aquest comportament.

class Calculator {
    int add(int a, int b) {
        return a + b
    }
}

Prova per al Mètode add

import spock.lang.Specification

class CalculatorSpec extends Specification {

    def "sumar dos nombres"() {
        setup:
        def calculator = new Calculator()

        when:
        def result = calculator.add(2, 3)

        then:
        result == 5
    }
}

  1. Assertions i Expectatives

Spock proporciona diverses maneres de fer assertions i establir expectatives sobre el comportament del codi.

Assertions

Les assertions es fan a la secció then o expect de la prova.

then:
result == 5

Expectatives

Les expectatives es poden utilitzar per combinar les seccions when i then.

expect:
calculator.add(2, 3) == 5

  1. Proves Parametritzades

Les proves parametritzades permeten executar la mateixa prova amb diferents conjunts de dades.

Exemple de Prova Parametritzada

import spock.lang.Specification
import spock.lang.Unroll

class CalculatorSpec extends Specification {

    @Unroll
    def "sumar #a i #b ha de donar #result"() {
        setup:
        def calculator = new Calculator()

        expect:
        calculator.add(a, b) == result

        where:
        a | b || result
        1 | 1 || 2
        2 | 3 || 5
        3 | 4 || 7
    }
}

  1. Exercicis Pràctics

Exercici 1: Escriure una Prova per a la Multiplicació

  1. Creeu una classe Calculator amb un mètode multiply que multipliqui dos nombres.
  2. Escriu una prova Spock per verificar el comportament del mètode multiply.

Solució

class Calculator {
    int multiply(int a, int b) {
        return a * b
    }
}

import spock.lang.Specification

class CalculatorSpec extends Specification {

    def "multiplicar dos nombres"() {
        setup:
        def calculator = new Calculator()

        when:
        def result = calculator.multiply(2, 3)

        then:
        result == 6
    }
}

Exercici 2: Prova Parametritzada per a la Divisió

  1. Afegiu un mètode divide a la classe Calculator que divideixi dos nombres.
  2. Escriu una prova parametritzada per verificar el comportament del mètode divide.

Solució

class Calculator {
    int divide(int a, int b) {
        return a / b
    }
}

import spock.lang.Specification
import spock.lang.Unroll

class CalculatorSpec extends Specification {

    @Unroll
    def "dividir #a per #b ha de donar #result"() {
        setup:
        def calculator = new Calculator()

        expect:
        calculator.divide(a, b) == result

        where:
        a | b || result
        6 | 2 || 3
        9 | 3 || 3
        8 | 4 || 2
    }
}

Conclusió

En aquest tema, hem après com configurar i utilitzar Spock per escriure proves unitàries en Groovy. Hem vist com estructurar una prova Spock, fer assertions i expectatives, i escriure proves parametritzades. Les proves unitàries són una eina poderosa per assegurar la qualitat del codi i facilitar el manteniment del projecte.

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