Kennismaken met de TDD-cyclus
Begrijp de kernprincipes en de Red-Green-Refactor-workflow van Test-Driven Development.
Kennismaken met de TDD-cyclus is een gratis Testen beheersen: JUnit, Mockito en integratietesten-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 Testen beheersen: JUnit, Mockito en integratietesten. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Testen beheersen: JUnit, Mockito en integratietesten bevat in totaal 4 lessen.
Introductie tot testgestuurde ontwikkeling
Welkom bij Test-Driven Development (TDD)! Het is een krachtige aanpak waarbij je eerst tests schrijft en daarna pas je eigenlijke code.
Dit klinkt misschien omgekeerd, maar het is een bewezen methode om robuuste software van hoge kwaliteit te bouwen.
Waarom TDD gebruiken?
TDD gaat niet alleen over testen; het is ook een ontwerptechniek. Het helpt je om:
- Helder na te denken over vereisten.
- Eenvoudigere, meer modulaire code te ontwerpen.
- Fouten vroegtijdig op te sporen.
- Met vertrouwen te refactoren.
Het fungeert als een vangnet voor je ontwikkelproces.
De TDD-cyclus: Red-Green-Refactor
TDD volgt een eenvoudige, iteratieve cyclus die bekendstaat als Red-Green-Refactor. Je herhaalt deze drie stappen meerdere keren per dag.
Laten we bekijken wat elke kleur betekent en waarom deze cyclus cruciaal is voor het bouwen van goede software.
Red: schrijf een falende test
In de fase Red schrijf je een nieuwe unitt test voor een klein stukje functionaliteit. Deze test beschrijft het gedrag dat je wilt toevoegen.
Belangrijk is dat deze test *faalt* wanneer je hem uitvoert. Waarom? Omdat de code voor deze functie nog niet bestaat!
Red: het falen van de test uitgelegd
Een falende test in de fase Red bevestigt twee dingen:
- Je test is correct geschreven en kan detecteren dat de functie ontbreekt.
- Je hebt de functie niet per ongeluk al geïmplementeerd.
Het is een bewuste stap om te controleren of je testsuite werkt zoals verwacht.
Green: laat de test slagen
Zodra je een falende test hebt (Red!), begint de fase Green. Je doel is eenvoudig: schrijf de *minimale hoeveelheid productiecode* die nodig is om die falende test te laten slagen.
Maak je nog geen zorgen over een perfect ontwerp of elegantie. Zorg er gewoon voor dat het werkt!
Green: voorbeeldcode
Stel dat we willen dat een Calculator twee getallen optelt. We schrijven dan een test die verwacht dat add(2,3) gelijk is aan 5. Omdat add niet bestaat, faalt de test (Red).
Vervolgens implementeren we de add-methode om de test te laten slagen (Green):
public class Main {
// Our simple Calculator class
static class Calculator {
public int add(int a, int b) {
return a + b; // Minimal code to pass the test
}
}
public static void main(String[] args) {
Calculator calc = new Calculator();
int expected = 5;
int actual = calc.add(2, 3); // Call the implemented method
if (actual == expected) {
System.out.println("Test PASSED! Expected " + expected + ", Got " + actual);
System.out.println("This is the 'Green' stage!");
} else {
System.out.println("Test FAILED: Expected " + expected + ", Got " + actual);
}
}
}Refactor: verbeter de code
Nu je test slaagt (Green!), is het tijd voor de fase Refactor. Hier verbeter je de kwaliteit van je code.
Je kunt je code veilig herstructureren, vereenvoudigen of optimaliseren, omdat je tests je meteen laten weten als je iets hebt stukgemaakt.
Refactoren voor kwaliteit
Refactoren betekent dat je de interne structuur van je code verbetert zonder het externe gedrag ervan te veranderen. Dit kan het volgende omvatten:
- Dubbele code verwijderen.
- Code leesbaarder maken.
- Methodenamen verbeteren.
- Grote methoden opsplitsen.
De tests zorgen ervoor dat je wijzigingen veilig zijn.
Voordelen van de TDD-cyclus
Het regelmatig herhalen van de Red-Green-Refactor-cyclus leidt tot:
- Duidelijkere vereisten: Tests definiëren het gewenste gedrag.
- Beter ontwerp: Code wordt modulairder en beter testbaar.
- Minder fouten: Problemen worden meteen opgespoord.
- Meer vertrouwen: Je kunt wijzigingen aanbrengen zonder bang te zijn dat bestaande functies stukgaan.
Korte controle: volgorde van de TDD-cyclus
Je hebt geleerd over de Red-Green-Refactor-cyclus. Zet de stappen nu in de juiste volgorde!
Samenvatting: de basis van TDD
Goed gedaan! Je hebt onze introductie tot Test-Driven Development afgerond.
- TDD is een ontwikkelaanpak waarbij tests *vóór* de code worden geschreven.
- De kern is de Red-Green-Refactor-cyclus.
- Deze aanpak leidt tot een beter ontwerp, minder fouten en meer vertrouwen in je code.
Hierna gaan we dieper in op het eerst schrijven van tests!
Leer Testen beheersen: JUnit, Mockito en integratietesten 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
- 12
- Lessen
- 48
Veelgestelde vragen
Is de les “Kennismaken met de TDD-cyclus” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Testen beheersen: JUnit, Mockito en integratietesten, waaronder “Kennismaken met de TDD-cyclus”, 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 Testen beheersen: JUnit, Mockito en integratietesten bevat in totaal 4 lessen.
Wat leer ik in “Kennismaken met de TDD-cyclus”?
Begrijp de kernprincipes en de Red-Green-Refactor-workflow van Test-Driven Development. Je oefent met Testen beheersen: JUnit, Mockito en integratietesten 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 Testen beheersen: JUnit, Mockito en integratietesten te beginnen?
Ervaring vooraf is niet nodig. Testen beheersen: JUnit, Mockito en integratietesten 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 “Kennismaken met de TDD-cyclus”?
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 Testen beheersen: JUnit, Mockito en integratietesten?
Ja. Elke les over Testen beheersen: JUnit, Mockito en integratietesten 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
- Kennismaken met de TDD-cyclus
- Eerst tests schrijven
- Refactoring voor testbaarheid
- De drie wetten van TDD