Mestrer test: JUnit, Mockito og integrationstest · Lektion

Spionering på rigtige objekter

Opdag, hvordan du bruger Mockito-spies til delvist at mocke rigtige objekter, kalde de rigtige metoder og samtidig verificere interaktioner.

Lektion 3 af 411 trin

Spionering på rigtige objekter er en gratis Mestrer test: JUnit, Mockito og integrationstest-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Mestrer test: JUnit, Mockito og integrationstest, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Mestrer test: JUnit, Mockito og integrationstest-kurset indeholder 4 lektioner i alt.

Hvad er Mockito-spies?

I Mockito har du lært at oprette mocks for at få fuld kontrol over objekters adfærd. Men hvad nu, hvis du kun vil ændre nogle få metoder, mens de øvrige bevarer deres oprindelige adfærd?

Det er her, spies kommer ind i billedet! En spy pakker et rigtigt objekt ind og giver dig mulighed for at:

Kalde objektets faktiske metoder som standard.
Tilsidesætte specifikke metoder med stubs, så de returnerer foruddefinerede værdier.
Verificere interaktioner med det rigtige objekt.

Tænk på det som en "delvis mocking" – du bruger det rigtige objekt, men med nogle få justeringer.

Opret din første spy

Det er enkelt at oprette en spy. I stedet for Mockito.mock() bruger du Mockito.spy() og sender en instans af det rigtige objekt, du vil overvåge, med.

Lad os definere en simpel klasse ved navn DataService, som vi bruger i vores eksempler. Denne service udfører nogle handlinger.

import org.mockito.Mockito;

public class DataService {
    public String fetchData(String id) {
        return "Real data for " + id;
    }

    public int processData(String data) {
        return data.length();
    }
}

public class Main {
    public static void main(String[] args) {
        DataService realService = new DataService();
        DataService spyService = Mockito.spy(realService);

        System.out.println("Spy created successfully!");
    }
}

Spies kalder de rigtige metoder

Det vigtigste kendetegn ved en spy er, at den som standard kalder de faktiske metoder i det objekt, den pakker ind. Det adskiller den fra en mock, som ikke har nogen rigtig implementering og returnerer standardværdier.

Lad os se vores spyService kalde en rigtig metode:

import org.mockito.Mockito;

public class DataService {
    public String fetchData(String id) {
        System.out.println("--- Calling REAL fetchData for ID: " + id + " ---");
        return "Real data for " + id;
    }

    public int processData(String data) {
        return data.length();
    }
}

public class Main {
    public static void main(String[] args) {
        DataService realService = new DataService();
        DataService spyService = Mockito.spy(realService);

        String result = spyService.fetchData("123");
        System.out.println("Result from spy: " + result);

        int processed = spyService.processData("Hello");
        System.out.println("Processed data length: " + processed);
    }
}

Opret en stub for en spy: Tilsidesættelse af adfærd

Selvom spies som standard kalder de rigtige metoder, kan du stadig oprette stubs for dem, så de returnerer bestemte værdier eller udløser undtagelser, ligesom med mocks. Det giver dig mulighed for at kontrollere dele af objektets adfærd.

Når du opretter en stub for en spy, er det dog ofte sikrere at bruge syntaksen doReturn().when():

Mockito.when(spy.method()).thenReturn(value) kan først udføre den rigtige metode, hvis den kaldes under when()-delen.
Mockito.doReturn(value).when(spy).method() undgår at kalde den rigtige metode under oprettelsen af stubben. Det er afgørende, hvis den rigtige metode har bivirkninger eller udløser undtagelser.

Oprettelse af en spy-stub i praksis

Lad os oprette en stub for metoden fetchData i vores spyService, så den returnerer en tilpasset værdi for et bestemt ID, mens andre kald stadig går til den rigtige metode:

import org.mockito.Mockito;

public class DataService {
    public String fetchData(String id) {
        System.out.println("--- Calling REAL fetchData for ID: " + id + " ---");
        return "Real data for " + id;
    }

    public int processData(String data) {
        return data.length();
    }
}

public class Main {
    public static void main(String[] args) {
        DataService realService = new DataService();
        DataService spyService = Mockito.spy(realService);

        // Stubbing the spy for a specific input
        Mockito.doReturn("Mocked data for specific ID")
               .when(spyService)
               .fetchData("specialId");

        // This call will return the mocked data
        String result1 = spyService.fetchData("specialId");
        System.out.println("Result for specialId: " + result1);

        // This call will go to the real method
        String result2 = spyService.fetchData("regularId");
        System.out.println("Result for regularId: " + result2);
    }
}

Verifikation af spy-interaktioner

Ligesom med mocks kan du bruge Mockito.verify() til at sikre, at bestemte metoder blev kaldt på din spy. Det er nyttigt til at bekræfte, at din kode interagerer med det rigtige objekt som forventet.

