El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Framework de Pruebas Spock

Siguiente ►
►

El framework de pruebas Spock es una herramienta poderosa y flexible para realizar pruebas en aplicaciones Groovy y Java. Spock se destaca por su sintaxis clara y expresiva, lo que facilita la escritura y comprensión de las pruebas. En este módulo, aprenderemos a configurar Spock, escribir pruebas básicas y avanzadas, y utilizar sus características más destacadas.

Contenido

  1. Introducción a Spock
  2. Configuración del Entorno
  3. Escribiendo Pruebas Básicas
  4. Pruebas de Interacción
  5. Pruebas de Excepciones
  6. Pruebas de Datos
  7. Ejercicios Prácticos
  8. Conclusión

Introducción a Spock

Spock es un framework de pruebas para Groovy y Java que se basa en JUnit. Ofrece una sintaxis más legible y expresiva, lo que facilita la escritura y el mantenimiento de las pruebas. Algunas de las características clave de Spock incluyen:

  • Sintaxis clara y concisa: Utiliza una DSL (Domain-Specific Language) que hace que las pruebas sean fáciles de leer y escribir.
  • Soporte para pruebas de interacción: Permite verificar cómo interactúan los objetos entre sí.
  • Pruebas de datos: Facilita la creación de pruebas parametrizadas.
  • Integración con JUnit: Se puede ejecutar junto con otras pruebas JUnit.

Configuración del Entorno

Para comenzar a usar Spock, necesitamos agregar las dependencias necesarias a nuestro proyecto. A continuación, se muestra cómo hacerlo en un proyecto Gradle.

Paso 1: Agregar Dependencias

Edita el archivo build.gradle para incluir las dependencias de Spock:

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

Paso 2: Configurar el Plugin de Groovy

Asegúrate de que el plugin de Groovy esté aplicado en tu archivo build.gradle:

plugins {
    id 'groovy'
}

Paso 3: Sincronizar el Proyecto

Sincroniza tu proyecto para descargar las dependencias y aplicar la configuración.

Escribiendo Pruebas Básicas

Las pruebas en Spock se escriben en clases que extienden Specification. A continuación, se muestra un ejemplo básico de una prueba en Spock.

Ejemplo de Prueba Básica

import spock.lang.Specification

class MathSpec extends Specification {
    def "sumar dos números"() {
        expect:
        1 + 1 == 2
    }
}

Explicación del Código

  • class MathSpec extends Specification: Define una clase de prueba que extiende Specification.
  • def "sumar dos números"(): Define un método de prueba con una descripción legible.
  • expect:: Bloque que contiene las expectativas de la prueba.

Pruebas de Interacción

Spock permite verificar cómo interactúan los objetos entre sí mediante mocks y stubs.

Ejemplo de Prueba de Interacción

import spock.lang.Specification

class UserServiceSpec extends Specification {
    def "debería llamar al repositorio para guardar el usuario"() {
        given:
        def userRepository = Mock(UserRepository)
        def userService = new UserService(userRepository)

        when:
        userService.saveUser(new User(name: "John Doe"))

        then:
        1 * userRepository.save(_)
    }
}

Explicación del Código

  • given:: Bloque que configura el estado inicial de la prueba.
  • when:: Bloque que ejecuta la acción a probar.
  • then:: Bloque que verifica las interacciones y resultados esperados.

Pruebas de Excepciones

Spock facilita la verificación de excepciones lanzadas por el código bajo prueba.

Ejemplo de Prueba de Excepción

import spock.lang.Specification

class ExceptionSpec extends Specification {
    def "debería lanzar una excepción cuando el divisor es cero"() {
        when:
        int result = 1 / 0

        then:
        thrown(ArithmeticException)
    }
}

Explicación del Código

  • thrown(ArithmeticException): Verifica que se lance una ArithmeticException.

Pruebas de Datos

Spock permite crear pruebas parametrizadas utilizando el bloque where:.

Ejemplo de Prueba de Datos

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

class DataDrivenSpec extends Specification {
    @Unroll
    def "sumar #a y #b debería ser #c"() {
        expect:
        a + b == c

        where:
        a | b || c
        1 | 2 || 3
        4 | 5 || 9
        7 | 8 || 15
    }
}

Explicación del Código

  • @Unroll: Anotación que desglosa las pruebas parametrizadas para una mejor legibilidad.
  • where:: Bloque que define los datos de entrada y los resultados esperados.

Ejercicios Prácticos

Ejercicio 1: Prueba Básica

Escribe una prueba que verifique que la multiplicación de dos números es correcta.

import spock.lang.Specification

class MultiplicationSpec extends Specification {
    def "multiplicar dos números"() {
        expect:
        2 * 3 == 6
    }
}

Ejercicio 2: Prueba de Interacción

Crea una prueba que verifique que un servicio llama a un repositorio para eliminar un usuario.

import spock.lang.Specification

class UserServiceSpec extends Specification {
    def "debería llamar al repositorio para eliminar el usuario"() {
        given:
        def userRepository = Mock(UserRepository)
        def userService = new UserService(userRepository)

        when:
        userService.deleteUser(1)

        then:
        1 * userRepository.delete(1)
    }
}

Ejercicio 3: Prueba de Excepción

Escribe una prueba que verifique que se lanza una NullPointerException cuando se intenta acceder a un método de un objeto nulo.

import spock.lang.Specification

class NullPointerSpec extends Specification {
    def "debería lanzar una NullPointerException"() {
        when:
        String str = null
        str.length()

        then:
        thrown(NullPointerException)
    }
}

Ejercicio 4: Prueba de Datos

Crea una prueba parametrizada que verifique la resta de dos números.

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

class SubtractionSpec extends Specification {
    @Unroll
    def "restar #a y #b debería ser #c"() {
        expect:
        a - b == c

        where:
        a | b || c
        5 | 3 || 2
        10 | 4 || 6
        7 | 2 || 5
    }
}

Conclusión

En este módulo, hemos explorado el framework de pruebas Spock, desde su configuración hasta la escritura de pruebas básicas y avanzadas. Spock ofrece una sintaxis clara y poderosa que facilita la creación de pruebas efectivas y mantenibles. Con los ejercicios prácticos, has tenido la oportunidad de aplicar lo aprendido y reforzar tus habilidades en la escritura de pruebas con Spock.

En el próximo módulo, exploraremos el framework Grails, una poderosa herramienta para el desarrollo web con Groovy. ¡Sigue adelante y sigue aprendiendo!

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados