Mockar, stubbar och fakes
Skilj mellan testdubbeltyperna mockar, stubbar, fakes och dummies och förstå deras roller i testning.
Mockar, stubbar och fakes ä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.
Vad är testdubletter?
När du testar en klass är den ofta beroende av andra klasser. Dessa "beroenden" kan göra tester svåra! Testdubletter är ersättningsobjekt som efterliknar beteendet hos verkliga beroenden.
De hjälper dig att isolera koden du testar, vilket gör testerna snabbare, tillförlitligare och enklare att skriva.
Varför behöver vi dem?
Föreställ dig att du testar en klass som skickar e-post eller kommunicerar med en databas. Du vill inte att testerna ska:
- Faktiskt skicka e-post (skräppost!).
- Bli långsammare genom att ansluta till en riktig databas.
- Vara beroende av externa tjänster som kanske inte är tillgängliga.
Testdubletter löser dessa problem genom att tillhandahålla kontrollerade och förutsägbara ersättningar.
Dummyobjekt: endast platshållare
Ett dummyobjekt är den enklaste typen av testdubblett. Det skickas vidare men används aldrig i praktiken.
Tänk på det som en obligatorisk parameter som koden inte bryr sig om i ett visst testsammanhang. Den fyller bara ut en plats.
- Ofta
nulleller en tom instans. - Inget beteende förväntas från objektet.
- Används när ett argument behövs men saknar betydelse för testet.
Exempel på dummyobjekt: irrelevanta data
Anta att en UserService behöver en EmailSender, men att vi i testsituationen bara bryr oss om att skapa användaren och inte om att skicka e-post.
Här kan en null eller en enkel new EmailSender() fungera som dummyobjekt.
interface EmailSender {
void sendEmail(String to, String subject, String body);
}
class UserService {
private EmailSender emailSender;
public UserService(EmailSender emailSender) {
this.emailSender = emailSender;
}
public boolean createUser(String username) {
// In this specific test, we don't care about emailSender
// emailSender.sendEmail(username + "@example.com", "Welcome", "Hi!");
return true; // Simplified for example
}
}
public class Main {
public static void main(String[] args) {
// Here, null acts as a dummy object for createUser test
EmailSender dummySender = null;
UserService userService = new UserService(dummySender);
boolean created = userService.createUser("testuser");
System.out.println("User created: " + created);
}
}Stubobjekt: förberedda svar
Ett stubobjekt tillhandahåller förprogrammerade svar på metodanrop under ett test. Det utför ingen verklig logik utan returnerar bara specifika värden.
Stubbar passar bra när testet behöver att ett beroende returnerar en viss datamängd för att kunna fortsätta.
- Returnerar fasta, förutbestämda värden.
- Fokuserar på tillståndsbaserad testning.
- Verifierar inte interaktioner utan tillhandahåller bara data.
Exempel på stubobjekt: fasta data
Anta att en ProductService behöver en ProductRepository för att hitta produkter. En stub kan returnera en specifik produkt utan att ansluta till en riktig databas.
interface ProductRepository {
String findProductNameById(int id);
}
class ProductRepositoryStub implements ProductRepository {
@Override
public String findProductNameById(int id) {
if (id == 1) {
return "Laptop";
}
return "Unknown Product";
}
}
class ProductService {
private ProductRepository repository;
public ProductService(ProductRepository repository) {
this.repository = repository;
}
public String getProductDetails(int productId) {
return "Product: " + repository.findProductNameById(productId);
}
}
public class Main {
public static void main(String[] args) {
ProductRepository stub = new ProductRepositoryStub();
ProductService service = new ProductService(stub);
System.out.println(service.getProductDetails(1));
System.out.println(service.getProductDetails(2));
}
}Fakeobjekt: förenklade implementationer
Ett fakeobjekt har en fungerande implementation, men den är förenklad jämfört med den riktiga. Den använder vanligtvis genvägar som gör den olämplig i produktion men perfekt för tester.
En databas i minnet eller en ersättning för ett filsystem är vanliga exempel på fakeobjekt.
- Innehåller viss logik, inte bara förberedda svar.
- Simulerar verkligt beteende, men på ett enklare sätt.
- Användbart för enhetstester som liknar integrationstester.
Exempel på fakeobjekt: databas i minnet
Här är ett fakeobjekt för UserRepository som lagrar användare i en enkel HashMap i stället för i en riktig databas. Det simulerar hur användare läggs till och hittas.
import java.util.HashMap;
import java.util.Map;
interface UserRepository {
void addUser(String name);
String findUser(String name);
}
class InMemoryUserRepository implements UserRepository {
private Map<String, String> users = new HashMap<>();
@Override
public void addUser(String name) {
users.put(name, name);
}
@Override
public String findUser(String name) {
return users.get(name);
}
}
class UserService {
private UserRepository repository;
public UserService(UserRepository repository) {
this.repository = repository;
}
public void registerUser(String username) {
repository.addUser(username);
}
public boolean userExists(String username) {
return repository.findUser(username) != null;
}
}
public class Main {
public static void main(String[] args) {
UserRepository fakeRepo = new InMemoryUserRepository();
UserService service = new UserService(fakeRepo);
service.registerUser("Alice");
System.out.println("Alice exists: " + service.userExists("Alice"));
System.out.println("Bob exists: " + service.userExists("Bob"));
}
}Mockobjekt: verifiera beteende
Ett mockobjekt är en särskild typ av stub som också registrerar interaktioner. Du använder mockobjekt för att verifiera att en viss metod anropades på ett beroende, med specifika argument och ett visst antal gånger.
Mockobjekt är centrala i beteendedriven testning, där fokus ligger på hur objektet interagerar med sina samarbetande objekt.
- Registrerar metodanrop och argument.
- Möjliggör verifiering av interaktioner.
- Skapas ofta av ramverk för mocking, till exempel Mockito!
Mockobjekt kontra stubbar: beteende eller tillstånd?
Den viktigaste skillnaden ligger i syftet:
- Stubbar: Fokuserar på tillståndsverifiering. De tillhandahåller de data som behövs för att testet ska kunna köras, och testet verifierar tillståndet hos systemet som testas.
- Mockobjekt: Fokuserar på beteendeverifiering. De verifierar att systemet som testas interagerade med sina beroenden på ett specifikt sätt.
Du kombinerar ofta båda: en stub tillhandahåller data och ett mockobjekt verifierar en åtgärd.
Testa dina kunskaper om testdubletter
Vilken typ av testdubblett används främst för att verifiera att en viss metod anropades på ett beroende?
Sammanfattning: Familjen av testdubletter
Vi har gått igenom de olika typerna av testdubletter och varför de är viktiga för att skriva bra tester:
- Dummy: En platshållare som skickas vidare men inte används.
- Stub: Tillhandahåller förberedda svar på metodanrop.
- Fake: En förenklad, fungerande implementation.
- Mock: Verifierar interaktioner och beteende.
Med den här förståelsen kan du välja rätt verktyg för att effektivt isolera och testa koden. Nästa steg är att gå igenom hur Mockito hjälper oss att skapa dessa mockobjekt!
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 ”Mockar, stubbar och fakes” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Testning på avancerad nivå: JUnit, Mockito och integrationstester, inklusive ”Mockar, stubbar och fakes”, 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 ”Mockar, stubbar och fakes”?
Skilj mellan testdubbeltyperna mockar, stubbar, fakes och dummies och förstå deras roller i testning. 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 ”Mockar, stubbar och fakes”?
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