verify() fungerer præcis på samme måde for spies som for mocks. Du kan kontrollere:

Om en metode blev kaldt.
Hvor mange gange den blev kaldt.
Hvilke argumenter den blev kaldt med.

Eksempel på verifikation af spy-kald

Lad os verificere, at metoden fetchData blev kaldt på spy'en, også selvom den udførte sin rigtige implementering:

import org.mockito.Mockito;

public class DataService {
    public String fetchData(String id) {
        System.out.println("--- Calling REAL fetchData for ID: " + id + " ---");
        return "Real data for " + id;
    }

    public int processData(String data) {
        return data.length();
    }
}

public class Main {
    public static void main(String[] args) {
        DataService realService = new DataService();
        DataService spyService = Mockito.spy(realService);

        // Call a method on the spy (it will execute the real method)
        spyService.fetchData("user1");
        spyService.processData("data1");
        spyService.fetchData("user2");

        // Verify interactions
        Mockito.verify(spyService).fetchData("user1");
        Mockito.verify(spyService, Mockito.times(2)).fetchData(Mockito.anyString());
        Mockito.verify(spyService).processData("data1");

        System.out.println("Verification successful!");
    }
}

Spies kontra mocks: Den afgørende forskel

Det er afgørende at forstå, hvornår du skal bruge en spy i stedet for en traditionel mock:

Mocks: Opretter et helt falsk objekt. Alle metoder er "tomme" og returnerer standardværdier, medmindre du udtrykkeligt opretter stubs for dem. Ideelt til at isolere den enhed, der testes.
Spies: Pakker et rigtigt objekt ind. Alle metoder udfører deres faktiske implementering, medmindre du udtrykkeligt opretter stubs for dem. Nyttigt, når du vil bruge det meste af det rigtige objekts adfærd, men kontrollere nogle få specifikke interaktioner.

Foretræk mocks, når du har brug for ægte enhedsisolering. Brug spies til komplekse objekter, hvor kun nogle få metoder skal kontrolleres, eller til ældre kode.

Hvornår skal du bruge spies?

Spies er særligt nyttige i scenarier, hvor:

Du tester en klasse, der interagerer med en kompleks afhængighed, og kun har brug for at tilsidesætte en lille del af afhængighedens adfærd.
Du har en ældre klasse med mange metoder, og det ville være besværligt at oprette en fuld mock, men du skal sikre, at nogle metoder kaldes eller returnerer bestemte værdier.
Du vil teste en del af et rigtigt objekts adfærd uden at erstatte det fuldstændigt.

Brug dem dog med måde. Hvis du er for afhængig af spies, kan det føre til mindre isolerede tests, der er sværere at vedligeholde.

Hurtigt tjek: Spy-adfærd

Forestil dig en klasse ved navn Logger med en metode log(String message), der skriver til konsollen. Hvis du opretter en spy af et new Logger()-objekt, hvad sker der så, når du kalder spyLogger.log("Test") uden at oprette nogen stub?

Besvar den i den interaktive lektion

Opsummering: Overvågning af rigtige objekter

Du har nu lært om Mockito-spies!

Spies pakker rigtige objekter ind, så du som standard kan bruge deres faktiske metoder.
Du opretter dem med Mockito.spy(realObject).
Du kan oprette stubs for specifikke metoder ved hjælp af doReturn().when(spy).method() for at tilsidesætte deres adfærd.
Du kan verificere interaktioner på spies ved hjælp af Mockito.verify(), ligesom med mocks.
Brug spies med omtanke, primært når der er brug for delvis kontrol over et rigtigt objekt, frem for fuld isolering.

Denne fleksibilitet hjælper dig med at skrive mere målrettede tests til komplekse scenarier.

Gratis at komme i gang

Lær Mestrer test: JUnit, Mockito og integrationstest med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 12
Lektioner: 48

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Spionering på rigtige objekter” gratis?

Ja — alle 3 lektioner i læringssporet Mestrer test: JUnit, Mockito og integrationstest, inklusive “Spionering på rigtige objekter”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Mestrer test: JUnit, Mockito og integrationstest-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Spionering på rigtige objekter”?

Opdag, hvordan du bruger Mockito-spies til delvist at mocke rigtige objekter, kalde de rigtige metoder og samtidig verificere interaktioner. Du øver dig i Mestrer test: JUnit, Mockito og integrationstest med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Mestrer test: JUnit, Mockito og integrationstest?

Der kræves ingen tidligere erfaring. Mestrer test: JUnit, Mockito og integrationstest på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “Spionering på rigtige objekter”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Mestrer test: JUnit, Mockito og integrationstest-lektion?

Ja. Alle Mestrer test: JUnit, Mockito og integrationstest-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Stubning af returværdier
Mockito-argumentmatchere
Spionering på rigtige objekter
Kastning af exceptions og konsekutive kald

← Tilbage til Mestrer test: JUnit, Mockito og integrationstest