Testing i praksis: JUnit, Mockito og integrasjonstester · leksjon

Håndtering av testdata

Utvikle strategier for å opprette, administrere og rydde opp i testdata for å sikre gjentakbare E2E-tester.

Leksjon 3 av 411 trinn

Håndtering av testdata er en gratis leksjon i Testing i praksis: JUnit, Mockito og integrasjonstester på CoddyKit. Dette er leksjon 3 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Testing i praksis: JUnit, Mockito og integrasjonstester, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Testing i praksis: JUnit, Mockito og integrasjonstester inneholder totalt 4 leksjoner.

Grunnleggende om E2E-testdata

Når du utfører end-to-end-tester (E2E), er testdata avgjørende. Det er informasjonen applikasjonen bruker under en test, for eksempel brukerkontoer, produktdetaljer eller ordrehistorikk.

Uten gode testdata blir E2E-testene dine upålitelige. Tenk deg å teste utsjekking i en nettbutikk uten et produkt i handlekurven eller en registrert bruker!

Utfordringer med E2E-data

Håndtering av testdata for E2E-tester innebærer noen unike utfordringer:

Kompleksitet: E2E-tester samhandler ofte med flere deler av systemet, noe som krever komplekse dataoppsett.
Avhengigheter: Data kan avhenge av eksterne systemer eller andre moduler, noe som gjør dem vanskelige å kontrollere.
Tilstand: Tester kan etterlate systemet i en uventet tilstand, noe som påvirker påfølgende tester.
Opprydding: Det kan være vanskelig å fjerne data etter en test, men dette er avgjørende for at testene skal kunne gjentas.

Opprett data via API

En vanlig strategi er å opprette testdata programmatisk ved hjelp av applikasjonens egne API-er (for eksempel REST API-endepunkter). Dette sikrer at dataene går gjennom den samme valideringslogikken som ekte brukerdata.

Prøv å kjøre dette eksempelet, som simulerer oppretting av en bruker via et API:

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());
  }
}

Data med databaseskript

For noen E2E-tester kan det være nødvendig å sette inn data direkte i databasen ved hjelp av SQL-skript. Dette går raskt, men omgår applikasjonens forretningslogikk.

Bruk denne metoden med forsiktighet, vanligvis for grunnleggende data eller når oppretting via API er for treg eller kompleks.

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);

Bruk av testdatafabrikker

Testdatafabrikker (eller generatorer) er verktøy eller egendefinerte klasser som automatiserer opprettingen av realistiske og varierte data. Biblioteker som Faker kan generere navn, adresser og mer.

Dette gjør det mulig å opprette varierte testscenarioer uten manuelt arbeid. Her er et enkelt fabrikkonsept:

// 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);
  }
}

Isoler testdata

Et av de viktigste prinsippene er isolering av testdata. Hver test eller testpakke bør ideelt sett bruke sitt eget, unike datasett.

Dette hindrer tester i å påvirke hverandre, og gjør dem mer pålitelige og enklere å feilsøke. Delte data kan føre til ustabile tester som består eller mislykkes på uforutsigbare måter.

Miljødata

Testdata må ofte være forskjellige i ulike miljøer (for eksempel utvikling, staging og produksjon). Det kan hende du har bestemte konfigurasjoner eller integrasjoner med eksterne tjenester som krever unike data.

Håndter dette ved å bruke miljøvariabler, konfigurasjonsfiler eller dedikerte datasett for hvert miljø.

Avgjørende dataopprydding

Å opprette testdata er bare halve jobben; opprydding er like viktig. Etter at en test er kjørt, bør alle dataene den opprettet, fjernes.

Hvorfor er opprydding så viktig?

Sikrer at testene faktisk kan gjentas.
Hindrer dataforurensning i testmiljøet.
Unngår uventede bivirkninger i påfølgende tester.

Programmatisk opprydding

Akkurat som du oppretter data programmatisk, bør du også slette dem programmatisk. Dette kan innebære å kalle et «delete»-API-endepunkt eller kjøre SQL-setninger med DELETE.

Opprydding utføres ofte i en metode av typen @AfterEach eller @AfterAll (avhengig av testingsrammeverket ditt) for å garantere at den kjøres etter at testene er fullført.

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 om testdata

Hvilke av følgende er gode fremgangsmåter for håndtering av testdata i end-to-end-tester (E2E)?

Besvar den i den interaktive leksjonen

Oppsummering: Bli ekspert på testdata

Du har lært at effektiv håndtering av testdata er avgjørende for stabile og gjentakbare E2E-tester. Vi har gått gjennom:

Strategier for å opprette data (API-er, databaseskript og fabrikker).
Betydningen av dataisolering og miljøspesifikke data.
Nødvendigheten av å rydde opp i data etter tester.

Ved å bruke disse strategiene kan du bygge mer robuste og pålitelige E2E-testpakker!

Gratis å komme i gang

Lær deg Testing i praksis: JUnit, Mockito og integrasjonstester med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Håndtering av testdata» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Testing i praksis: JUnit, Mockito og integrasjonstester, inkludert «Håndtering av testdata», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Testing i praksis: JUnit, Mockito og integrasjonstester inneholder totalt 4 leksjoner.

Hva lærer jeg i «Håndtering av testdata»?

Utvikle strategier for å opprette, administrere og rydde opp i testdata for å sikre gjentakbare E2E-tester. Du øver på Testing i praksis: JUnit, Mockito og integrasjonstester med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Testing i praksis: JUnit, Mockito og integrasjonstester?

Ingen tidligere erfaring er nødvendig. Testing i praksis: JUnit, Mockito og integrasjonstester på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Håndtering av testdata»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Testing i praksis: JUnit, Mockito og integrasjonstester-leksjonen?

Ja. Alle Testing i praksis: JUnit, Mockito og integrasjonstester-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

E2E-testing kontra integrasjonstesting
Oversikt over verktøy for E2E-testing
Håndtering av testdata
Skrive pålitelige E2E-tester: Bekjemp flaky tester

← Tilbake til Testing i praksis: JUnit, Mockito og integrasjonstester