0Pricing
Lua Academy · Aula

Cobertura de código e instrumentação de testes

Meça a cobertura de testes com luacov e interprete os relatórios de cobertura.

Cobertura de código e instrumentação de testes é 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.

O que é cobertura de código?

A cobertura de código mede quais linhas, ramificações ou funções do seu código são executadas pelos testes. Uma cobertura alta aumenta a confiança de que os testes estão exercitando bem o código.

luacov: a ferramenta padrão

luacov é a ferramenta padrão de cobertura do Lua. Ela se conecta à camada de depuração do Lua e registra quais linhas são executadas.

-- Run with luacov:
luacov script.lua
-- Or require at the start of the test file:
require("luacov")

Uso do luacov com um executor de testes

Com o busted ou um executor personalizado, carregue o luacov no início, e ele registrará a cobertura automaticamente.

-- spec/all_spec.lua
require("luacov")
describe("my module", function()
  it("does something", function()
    local m = require("mymodule")
    assert.equals(m.add(1,2), 3)
  end)
end)

Geração de um relatório

Depois da execução dos testes, luacov grava um arquivo luacov.stats.out. Execute luacov-reporter para gerar um relatório legível.

# After tests:
luacov-reporter
# Produces luacov.report.out with per-file line coverage

Leitura do relatório

Cada linha mostra: quantidade de acertos, quantidade de falhas e a linha do código-fonte. Linhas com 0 acertos são código não coberto — possível código inativo ou casos de teste ausentes.

Cobertura de ramificações

O luacov acompanha a cobertura de linhas, não a cobertura de ramificações. Para obter cobertura de ramificações, use uma ferramenta mais avançada ou adicione manualmente casos de teste para cada caminho condicional.

Gancho de cobertura personalizado

Crie um registrador mínimo de cobertura com debug.sethook para eventos de linha.

local covered = {}
debug.sethook(function(event, line)
  local info = debug.getinfo(2, "S")
  local src = info.short_src
  covered[src] = covered[src] or {}
  covered[src][line] = (covered[src][line] or 0) + 1
end, "l")
-- ... run tests ...
debug.sethook()

Limiares de cobertura

Defina um limiar mínimo de cobertura na integração contínua (por exemplo, 80%). Faça a compilação falhar se a cobertura ficar abaixo dele. Isso impede o acúmulo acidental de código inativo.

Padrões de instrumentação de testes

Além da cobertura, instrumente os testes com: tempo de execução (para detectar testes lentos), asserções de quantidade de chamadas (para verificar se as funções são chamadas o número esperado de vezes) e captura de valores (para registrar os argumentos passados a funções simuladas).

Simulação para isolamento de testes

Substitua módulos reais por simuladores durante os testes para isolar as unidades. Armazene a função real, substitua-a por um substituto de rastreamento e restaure-a depois do teste.

local realSend = http.send
local calls = {}
http.send = function(...) calls[#calls+1] = {...} end
-- run tests --
http.send = realSend  -- restore
print(#calls, "send calls")

Integração à integração contínua

Execute o luacov no seu processo de integração contínua. Envie os relatórios de cobertura para o Coveralls ou o Codecov para acompanhar as tendências entre as confirmações.

Pergunta sobre cobertura

O que indica uma linha com 0 ocorrências em um relatório do luacov?

Recapitulação: cobertura de código e instrumentação de testes

Use o luacov para registrar a cobertura de linhas e gerar relatórios. Defina limites de cobertura no CI. Adicione instrumentação personalizada com debug.sethook para um acompanhamento especializado. Use simulações para isolar testes unitários e verificar a contagem de chamadas.

Perguntas Frequentes

A aula “Cobertura de código e instrumentação de testes” é grátis?

Sim — o texto completo de “Cobertura de código e instrumentação de testes” é 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 “Cobertura de código e instrumentação de testes”?

Meça a cobertura de testes com luacov e interprete os relatórios de cobertura. 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 “Cobertura de código e instrumentação de testes”?

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

  1. A biblioteca debug em profundidade
  2. Depuração remota com MobDebug
  3. Criação de perfis com LuaProfiler
  4. Cobertura de código e instrumentação de testes
← Voltar para Lua Academy