Stubbning av returvärden
Konfigurera mockobjekt så att de returnerar specifika värden eller kastar undantag när deras metoder anropas.
Stubbning av returvärden är en gratis lektion i Testning på avancerad nivå: JUnit, Mockito och integrationstester på CoddyKit. Detta är lektion 1 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 stubbing av mocks
När ni skapar ett mockobjekt har det inget verkligt beteende. Dess metoder gör som standard ingenting och returnerar ofta null, 0 eller tomma samlingar.
Stubbing är processen att lära ett mockobjekt hur det ska svara på specifika metodanrop. Det är som att ge er mock ett manus att följa!
Detta låter er styra de exakta förutsättningarna för testerna och isolera den kod ni faktiskt testar.
Få mocks att returnera värden
Det vanligaste sättet att stubba en mock är att använda when().thenReturn(). Det talar om för Mockito: "När den här specifika metoden anropas på mocken ska det här fördefinierade värdet returneras."
when(mock.someMethod()).thenReturn(value);
value kan vara vilket objekt eller vilken primitiv typ som helst, så länge den matchar metodens returtyp.
Kodexempel med thenReturn()
Prova att köra det här enkla exemplet. Observera hur mockens add-metod returnerar vårt stubbade värde endast när den anropas med (1, 1).
import static org.mockito.Mockito.*;
interface CalculatorService {
int add(int a, int b);
}
public class Main {
public static void main(String[] args) {
// Create a mock of CalculatorService
CalculatorService mockCalc = mock(CalculatorService.class);
// Stub the add(1, 1) method to return 5
when(mockCalc.add(1, 1)).thenReturn(5);
// Call the stubbed method
System.out.println("1 + 1 = " + mockCalc.add(1, 1));
// Call a method that was NOT stubbed
System.out.println("2 + 2 = " + mockCalc.add(2, 2));
}
}Mocks som kastar fel
Ibland behöver ni testa hur koden hanterar fel. Ni kan konfigurera en mock så att den kastar ett undantag när en specifik metod anropas genom att använda when().thenThrow().
when(mock.failingMethod()).thenThrow(new SomeException("Error!"));
Detta är avgörande för att testa felvägar och säkerställa att applikationen hanterar oväntade situationer på ett bra sätt.
Kodexempel med thenThrow()
I det här exemplet är vår DataService-mock konfigurerad att kasta ett IllegalArgumentException om vi försöker hämta data med ett "invalid"-ID.
import static org.mockito.Mockito.*;
interface DataService {
String fetchData(String id);
}
public class Main {
public static void main(String[] args) {
DataService mockData = mock(DataService.class);
// Stub fetchData("invalid") to throw an exception
when(mockData.fetchData("invalid"))
.thenThrow(new IllegalArgumentException("ID not found!"));
// Call a method that was NOT stubbed (returns null by default)
System.out.println("Fetching 'valid': " + mockData.fetchData("valid"));
// Call the stubbed method that throws an exception
try {
System.out.println("Fetching 'invalid': " + mockData.fetchData("invalid"));
} catch (IllegalArgumentException e) {
System.out.println("Caught error: " + e.getMessage());
}
}
}Dynamiska svar: thenAnswer()
Vad gör ni om mockens svar behöver bero på argumenten som skickas till den, eller om den ska utföra anpassad logik?
when().thenAnswer() är lösningen. Den tar ett Answer-objekt (ofta ett lambda-uttryck eller en anonym klass) som ger större kontroll:
- Ni får tillgång till de faktiska metodargumenten.
- Ni kan utföra beräkningar eller komplex logik.
- Ni kan dynamiskt returnera ett värde eller kasta ett undantag.
Kodexempel med thenAnswer()
Här utför metoden multiply på vår mock faktiskt multiplikationen utifrån argumenten den tar emot. Detta är mer dynamiskt än ett fast returvärde.
import static org.mockito.Mockito.*;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
interface MathService {
int multiply(int a, int b);
}
public class Main {
public static void main(String[] args) {
MathService mockMath = mock(MathService.class);
// Stub multiply for any two integers to perform actual multiplication
when(mockMath.multiply(anyInt(), anyInt())).thenAnswer(
new Answer<Integer>() {
public Integer answer(InvocationOnMock invocation) {
Object[] args = invocation.getArguments();
Integer arg1 = (Integer) args[0];
Integer arg2 = (Integer) args[1];
return arg1 * arg2; // Custom logic based on arguments
}
}
);
System.out.println("3 * 4 = " + mockMath.multiply(3, 4));
System.out.println("5 * 2 = " + mockMath.multiply(5, 2));
System.out.println("7 * 0 = " + mockMath.multiply(7, 0));
}
}Flera returvärden: kedjning
Vad gör ni om en mockmetod ska returnera olika värden vid efterföljande anrop?
Med Mockito kan ni kedja stubbingmetoder. Ni kan ange flera returvärden till thenReturn() eller kedja flera anrop till thenReturn(), thenThrow() eller thenAnswer().
when(mock.method()).thenReturn(val1, val2, val3);when(mock.method()).thenReturn(val1).thenThrow(ex).thenReturn(val3);
När alla angivna värden eller åtgärder har använts upprepas det sista för efterföljande anrop.
Demonstration av kedjad stubbing
Observera hur vår mock Queue returnerar "Item A", sedan "Item B" och därefter kastar ett undantag vid efterföljande anrop till poll().
import static org.mockito.Mockito.*;
import java.util.Queue;
import java.util.LinkedList;
public class Main {
public static void main(String[] args) {
Queue<String> mockQueue = mock(Queue.class);
// Stub poll() to return different values/actions on successive calls
when(mockQueue.poll())
.thenReturn("Item A")
.thenReturn("Item B")
.thenThrow(new IllegalStateException("Queue is empty!"));
System.out.println("Poll 1: " + mockQueue.poll()); // Returns "Item A"
System.out.println("Poll 2: " + mockQueue.poll()); // Returns "Item B"
try {
System.out.println("Poll 3: " + mockQueue.poll()); // Throws exception
} catch (IllegalStateException e) {
System.out.println("Caught error on Poll 3: " + e.getMessage());
}
// Subsequent calls will repeat the last action (throw exception)
try {
System.out.println("Poll 4: " + mockQueue.poll());
} catch (IllegalStateException e) {
System.out.println("Caught error on Poll 4: " + e.getMessage());
}
}
}Kontrollera era kunskaper
Ni testar en metod som bearbetar objekt från en kö. Ni behöver att köns poll()-metod returnerar "Task 1", sedan "Task 2" och slutligen null (vilket anger en tom kö) vid efterföljande anrop. Vilket sätt att stubba med Mockito skulle ni använda?
Sammanfattning: Stubbade returvärden
I den här lektionen har ni lärt er att styra beteendet hos era mockobjekt genom att stubba deras metodanrop. Detta är grundläggande för att isolera enheten som testas och skapa förutsägbara testmiljöer.
when().thenReturn(): Gör att en mockmetod returnerar ett specifikt värde.when().thenThrow(): Gör att en mockmetod kastar ett undantag.when().thenAnswer(): Ger dynamiska svar baserade på metodargument eller anpassad logik.- Kedjning: Definierar en sekvens av olika beteenden för efterföljande anrop till samma metod.
Nästa steg är att utforska Mockitos argumentmatchare för ännu mer flexibel stubbing och verifiering!
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
Vanliga frågor
Är lektionen ”Stubbning av returvärden” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Testning på avancerad nivå: JUnit, Mockito och integrationstester, inklusive ”Stubbning av returvärden”, 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 ”Stubbning av returvärden”?
Konfigurera mockobjekt så att de returnerar specifika värden eller kastar undantag när deras metoder anropas. 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 1 av 4.
Hur lång tid tar lektionen ”Stubbning av returvärden”?
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
- Stubbning av returvärden
- Argumentmatchare i Mockito
- Spionera på riktiga objekt
- Kasta exceptions och hantera konsekutiva anrop