0Pricing
Lua Academy · Leçon

Couverture du code et instrumentation des tests

Mesurez la couverture des tests avec luacov et interprétez les rapports de couverture.

Couverture du code et instrumentation des tests est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Lua Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Lua Academy comprend 4 leçons au total.

Qu'est-ce que la couverture du code ?

La couverture du code mesure les lignes, branches ou fonctions de votre code qui sont exécutées par les tests. Une couverture élevée indique que les tests exercent correctement le code.

luacov : l'outil standard

luacov est l'outil standard de couverture pour Lua. Il s'intègre à la couche de débogage de Lua et enregistre les lignes qui sont exécutées.

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

Utiliser luacov avec un lanceur de tests

Avec busted ou un lanceur personnalisé, chargez luacov au démarrage : il enregistre automatiquement la couverture.

-- 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)

Génération d'un rapport

Après l'exécution des tests, luacov écrit un luacov.stats.out. fichier Exécutez luacov-reporter pour générer un rapport lisible.

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

Lecture du rapport

Chaque ligne affiche : le nombre d'occurrences, le nombre d'absences et la ligne source. Les lignes avec 0 occurrence correspondent à du code non couvert — potentiellement du code mort ou des cas de test manquants.

Couverture des branches

luacov suit la couverture des lignes, et non celle des branches. Pour couvrir les branches, utilisez un outil plus avancé ou ajoutez manuellement des cas de test pour chaque chemin if/else.

Fonction d'interception personnalisée pour la couverture

Créez un enregistreur de couverture minimal avec debug.sethook pour les événements de ligne.

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()

Seuils de couverture

Définissez un seuil minimal de couverture dans la CI (par exemple, 80 %). Faites échouer la compilation si la couverture passe en dessous de ce seuil. Cela empêche l'accumulation accidentelle de code mort.

Schémas d'instrumentation des tests

Au-delà de la couverture, instrumentez les tests avec : le temps d'exécution (pour détecter les tests lents), des assertions sur le nombre d'appels (pour vérifier que les fonctions sont appelées le nombre de fois attendu) et la capture des valeurs (pour enregistrer les arguments transmis aux fonctions simulées).

Simulation pour isoler les tests

Remplacez les modules réels par des simulations pendant les tests afin d'isoler les unités. Enregistrez la fonction réelle, remplacez-la par une fonction factice de suivi, puis restaurez-la après le test.

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

Intégration à la CI

Exécutez luacov dans votre chaîne CI. Téléversez les rapports de couverture vers Coveralls ou Codecov pour suivre l'évolution au fil des commits.

Question sur la couverture

Qu'indique une ligne avec 0 exécution dans un rapport luacov ?

Récapitulatif : couverture du code et instrumentation des tests

Utilisez luacov pour enregistrer la couverture des lignes et générer des rapports. Définissez des seuils de couverture dans l'intégration continue. Ajoutez une instrumentation personnalisée avec debug.sethook pour un suivi spécialisé. Utilisez des simulations pour isoler les tests unitaires et vérifier le nombre d'appels.

Questions Fréquemment Posées

La leçon « Couverture du code et instrumentation des tests » est-elle gratuite ?

Oui — le texte complet de « Couverture du code et instrumentation des tests » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Lua Academy, passe à CoddyKit PRO. Le cours Lua Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Couverture du code et instrumentation des tests » ?

Mesurez la couverture des tests avec luacov et interprétez les rapports de couverture. Tu pratiques Lua Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Lua Academy ?

Aucune expérience préalable n'est requise. Lua Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Couverture du code et instrumentation des tests » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Lua Academy ?

Oui. Chaque leçon Lua Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. La bibliothèque debug en profondeur
  2. Débogage à distance avec MobDebug
  3. Profilage avec LuaProfiler
  4. Couverture du code et instrumentation des tests
← Retour à Lua Academy