Testgegevens beheren
Ontwikkel strategieën voor het aanmaken, beheren en opruimen van testgegevens om herhaalbare E2E-tests te garanderen.
Testgegevens beheren is een gratis Testen beheersen: JUnit, Mockito en integratietesten-les op CoddyKit. Dit is les 3 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.
Basisprincipes van E2E-testgegevens
Bij het uitvoeren van End-to-End-tests (E2E-tests) zijn testgegevens cruciaal. Het gaat om de informatie die je applicatie tijdens een test gebruikt, zoals gebruikersaccounts, productgegevens of bestelgeschiedenis.
Zonder goede testgegevens worden je E2E-tests onbetrouwbaar. Stel je voor dat je het afrekenen in een webwinkel test zonder product in het winkelwagentje of zonder geregistreerde gebruiker!
Uitdagingen met E2E-gegevens
Het beheren van testgegevens voor E2E-tests brengt unieke uitdagingen met zich mee:
- Complexiteit: E2E-tests werken vaak met meerdere onderdelen van het systeem, waardoor complexe gegevensconfiguraties nodig zijn.
- Afhankelijkheden: Gegevens kunnen afhankelijk zijn van externe systemen of andere modules, waardoor ze moeilijk te beheren zijn.
- Statusafhankelijkheid: Tests kunnen het systeem in een onverwachte toestand achterlaten, wat volgende tests beïnvloedt.
- Opschonen: Gegevens na een test verwijderen kan lastig zijn, maar is essentieel voor herhaalbaarheid.
Gegevens maken via een API
Een veelgebruikte strategie is om testgegevens programmatisch te maken met de eigen API's van je applicatie, bijvoorbeeld REST API-eindpunten. Zo weet je zeker dat de gegevens dezelfde validatielogica doorlopen als echte gebruikersgegevens.
Probeer dit voorbeeld uit te voeren, waarin het maken van een gebruiker via een API wordt gesimuleerd:
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
public class Main {
public static void main(String[] args) throws IOException, InterruptedException {
String jsonPayload = "{\"username\": \"testuser\", \"email\": \"test@example.com\"}";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.example.com/users"))
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
.build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println("API Call Status: " + response.statusCode());
System.out.println("Response Body: " + response.body());
}
}Gegevens met databasescripts
Voor sommige E2E-tests moet je mogelijk rechtstreeks gegevens in de database invoegen met SQL-scripts. Dit is snel, maar omzeilt de bedrijfslogica van je applicatie.
Gebruik deze methode voorzichtig, meestal voor basisgegevens of wanneer gegevens maken via de API te langzaam of te complex is.
INSERT INTO users (id, username, email)
VALUES (101, 'db_user', 'db@example.com');
INSERT INTO products (id, name, price)
VALUES (201, 'Test Product A', 19.99);Testgegevensfabrieken gebruiken
Testgegevensfabrieken (of generatoren) zijn tools of aangepaste klassen die het maken van realistische, gevarieerde gegevens automatiseren. Bibliotheken zoals Faker kunnen namen, adressen en meer genereren.
Zo kun je uiteenlopende testscenario's maken zonder handmatig werk. Dit is een eenvoudig concept voor zo'n fabriek:
// Imagine a UserFactory class
class User {
String username;
String email;
public User(String username, String email) {
this.username = username;
this.email = email;
}
@Override
public String toString() {
return "User: " + username + " (" + email + ")";
}
}
class UserFactory {
private static int counter = 0;
public static User createRandomUser() {
counter++;
return new User("user_" + counter, "user" + counter + "@example.com");
}
}
public class Main {
public static void main(String[] args) {
User user1 = UserFactory.createRandomUser();
User user2 = UserFactory.createRandomUser();
System.out.println(user1);
System.out.println(user2);
}
}Testgegevens isoleren
Een van de belangrijkste principes is isolatie van testgegevens. Elke test of testsuite hoort idealiter zelfstandig te werken met een eigen, unieke set gegevens.
Zo voorkom je dat tests elkaar beïnvloeden, waardoor ze betrouwbaarder en gemakkelijker te debuggen zijn. Gedeelde gegevens kunnen leiden tot instabiele tests die onvoorspelbaar slagen of mislukken.
Omgevingsgegevens
Testgegevens moeten vaak verschillen per omgeving, zoals ontwikkeling, acceptatie en productie. Mogelijk heb je specifieke configuraties of integraties met externe services waarvoor unieke gegevens nodig zijn.
Beheer dit met omgevingsvariabelen, configuratiebestanden of speciale gegevenssets voor elke omgeving.
Cruciaal: gegevens opschonen
Testgegevens maken is slechts de helft van het werk; ze opschonen is minstens zo belangrijk. Na het uitvoeren van een test moeten alle gegevens die de test heeft gemaakt worden verwijderd.
Waarom is opschonen zo belangrijk?
- Het zorgt ervoor dat tests echt herhaalbaar zijn.
- Het voorkomt vervuiling van je testomgeving.
- Het voorkomt onverwachte neveneffecten op volgende tests.
Programmatisch opschonen
Net zoals je gegevens programmatisch maakt, moet je ze ook programmatisch verwijderen. Dit kan betekenen dat je een 'delete'-API-eindpunt aanroept of SQL-DELETE-instructies uitvoert.
Vaak wordt het opschonen uitgevoerd in een methode van het type @AfterEach of @AfterAll (afhankelijk van je testframework), zodat het gegarandeerd wordt uitgevoerd nadat tests zijn voltooid.
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
public class Main {
public static void main(String[] args) throws IOException, InterruptedException {
String userIdToDelete = "testuser"; // Or an ID obtained during creation
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.example.com/users/" + userIdToDelete))
.DELETE()
.build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println("Delete Status: " + response.statusCode());
}
}Quiz over testgegevens
Welke van de volgende werkwijzen zijn goed voor het beheren van testgegevens in End-to-End-tests (E2E-tests)?
Samenvatting: testgegevens beheersen
Je hebt geleerd dat effectief beheer van testgegevens essentieel is voor stabiele en herhaalbare E2E-tests. We hebben behandeld:
- Strategieën om gegevens te maken (API's, databasescripts, fabrieken).
- Het belang van gegevensisolatie en omgevingsspecifieke gegevens.
- De noodzaak om gegevens na tests op te schonen.
Door deze strategieën toe te passen kun je robuustere en betrouwbaardere E2E-testsuites bouwen!
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 “Testgegevens beheren” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Testen beheersen: JUnit, Mockito en integratietesten, waaronder “Testgegevens beheren”, 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 “Testgegevens beheren”?
Ontwikkel strategieën voor het aanmaken, beheren en opruimen van testgegevens om herhaalbare E2E-tests te garanderen. 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 3 van 4.
Hoe lang duurt de les “Testgegevens beheren”?
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