Scala for Backend Engineering & Functional Programming · Aula

Mocks e fixtures

Configuração de testes.

Mocks e fixtures é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

Preparação e limpeza de testes

Muitos testes precisam de dispositivos de teste compartilhados: dados ou recursos preparados antes de um teste e limpos depois dele. O ScalaTest oferece várias formas de gerenciá-los sem duplicar o código de preparação.

Dispositivo simples: apenas um método

O dispositivo mais simples é um método auxiliar que cria um estado novo. Cada teste o chama, garantindo o isolamento.

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

Misture BeforeAndAfter para executar código antes e depois de cada teste usando blocos before { } e 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 dispendiosos compartilhados entre todos os testes de uma suíte (uma conexão de banco de dados ou um servidor incorporado), use BeforeAndAfterAll com beforeAll e 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)
  }
}

Padrão do dispositivo emprestado

O padrão de empréstimo passa um recurso recém-criado ao corpo do teste e garante a limpeza em um finally, mesmo que o teste falhe.

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 que usar simulações?

Uma simulação é um substituto para uma dependência real (um banco de dados ou cliente HTTP), para que um teste unitário permaneça rápido e determinístico. Você controla o que a simulação retorna e verifica como ela foi chamada.

Adicionando Mockito

O ScalaTest se integra ao Mockito por meio de scalatestplus. Adicione a dependência e misture MockitoSugar.

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

Configurando o comportamento de um método

Crie uma simulação e programe seu comportamento com when(...).thenReturn(...). Em seguida, o teste exercita o código que depende dela.

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"
  }
}

Verificando interações

Além dos valores retornados, você pode verificar se um método foi chamado o número esperado de vezes com 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")
  }
}

Simulações, substitutos e falsificações

Terminologia:

Substituto: retorna respostas predefinidas.
Simulação: também permite verificar interações.
Falsificação: uma implementação funcional leve (por exemplo, um repositório em memória).

Prefira falsificações ou objetos reais quando for simples; use simulações apenas para dependências externas reais.

Mantendo os testes isolados

Dispositivos e simulações têm um objetivo: cada teste deve ser executado em um estado conhecido e independente. Redefina o estado mutável compartilhado antes de cada teste e evite compartilhar dispositivos mutáveis entre testes para prevenir falhas instáveis e dependentes da ordem.

Verificação rápida

Teste seus conhecimentos sobre dispositivos e simulações.

Recapitulação

Você aprendeu sobre dispositivos e simulações:

Dispositivos: métodos auxiliares, BeforeAndAfter, BeforeAndAfterAll e o padrão de empréstimo.
Simulações (por meio de MockitoSugar): configure substitutos com when().thenReturn() e verifique chamadas com verify.
Prefira falsificações em casos simples; use simulações para dependências externas.
Mantenha cada teste isolado e independente da ordem.

Perguntas Frequentes

A aula “Mocks e fixtures” é grátis?

Sim — o texto completo de “Mocks e fixtures” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

O que vou aprender em “Mocks e fixtures”?

Configuração de testes. Você pratica Scala for Backend Engineering & Functional Programming com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Scala for Backend Engineering & Functional Programming?

Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Mocks e fixtures”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Scala for Backend Engineering & Functional Programming?

Sim. Cada aula de Scala for Backend Engineering & Functional Programming inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Scala for Backend Engineering & Functional Programming