Unit- versus integratietests
Maak duidelijk onderscheid tussen unit- en integratietests en begrijp hun reikwijdte en doel binnen de testpiramide.
Unit- versus integratietests 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.
Welkom bij testtypen
Testen zijn cruciaal bij softwareontwikkeling. Maar niet alle tests zijn hetzelfde! We bekijken twee fundamentele typen: unittests en integratietests.
Als je de verschillen begrijpt, kun je effectieve tests schrijven en robuuste toepassingen bouwen.
Wat is een 'eenheid'?
Voordat we in unittests duiken: wat is precies een "eenheid"?
- Een eenheid is het kleinste testbare onderdeel van een toepassing.
- Dit kan één methode, een klasse of een kleine module zijn.
- Het belangrijkste is dat de eenheid een specifieke, geïsoleerde functie uitvoert.
Unittest: focus op isolatie
Een unittest richt zich op het geïsoleerd testen van één "eenheid" code.
- De test controleert of een specifieke methode of klasse werkt zoals verwacht.
- Deze tests zijn doorgaans erg snel en hebben geen externe afhankelijkheden.
- Je kunt het vergelijken met controleren of één tandwiel in een machine op zichzelf perfect werkt.
Eenvoudig voorbeeld van een unittest
Neem een eenvoudige methode voor een rekenmachine. Een unittest zou alleen deze methode controleren.
Voor deze test zijn geen database of netwerkverbinding nodig, alleen de klasse Calculator.
class Calculator {
public int add(int a, int b) {
return a + b;
}
}
// In a real JUnit test, you'd use @Test and assertions.
// For now, imagine testing 'add' by itself.
public class Main {
public static void main(String[] args) {
Calculator calc = new Calculator();
int result = calc.add(5, 3);
System.out.println("Result of add(5, 3): " + result); // Expected: 8
}
}Integratietest: onderdelen verbinden
Een integratietest controleert of verschillende eenheden of componenten van een applicatie goed samenwerken.
- De test controleert de interactie tussen modules, services en zelfs externe systemen zoals databases.
- Deze tests hebben een bredere reikwijdte en zijn vaak langzamer dan unittests.
- Je kunt het zien als controleren of twee of meer tandwielen goed in elkaar grijpen en soepel samen draaien.
Eenvoudig voorbeeld van een integratietest
Stel je een UserService voor die een UserRepository gebruikt om gebruikers op te slaan. Een integratietest controleert of UserService via UserRepository met succes een gebruiker in de database kan opslaan.
Hierbij zijn beide componenten en mogelijk een echte (of gemockte) databaseverbinding betrokken.
class UserRepository {
public void saveUser(String username) {
// Simulates saving to a database
System.out.println("Saving user: " + username + " to DB.");
}
}
class UserService {
private UserRepository userRepository;
public UserService(UserRepository userRepository) {
this.userRepository = userRepository;
}
public void registerUser(String username) {
// Business logic
userRepository.saveUser(username);
}
}
public class Main {
public static void main(String[] args) {
// In an integration test, you'd wire these up
// and check if 'saveUser' was called and data persisted.
UserRepository repo = new UserRepository();
UserService service = new UserService(repo);
service.registerUser("Alice");
}
}Unit- versus integratietests: belangrijkste verschillen
- Reikwijdte: Unittests richten zich op één eenheid; integratietests richten zich op interacties tussen eenheden.
- Afhankelijkheden: Unittests isoleren afhankelijkheden; integratietests gebruiken echte afhankelijkheden (of realistische mocks).
- Snelheid: Unittests zijn snel; integratietests zijn meestal langzamer.
- Doel: Unittests bevestigen afzonderlijke logica; integratietests bevestigen de samenwerking tussen componenten.
De testpiramide uitgelegd
De testpiramide is een visuele metafoor voor softwaretesten. Het idee is om het volgende te schrijven:
- Veel unittests (de basis, snel en goedkoop).
- Minder integratietests (de middelste laag, langzamer maar met een grotere dekking).
- Nog minder end-to-endtests (de top, het langzaamst en gericht op het hele systeem).
Deze balans helpt om efficiënt een goede dekking te bereiken.
Het juiste testtype kiezen
Wanneer schrijf je een unittest en wanneer een integratietest?
- Kies unittests voor complexe bedrijfslogica, algoritmen of hulpprogrammamethoden die niet afhankelijk zijn van externe systemen.
- Kies integratietests wanneer je wilt bevestigen dat je code correct samenwerkt met databases, API's, bestandssystemen of andere services.
Korte controle: testtypen
Je hebt een nieuwe functie gebouwd die invoer van een gebruiker ontvangt, deze met een complexe berekening verwerkt en het resultaat vervolgens in een database opslaat.
Welk testtype is het meest geschikt om te controleren of de complexe berekening zelf correct werkt, onafhankelijk van de interactie met de database?
Samenvatting: unit- versus integratietests
Goed gedaan! Je hebt de fundamentele verschillen tussen unit- en integratietests geleerd.
- Unittests zijn klein, snel en geïsoleerd en controleren afzonderlijke componenten.
- Integratietests controleren interacties tussen componenten, zijn breder opgezet en gebruiken afhankelijkheden.
Deze twee testtypen vormen de kern van effectief softwaretesten. Zo zorg je ervoor dat zowel afzonderlijke onderdelen als hun verbindingen betrouwbaar werken.
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 “Unit- versus integratietests” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Testen beheersen: JUnit, Mockito en integratietesten, waaronder “Unit- versus integratietests”, 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 “Unit- versus integratietests”?
Maak duidelijk onderscheid tussen unit- en integratietests en begrijp hun reikwijdte en doel binnen de testpiramide. 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 “Unit- versus integratietests”?
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
- Unit- versus integratietests
- Integratietests instellen
- Database-interacties testen
- Externe API's testen met WireMock