E2E-tests versus integratietests
Krijg inzicht in de verschillende scope en het verschillende doel van End-to-End-tests vergeleken met integratietests.
E2E-tests 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.
E2E versus integratie: het grote geheel
Welkom bij de uitleg over twee belangrijke soorten softwaretests: integratietests en end-to-endtests (E2E-tests).
Bij beide zijn meerdere onderdelen van je systeem betrokken, maar hun reikwijdte en doel verschillen aanzienlijk. Als je dit onderscheid beheerst, kun je een robuuste en efficiënte teststrategie opbouwen.
Integratietests: onderdelen verbinden
Integratietesten richt zich op het controleren of verschillende modules of services binnen je applicatie correct werken wanneer ze worden gecombineerd.
Het controleert de interacties en gegevensstroom tussen deze geïntegreerde onderdelen, bijvoorbeeld hoe je code communiceert met een database of een externe API. Het doel is om fouten in interfaces op te sporen.
Reikwijdte van integratietests
Integratietests controleren meestal het volgende:
- Database-interacties: Slaat je service gegevens correct op, haalt hij ze correct op en werkt hij ze correct bij?
- API-aanroepen: Communiceert je applicatie correct met interne of externe API's?
- Samenwerking tussen onderdelen: Communiceren je lagen voor bedrijfslogica zoals verwacht met je lagen voor gegevenstoegang?
De volledige gebruikersinterface of een echte webbrowser wordt meestal niet gebruikt.
Integratietest: service en repository
Stel dat je een UserService hebt die een UserRepository gebruikt om gebruikers te beheren.
Een integratietest controleert of UserService.createUser() succesvol met UserRepository communiceert om een nieuwe gebruiker op te slaan in een echte database of een database in het geheugen.
Hieronder staat een conceptueel fragment dat het idee laat zien:
public class UserServiceTest {
// Assume UserRepository interacts with a DB
private UserRepository userRepository = new UserRepository();
private UserService userService = new UserService(userRepository);
// This isn't a full JUnit test, just illustrates the concept
public static void main(String[] args) {
UserServiceTest test = new UserServiceTest();
test.testCreateUserIntegration();
}
void testCreateUserIntegration() {
System.out.println("Running integration test for UserService...");
User newUser = new User("Alice", "alice@example.com");
userService.createUser(newUser); // This would interact with the real DB/repo
User foundUser = userService.findUserByEmail("alice@example.com");
if (foundUser != null && foundUser.getName().equals("Alice")) {
System.out.println("Integration test PASSED: User created and found.");
} else {
System.out.println("Integration test FAILED: User not found or incorrect.");
}
}
static class User {
String name;
String email;
User(String name, String email) { this.name = name; this.email = email; }
String getName() { return name; }
String getEmail() { return email; }
}
static class UserRepository {
// This would normally connect to a database
// For this conceptual example, we simulate it
private java.util.Map<String, User> users = new java.util.HashMap<>();
void save(User user) {
System.out.println(" Saving user to 'DB': " + user.getEmail());
users.put(user.getEmail(), user);
}
User findByEmail(String email) {
System.out.println(" Finding user in 'DB': " + email);
return users.get(email);
}
}
static class UserService {
private UserRepository repository;
UserService(UserRepository repository) { this.repository = repository; }
void createUser(User user) {
repository.save(user);
}
User findUserByEmail(String email) {
return repository.findByEmail(email);
}
}
}E2E-tests: gebruikersreizen simuleren
End-to-endtesten (E2E-testen) simuleren een volledige gebruikersflow door de applicatie, van begin tot eind. Ze testen het hele systeem, waaronder de gebruikersinterface, database, netwerk en alle geïntegreerde externe services.
Het doel is om te controleren of de applicatie zich vanuit het perspectief van de gebruiker gedraagt zoals verwacht en of het volledige systeem integer werkt.
Reikwijdte van end-to-endtests
E2E-tests omvatten meestal het volgende:
- Gebruikersinterface (UI): Werken met knoppen, formulieren en navigatie.
- Backendservices: Controleren of bedrijfslogica en gegevensverwerking correct werken.
- Database: Via de gebruikersinterface controleren of gegevens correct worden opgeslagen en opgehaald.
- Externe integraties: Als de gebruikersflow externe API's van derden gebruikt, zoals betaaldiensten.
Ze worden vaak uitgevoerd in een browser of mobiele emulator, waarbij echte gebruikersacties worden nagebootst.
E2E-test: de winkelreis van een gebruiker
Neem een e-commerceapplicatie. Een E2E-test kan het volgende simuleren:
- Een gebruiker die naar de website navigeert.
- Zoeken naar een product.
- Het product aan de winkelwagen toevoegen.
- Doorgaan naar het afrekenen.
- Betalingsgegevens invoeren.
- De orderbevestiging controleren.
Hiermee wordt elke laag getest, van de gebruikersinterface tot de database en de betalingsverwerking.
Reikwijdte en omgeving onderscheiden
Het belangrijkste verschil zit in hun reikwijdte en de omgeving die ze testen:
- Integratietests: Richten zich op interacties tussen enkele specifieke onderdelen. Ze worden vaak uitgevoerd tegen een "testdubbel" (zoals een database in het geheugen) of een speciale testomgeving.
- E2E-tests: Bestrijken de volledige applicatie en de externe afhankelijkheden ervan. Ze worden uitgevoerd in een omgeving die de productieomgeving nauw benadert, zoals staging of preproductie.
Snelheid en kosten onderscheiden
Er is ook een afweging tussen snelheid en onderhoud:
- Integratietests: Worden over het algemeen sneller uitgevoerd en zijn minder kwetsbaar. Ze zijn eenvoudiger te debuggen en te onderhouden doordat ze interacties tussen onderdelen isoleren.
- E2E-tests: Duren langer en zijn gevoeliger voor instabiliteit doordat ze afhankelijk zijn van de gebruikersinterface en externe systemen. Ze zijn duurder om op te zetten en te onderhouden, maar bieden veel zekerheid.
Een goede teststrategie gebruikt beide en vormt zo een "testpiramide".
Korte controle: soorten tests
Laten we controleren of je het verschil tussen integratie- en end-to-endtesten begrijpt.
Samenvatting: E2E versus integratie
We hebben de belangrijkste verschillen tussen integratie- en end-to-endtests onderzocht:
- Integratietests controleren interacties tussen onderdelen.
- E2E-tests valideren volledige gebruikersflows door het hele systeem.
Beide zijn essentieel voor kwaliteit, maar hebben verschillende doelen binnen je teststrategie. Als je begrijpt wanneer je welke gebruikt, kun je robuuste en efficiënte testsuites maken.
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 “E2E-tests versus integratietests” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Testen beheersen: JUnit, Mockito en integratietesten, waaronder “E2E-tests 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 “E2E-tests versus integratietests”?
Krijg inzicht in de verschillende scope en het verschillende doel van End-to-End-tests vergeleken met integratietests. 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 “E2E-tests 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
- E2E-tests versus integratietests
- Overzicht van E2E-testtools
- Testgegevens beheren
- Betrouwbare E2E-tests schrijven: flakiness bestrijden