Lua Academy · Aula

Mocks e spies

Isole o código em teste.

Mocks e spies é uma aula grátis de Lua Academy 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 Lua Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Lua Academy inclui 4 aulas no total.

Dublês de teste

Às vezes, uma função depende de algo lento ou externo, como uma chamada de rede ou um registrador. Os dublês de teste substituem essas dependências por substitutos controláveis.

O busted fornece três tipos: espiões, substitutos e simulações. Cada um atende a uma necessidade diferente.

O que um spy faz

Um spy envolve uma função e registra como ela é chamada, enquanto ainda executa a função original. Isso permite verificar se algo foi chamado.

Crie um com spy.new em torno de uma função ou monitore um campo de uma tabela.

local s = spy.new(function() end)
s(1, 2)
assert.spy(s).was.called()

Monitorando um método

Use spy.on para monitorar um método em uma tabela existente. O método original ainda é executado, mas o busted acompanha cada chamada.

Isso é ideal para confirmar um efeito colateral, como a chamada de um registrador.

spy.on(logger, "info")
service.run()
assert.spy(logger.info).was.called()

Verificando a quantidade de chamadas

Os spies registram quantas vezes foram chamados. Use was.called(n) para verificar uma quantidade exata.

Isso detecta erros em que uma função é chamada vezes demais ou não é chamada.

assert.spy(s).was.called(2)
assert.spy(s).was_not.called()

Verificando os argumentos das chamadas

Você pode verificar quais argumentos um spy recebeu usando was.called_with. O busted compara os argumentos registrados com o que você esperava.

Isso verifica não apenas se uma função foi executada, mas também se foi executada corretamente.

local s = spy.new(function() end)
s("user", 42)
assert.spy(s).was.called_with("user", 42)

O que um stub faz

Um stub substitui completamente uma função, portanto a original nunca é executada. Use-o para ignorar operações lentas ou indesejadas, como o acesso real à rede ou ao disco.

Crie um com stub em um campo de tabela. Por padrão, o stub não faz nada e retorna nil.

stub(api, "fetch")
service.load()
assert.stub(api.fetch).was.called()

Valores retornados por stubs

Você pode fazer um stub retornar um valor fixo com returns. Isso fornece dados controlados ao código em teste.

Assim, o teste não depende da dependência real.

stub(api, "fetch").returns({id = 1})
local r = service.load()
assert.are.same({id = 1}, r)

O que um mock faz

Um mock recebe uma tabela existente e transforma todas as suas funções em spies ou stubs de uma só vez. É uma forma conveniente de acompanhar um objeto inteiro.

Chame mock(obj) para envolvê-lo e depois faça asserções sobre métodos individuais.

local m = mock(realLogger)
app.start(m)
assert.spy(m.warn).was.called()

Mock com métodos substituídos

Passar true como segundo argumento para mock substitui todos os métodos por substitutos, portanto nenhum dos originais é executado. Isso isola completamente o objeto.

Use essa opção quando os métodos reais tiverem efeitos colaterais que você precise evitar.

local db = mock(database, true)
db.query.returns({})
assert.are.same({}, repo.all())

Restaurando dublês

Spies, stubs e mocks alteram tabelas compartilhadas, portanto você precisa restaurá-los; caso contrário, os testes seguintes verão o dublê. Chame :revert() ou mock.revert.

Coloque a restauração em after_each para garantir um estado limpo entre os testes.

after_each(function()
  mock.revert(m)
end)

Escolhendo o dublê certo

Use um spy para observar uma função real, um stub para substituí-la por um comportamento controlado e um mock para envolver um objeto inteiro de uma só vez.

Prefira o dublê mais simples que resolva o problema. O uso excessivo de mocks pode tornar os testes frágeis e ocultar erros reais.

describe("mailer", function()
  it("sends once", function()
    local s = spy.on(smtp, "send")
    mailer.notify("a@b.com")
    assert.spy(s).was.called(1)
  end)
end)

Verificação rápida

Teste sua compreensão dos dublês de teste do busted.

Recapitulação

Os dublês de teste isolam o código de dependências lentas ou externas. Um spy registra chamadas enquanto executa a função original, um stub substitui uma função por um comportamento controlado e um mock envolve um objeto inteiro.

Faça asserções com was.called e was.called_with e sempre restaure os dublês com revert em after_each para manter os testes isolados.

Perguntas Frequentes

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

Sim — o texto completo de “Mocks e spies” é 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 Lua Academy, atualize para CoddyKit PRO. O curso de Lua Academy inclui 4 aulas no total.

O que vou aprender em “Mocks e spies”?

Isole o código em teste. Você pratica Lua Academy 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 Lua Academy?

Nenhuma experiência prévia é necessária. Lua Academy 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 spies”?

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 Lua Academy?

Sim. Cada aula de Lua Academy 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 Lua Academy