Lua Academy · Les

Waarom testen?

Vind bugs voordat gebruikers dat doen.

Les 1 van 413 stappen

Waarom testen? is een gratis Lua Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Lua Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Lua Academy bevat in totaal 4 lessen.

Waarom überhaupt testen

Geautomatiseerde tests zijn code die je code controleert. In plaats van een programma handmatig uit te voeren en de uitvoer vluchtig te bekijken, schrijf je kleine asserties die het testprogramma voor je controleert.

Voor Lua is busted het populairste testraamwerk. Het biedt een duidelijke syntaxis om gedrag te beschrijven en resultaten als geslaagd of mislukt te rapporteren.

De kosten van geen tests

Zonder tests is elke wijziging een gok. Je lost de ene fout op en veroorzaakt ongemerkt een andere. Naarmate een codebasis groeit, wordt grondig handmatig controleren onmogelijk.

Tests vormen een vangnet. Wanneer je je code herstructureert, laat een groene testsuite zien dat het gedrag behouden is gebleven.

Een eerste testbestand

Een busted-testbestand staat meestal in een map spec/ en eindigt op _spec.lua. Daarin beschrijf je wat je test.

Hier is het kleinste bruikbare voorbeeld. Het controleert of eenvoudige rekenkunde werkt.

describe("math", function()
  it("adds numbers", function()
    assert.are.equal(4, 2 + 2)
  end)
end)

busted uitvoeren

Je installeert busted met LuaRocks: luarocks install busted. Voer daarna de opdracht busted uit in de hoofdmap van je project.

Het programma zoekt bestanden die eindigen op _spec.lua, voert elk it-blok uit en drukt voor elke geslaagde test een punt en voor elke mislukte test een F af.

Je eigen module testen

In echte tests importeer je de module die je test met require. Je roept de functies aan en voert asserties uit op het resultaat.

Stel dat je een module calculator.lua hebt die een tabel met functies teruggeeft.

local calc = require("calculator")

describe("calculator", function()
  it("multiplies", function()
    assert.are.equal(6, calc.mul(2, 3))
  end)
end)

Tests als documentatie

Goed geschreven tests doen ook dienst als levende documentatie. Een nieuwe ontwikkelaar kan het specificatiebestand lezen en precies begrijpen hoe een functie hoort te werken.

Omdat de beschrijvingen gewone tekenreeksen zijn, lezen ze bijna als zinnen: "rekenmachine vermenigvuldigt".

describe("string utils", function()
  it("trims whitespace", function()
    assert.are.equal("hi", utils.trim("  hi  "))
  end)
end)

Snelle terugkoppellussen

De echte kracht van tests is snelheid. Een volledige testsuite uitvoeren duurt enkele seconden, veel sneller dan handmatig door een app klikken.

Je kunt busted zelfs in de bewakingsmodus uitvoeren of één bestand selecteren om de terugkoppeling tijdens het ontwikkelen snel te houden.

-- run only one file
-- busted spec/calculator_spec.lua

Regressies opsporen

Een regressie is een fout die opnieuw opduikt in code die eerder werkte. Wanneer je een fout vindt, is het een goede gewoonte om eerst een test te schrijven die de fout reproduceert.

Zodra de test mislukt, herstel je de code totdat de test slaagt. Die test beschermt nu tegen het terugkeren van de fout.

it("handles empty input", function()
  assert.are.equal(0, calc.sum({}))
end)

Wat een goede test maakt

Goede tests zijn snel, geïsoleerd en deterministisch. Ze mogen niet afhankelijk zijn van netwerk, tijd of willekeurige waarden, tenzij je die beheerst.

Elke test moet één duidelijk gedrag controleren. Als een test mislukt, moet de naam zonder de inhoud te lezen vertellen wat er is misgegaan.

Testpiramide

De testpiramide adviseert veel kleine unittests, minder integratietests en zeer weinig tests van begin tot eind. Unittests zijn goedkoop en snel, dus geef daar de voorkeur aan.

busted is vooral een hulpmiddel voor unittests, maar je kunt het ook voor integratietests gebruiken.

Zekerheid om te wijzigen

Het diepste voordeel van testen is zekerheid. Met een betrouwbare testsuite kun je je code grondig herstructureren, afhankelijkheden bijwerken en sneller opleveren.

Deze cursus leert je busted vanaf de basis: structuur, asserties en testdubbels zoals mocks en spies.

describe("feature", function()
  it("still works after refactor", function()
    assert.is_true(feature.enabled())
  end)
end)

Korte controle

Test of je begrijpt waarom we tests schrijven.

Beantwoord dit in de interactieve les

Samenvatting

Tests zijn code die code controleert. busted is Lua's belangrijkste testraamwerk: het zoekt _spec.lua-bestanden en rapporteert of tests geslaagd of mislukt zijn.

Goede tests zijn snel, geïsoleerd en deterministisch. Ze sporen regressies op, doen dienst als documentatie en geven je de zekerheid om code vrijelijk te wijzigen.

Gratis beginnen

Leer Lua met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 40
Lessen: 159

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Waarom testen?” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Lua Academy, waaronder “Waarom testen?”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Lua Academy bevat in totaal 4 lessen.

Wat leer ik in “Waarom testen?”?

Vind bugs voordat gebruikers dat doen. Je oefent met Lua Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Lua Academy te beginnen?

Ervaring vooraf is niet nodig. Lua Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Waarom testen?”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Lua Academy?

Ja. Elke les over Lua Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Lua Academy