Scala for Backend Engineering & Functional Programming · Lección

Mocking y fixtures

Configuración de pruebas

Mocking y fixtures es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Scala for Backend Engineering & Functional Programming, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.

Configuración y limpieza de pruebas

Muchas pruebas necesitan fixtures compartidos: datos o recursos preparados antes de una prueba y liberados después. ScalaTest ofrece varias formas de gestionar esto sin duplicar el código de configuración.

Fixture simple: solo un método

El fixture más sencillo es un método auxiliar que crea un estado nuevo. Cada prueba lo invoca, lo que garantiza el aislamiento.

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

class StackSpec extends AnyFlatSpec with Matchers {
  def emptyStack(): scala.collection.mutable.Stack[Int] =
    scala.collection.mutable.Stack.empty[Int]

  "a stack" should "start empty" in {
    emptyStack().size shouldBe 0
  }
}

BeforeAndAfter

Mezcle BeforeAndAfter para ejecutar código antes y después de cada prueba mediante bloques before { } y after { }.

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

class DbSpec extends AnyFlatSpec with Matchers with BeforeAndAfter {
  var counter = 0
  before { counter = 10 }
  after  { counter = 0 }

  "counter" should "be initialized" in {
    counter shouldBe 10
  }
}

BeforeAndAfterAll

Para recursos costosos compartidos por todas las pruebas de una suite (una conexión a una base de datos o un servidor integrado), use BeforeAndAfterAll con beforeAll y afterAll.

import org.scalatest.flatspec.AnyFlatSpec
import org.scalatest.BeforeAndAfterAll

class ServerSpec extends AnyFlatSpec with BeforeAndAfterAll {
  override def beforeAll(): Unit = println("start server")
  override def afterAll(): Unit  = println("stop server")

  "server" should "respond" in {
    assert(true)
  }
}

Patrón del fixture prestado

El patrón de préstamo pasa un recurso recién creado al cuerpo de la prueba y garantiza su limpieza mediante finally, incluso si la prueba falla.

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

class FileSpec extends AnyFlatSpec with Matchers {
  def withBuffer(test: StringBuilder => Any): Unit = {
    val buf = new StringBuilder("init")
    try test(buf)
    finally buf.clear()
  }

  "a buffer" should "start with init" in withBuffer { buf =>
    buf.toString shouldBe "init"
  }
}

¿Por qué usar mocks?

Un mock es un sustituto de una dependencia real (una base de datos o un cliente HTTP) para que una prueba unitaria sea rápida y determinista. Puede controlar lo que devuelve el mock y verificar cómo se invocó.

Añadir Mockito

ScalaTest se integra con Mockito mediante scalatestplus. Añada la dependencia y mezcle MockitoSugar.

libraryDependencies += "org.scalatestplus" %% "mockito-5-10" % "3.2.18.0" % Test

Simular un método

Cree un mock y programe su comportamiento con when(...).thenReturn(...). Después, la prueba ejecuta el código que depende de él.

import org.scalatest.flatspec.AnyFlatSpec
import org.scalatest.matchers.should.Matchers
import org.scalatestplus.mockito.MockitoSugar
import org.mockito.Mockito.when

trait Repo { def find(id: Int): String }

class RepoSpec extends AnyFlatSpec with Matchers with MockitoSugar {
  "a repo" should "return stubbed value" in {
    val repo = mock[Repo]
    when(repo.find(1)).thenReturn("Alice")
    repo.find(1) shouldBe "Alice"
  }
}

Verificar interacciones

Además de los valores devueltos, puede verificar que un método se invocó el número de veces esperado con verify.

import org.scalatest.flatspec.AnyFlatSpec
import org.scalatestplus.mockito.MockitoSugar
import org.mockito.Mockito.{verify, times}

trait Logger { def log(msg: String): Unit }

class LogSpec extends AnyFlatSpec with MockitoSugar {
  "a service" should "log once" in {
    val logger = mock[Logger]
    logger.log("hi")
    verify(logger, times(1)).log("hi")
  }
}

Mocks frente a stubs y fakes

Terminología:

Stub: devuelve respuestas predefinidas.
Mock: también permite verificar las interacciones.
Fake: una implementación funcional y ligera (por ejemplo, un repositorio en memoria).

Prefiera fakes u objetos reales cuando sea sencillo; use mocks solo para dependencias externas reales.

Mantener las pruebas aisladas

Los fixtures y los mocks persiguen un objetivo: que cada prueba se ejecute en un estado conocido e independiente. Restablezca el estado mutable compartido antes de cada prueba y evite compartir fixtures mutables entre pruebas para prevenir fallos inestables y dependientes del orden.

Comprobación rápida

Compruebe sus conocimientos sobre fixtures y mocking.

Resumen

Ha aprendido sobre fixtures y mocking:

Fixtures: métodos auxiliares, BeforeAndAfter, BeforeAndAfterAll y el patrón de préstamo.
Mocks (mediante MockitoSugar): simule con when().thenReturn() y compruebe las invocaciones con verify.
Prefiera fakes para casos sencillos; use mocks para dependencias externas.
Mantenga cada prueba aislada e independiente del orden.

Preguntas frecuentes

¿La lección «Mocking y fixtures» es gratis?

Sí — el texto completo de «Mocking y fixtures» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Scala for Backend Engineering & Functional Programming, actualiza a CoddyKit PRO. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.

¿Qué aprenderé en «Mocking y fixtures»?

Configuración de pruebas Practicas Scala for Backend Engineering & Functional Programming con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Scala for Backend Engineering & Functional Programming?

No se requiere experiencia previa. Scala for Backend Engineering & Functional Programming en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Mocking y fixtures»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Scala for Backend Engineering & Functional Programming?

Sí. Cada lección de Scala for Backend Engineering & Functional Programming incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Scala for Backend Engineering & Functional Programming