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

Pruebas en Scala

Siguiente ►
►

Las pruebas son una parte fundamental del desarrollo de software, ya que aseguran que el código funcione como se espera y ayuda a prevenir errores en el futuro. En Scala, existen varias bibliotecas y herramientas que facilitan la creación y ejecución de pruebas. En esta sección, aprenderemos sobre las pruebas en Scala utilizando ScalaTest, una de las bibliotecas de pruebas más populares.

Contenido

  1. Introducción a ScalaTest
  2. Configuración del Entorno de Pruebas
  3. Escribiendo Pruebas Básicas
  4. Pruebas de Unidades
  5. Pruebas de Integración
  6. Pruebas de Propiedades
  7. Ejercicios Prácticos
  8. Conclusión

Introducción a ScalaTest

ScalaTest es una biblioteca de pruebas flexible y potente para Scala. Permite escribir pruebas de diferentes estilos, como pruebas de unidades, pruebas de integración y pruebas de propiedades. ScalaTest se integra bien con otras herramientas de construcción y ejecución de pruebas, como SBT (Scala Build Tool).

Características de ScalaTest

  • Flexibilidad: Soporta múltiples estilos de pruebas (BDD, TDD, etc.).
  • Integración: Compatible con SBT, Maven y otras herramientas de construcción.
  • Extensibilidad: Permite la creación de componentes personalizados para pruebas.

Configuración del Entorno de Pruebas

Para comenzar a usar ScalaTest, primero debemos configurar nuestro entorno de desarrollo. En este ejemplo, utilizaremos SBT para gestionar las dependencias y ejecutar las pruebas.

Paso 1: Crear un Proyecto SBT

Si aún no tienes un proyecto SBT, crea uno con la siguiente estructura:

my-project/
├── build.sbt
├── project/
│   └── build.properties
└── src/
    ├── main/
    │   └── scala/
    └── test/
        └── scala/

Paso 2: Añadir Dependencias de ScalaTest

Edita el archivo build.sbt para incluir las dependencias de ScalaTest:

name := "MyProject"

version := "0.1"

scalaVersion := "2.13.6"

libraryDependencies += "org.scalatest" %% "scalatest" % "3.2.9" % "test"

Paso 3: Crear un Archivo de Prueba

Crea un archivo de prueba en src/test/scala/ExampleSpec.scala:

import org.scalatest.flatspec.AnyFlatSpec
import org.scalatest.matchers.should.Matchers

class ExampleSpec extends AnyFlatSpec with Matchers {
  "An empty Set" should "have size 0" in {
    Set.empty.size should be (0)
  }

  it should "produce NoSuchElementException when head is invoked" in {
    a [NoSuchElementException] should be thrownBy {
      Set.empty.head
    }
  }
}

Paso 4: Ejecutar las Pruebas

Para ejecutar las pruebas, usa el siguiente comando en la terminal:

sbt test

Escribiendo Pruebas Básicas

En ScalaTest, las pruebas se escriben en clases que extienden uno de los muchos estilos de prueba disponibles. En este curso, nos centraremos en el estilo FlatSpec con Matchers, que es fácil de entender y usar.

Ejemplo de Prueba Básica

import org.scalatest.flatspec.AnyFlatSpec
import org.scalatest.matchers.should.Matchers

class CalculatorSpec extends AnyFlatSpec with Matchers {
  "A Calculator" should "add two numbers correctly" in {
    val sum = 1 + 1
    sum should be (2)
  }

  it should "subtract two numbers correctly" in {
    val difference = 5 - 3
    difference should be (2)
  }
}

Explicación del Código

  • AnyFlatSpec: Un estilo de prueba que permite escribir pruebas en un formato plano y legible.
  • Matchers: Proporciona una sintaxis fluida para las aserciones (should be, should equal, etc.).
  • in: Define el cuerpo de la prueba.

Pruebas de Unidades

Las pruebas de unidades verifican el comportamiento de componentes individuales del código, como funciones o métodos.

Ejemplo de Prueba de Unidad

class MathUtilsSpec extends AnyFlatSpec with Matchers {
  "MathUtils.add" should "return the sum of two numbers" in {
    val result = MathUtils.add(2, 3)
    result should be (5)
  }
}

object MathUtils {
  def add(a: Int, b: Int): Int = a + b
}

Explicación del Código

  • MathUtils.add: Método que suma dos números.
  • result should be (5): Aserción que verifica que el resultado es 5.

Pruebas de Integración

Las pruebas de integración verifican que diferentes componentes del sistema funcionen juntos correctamente.

Ejemplo de Prueba de Integración

class DatabaseSpec extends AnyFlatSpec with Matchers {
  "Database.connect" should "establish a connection to the database" in {
    val connection = Database.connect()
    connection should not be (null)
  }
}

object Database {
  def connect(): Connection = {
    // Simulación de conexión a la base de datos
    new Connection()
  }
}

class Connection

Explicación del Código

  • Database.connect: Método que simula una conexión a la base de datos.
  • connection should not be (null): Aserción que verifica que la conexión no es nula.

Pruebas de Propiedades

Las pruebas de propiedades verifican que una propiedad se mantenga para una amplia gama de entradas.

Ejemplo de Prueba de Propiedad

import org.scalatest.propspec.AnyPropSpec
import org.scalatest.prop.TableDrivenPropertyChecks

class StringSpec extends AnyPropSpec with TableDrivenPropertyChecks with Matchers {
  val examples = Table(
    ("input", "expectedLength"),
    ("", 0),
    ("Scala", 5),
    ("Property-based testing", 21)
  )

  property("String length should be correct") {
    forAll(examples) { (input: String, expectedLength: Int) =>
      input.length should be (expectedLength)
    }
  }
}

Explicación del Código

  • TableDrivenPropertyChecks: Permite definir tablas de ejemplos para pruebas basadas en propiedades.
  • forAll: Itera sobre los ejemplos y ejecuta la prueba para cada uno.

Ejercicios Prácticos

Ejercicio 1: Prueba de Unidad

Escribe una prueba de unidad para una función que multiplique dos números.

object MathUtils {
  def multiply(a: Int, b: Int): Int = a * b
}

class MathUtilsSpec extends AnyFlatSpec with Matchers {
  "MathUtils.multiply" should "return the product of two numbers" in {
    val result = MathUtils.multiply(2, 3)
    result should be (6)
  }
}

Ejercicio 2: Prueba de Integración

Escribe una prueba de integración para una función que obtenga un usuario de una base de datos simulada.

case class User(id: Int, name: String)

object Database {
  def getUser(id: Int): User = {
    // Simulación de obtención de usuario
    User(id, "John Doe")
  }
}

class DatabaseSpec extends AnyFlatSpec with Matchers {
  "Database.getUser" should "return a user with the given id" in {
    val user = Database.getUser(1)
    user.id should be (1)
    user.name should be ("John Doe")
  }
}

Conclusión

En esta sección, hemos aprendido sobre la importancia de las pruebas en el desarrollo de software y cómo utilizar ScalaTest para escribir y ejecutar pruebas en Scala. Hemos cubierto pruebas básicas, pruebas de unidades, pruebas de integración y pruebas de propiedades. Con esta base, estarás preparado para escribir pruebas efectivas que aseguren la calidad de tu código.

En la siguiente sección, exploraremos el Play Framework, un marco de trabajo para construir aplicaciones web en Scala.

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