Testning på avancerad nivå: JUnit, Mockito och integrationstester · Lektion

Skapa mockar med Mockito

Använd Mockito för att skapa mockobjekt för beroenden och isolera enheten som testas från dess samarbetande komponenter.

Lektion 2 av 411 steg

Skapa mockar med Mockito är en gratis lektion i Testning på avancerad nivå: JUnit, Mockito och integrationstester på CoddyKit. Detta är lektion 2 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Testning på avancerad nivå: JUnit, Mockito och integrationstester, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Testning på avancerad nivå: JUnit, Mockito och integrationstester innehåller totalt 4 lektioner.

Introduktion till Mockito-mockobjekt

I föregående lektion lärde vi oss om konceptet mockobjekt. Mocks är särskilda testdubletter som låter oss styra beroendenas beteende.

Nu ska vi gå igenom Mockito, ett populärt ramverk för mocking i Java, och se hur enkelt det är att skapa dessa kraftfulla verktyg för era tester.

Varför skapa mocks?

Att skapa mocks är avgörande för effektiv enhetstestning:

Isolering: Mocks låter er testa en enda kodenhet isolerat, utan att behöva ta hänsyn till dess verkliga beroenden.
Kontroll: Ni kan programmera mocks att bete sig exakt som behövs för testsituationen och simulera olika utfall.
Hastighet: Mocks undviker långsamma operationer som databasanrop eller nätverksförfrågningar, vilket gör att testerna körs mycket snabbare.

Metoden `Mockito.mock()`

Det enklaste sättet att skapa ett mockobjekt i Mockito är att använda den statiska metoden Mockito.mock(). Ni skickar in den Class eller Interface som ni vill skapa en mock för.

Metoden returnerar en ny mockinstans som ser ut och fungerar som det verkliga objektet, men utan den faktiska implementeringslogiken.

Exempel på att skapa en grundläggande mock

Vi skapar en mock för det enkla gränssnittet EmailService. Kör koden för att se hur ett mockobjekt skapas.

import org.mockito.Mockito;

interface EmailService {
  void sendEmail(String to, String subject, String body);
  String getServiceStatus();
}

public class Main {
  public static void main(String[] args) {
    EmailService mockEmailService = Mockito.mock(EmailService.class);
    System.out.println("Mock created: " + mockEmailService.getClass().getName());
  }
}

Förstå mocks standardbeteende

Vad händer om ni anropar en metod på en mock utan att ange vad den ska göra?

Objekt: Metoder som returnerar objekt returnerar null.
Primitiva typer: Metoder som returnerar primitiva typer (till exempel int och boolean) returnerar sina standardvärden (0 och false).
Samlingar: Metoder som returnerar samlingar returnerar tomma samlingar.
Void: Metoder som returnerar void gör ingenting.

Standardbeteende i praktiken

Vi anropar en metod på vår mockEmailService utan någon konfiguration. Observera standardvärdet som returneras.

import org.mockito.Mockito;

interface EmailService {
  void sendEmail(String to, String subject, String body);
  String getServiceStatus();
}

public class Main {
  public static void main(String[] args) {
    EmailService mockEmailService = Mockito.mock(EmailService.class);
    
    // Calling a method that returns an object
    String status = mockEmailService.getServiceStatus();
    System.out.println("Default status: " + status);
    
    // Calling a void method (does nothing by default)
    mockEmailService.sendEmail("test@example.com", "Hi", "Hello");
    System.out.println("Void method called (no output)");
  }
}

Skapa mocks med `@Mock`

Även om Mockito.mock() fungerar erbjuder Mockito ett smidigare sätt för tester genom annoteringen @Mock.

Ni deklarerar helt enkelt ett fält med @Mock, så tar Mockito hand om att initiera det som ett mockobjekt.

Initiera `@Mock`-annoteringar

För att @Mock-annoteringar ska fungera måste ni tala om för Mockito att bearbeta dem. I JUnit 5 görs detta vanligtvis genom att använda annoteringen @ExtendWith(MockitoExtension.class) på er testklass.

Alternativt kan ni initiera dem manuellt med MockitoAnnotations.openMocks(this).

Exempel: Använda annoteringen `@Mock`

Det här exemplet simulerar en testklass där @Mock används. Kör det för att se mocken initieras via MockitoAnnotations.openMocks().

import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

interface DataRepository {
  String fetchData();
}

// Simulate a test class structure
class MyServiceTest {
  @Mock
  DataRepository mockRepository;

  public MyServiceTest() {
    // Manually open mocks for demonstration in main
    MockitoAnnotations.openMocks(this);
  }
}

public class Main {
  public static void main(String[] args) {
    MyServiceTest testInstance = new MyServiceTest();
    System.out.println("Mocked repository: " + testInstance.mockRepository.getClass().getName());
    System.out.println("Default fetch data: " + testInstance.mockRepository.fetchData());
  }
}

Snabb kontroll av mocks

Ni vill skapa ett mockobjekt för ett gränssnitt som heter PaymentGateway. Vilket av följande är ett korrekt och vanligt sätt att göra detta i Mockito?

Besvara frågan i den interaktiva lektionen

Sammanfattning: Skapa mocks

Ni har lärt er de grundläggande sätten att skapa mockobjekt med Mockito:

Använd Mockito.mock(ClassToMock.class) för att skapa en mock direkt.
Använd annoteringen @Mock på ett fält, som vanligtvis initieras av @ExtendWith(MockitoExtension.class) i JUnit 5.
Mocks returnerar standardvärden (null, 0, false) vid metodanrop om inget annat har konfigurerats.

Nästa steg är att lära oss hur ni verifierar att era mocks anropades som förväntat!

Gratis att börja

Lär dig Testning på avancerad nivå: JUnit, Mockito och integrationstester med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Skapa mockar med Mockito” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Testning på avancerad nivå: JUnit, Mockito och integrationstester, inklusive ”Skapa mockar med Mockito”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Testning på avancerad nivå: JUnit, Mockito och integrationstester innehåller totalt 4 lektioner.

Vad lär jag mig i ”Skapa mockar med Mockito”?

Använd Mockito för att skapa mockobjekt för beroenden och isolera enheten som testas från dess samarbetande komponenter. Ni övar på Testning på avancerad nivå: JUnit, Mockito och integrationstester med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Testning på avancerad nivå: JUnit, Mockito och integrationstester?

Du behöver inga förkunskaper. Utbildningen i Testning på avancerad nivå: JUnit, Mockito och integrationstester på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Skapa mockar med Mockito”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Testning på avancerad nivå: JUnit, Mockito och integrationstester-lektionen?

Ja. Varje Testning på avancerad nivå: JUnit, Mockito och integrationstester-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Mockar, stubbar och fakes
Skapa mockar med Mockito
Verifiera interaktioner med mockar
Injicera mockar med @Mock och @InjectMocks

← Tillbaka till Testning på avancerad nivå: JUnit, Mockito och integrationstester