Kurs JavaScript i TypeScript · Moduł 11: Testowanie z Jest
Mockowanie w Jest
W tej lekcji5
System bezpieczeństwa parku po wykryciu naruszenia wysyła SMS do strażników. Test takiego systemu nie może naprawdę wysyłać wiadomości przy każdym uruchomieniu - byłby wolny, zależny od sieci, a strażnicy szybko przestaliby reagować na alarmy. Potrzebujemy dublera: czegoś, co wygląda jak prawdziwa funkcja, ale niczego nie wysyła, za to notuje, kto i z czym go wywołał.
Mockowanie to tworzenie sztucznych wersji funkcji, modułów lub obiektów. W Parku Jurajskim to jak tworzenie modeli dinozaurów do testów bezpieczeństwa zamiast używania prawdziwych bestii.
jest.fn() - tworzenie mock funkcji
jest.fn() tworzy "pustą" funkcję, która rejestruje wszystkie wywołania. Domyślnie zwraca undefined, a do sprawdzania jej historii służą matchery z rodziny toHaveBeenCalled:
test('jest.fn() - podstawy', () => {
// Tworzenie mock funkcji
const feedDino = jest.fn();
// Wywołanie mock funkcji
feedDino('Rex', 'meat');
feedDino('Brachio', 'plants');
// Sprawdzanie wywołań
expect(feedDino).toHaveBeenCalled();
expect(feedDino).toHaveBeenCalledTimes(2);
expect(feedDino).toHaveBeenCalledWith('Rex', 'meat');
expect(feedDino).toHaveBeenLastCalledWith('Brachio', 'plants');
});toHaveBeenCalled pyta, czy funkcja w ogóle zadziałała, toHaveBeenCalledTimes - ile razy, toHaveBeenCalledWith - czy choć raz dostała te argumenty, a toHaveBeenLastCalledWith - z czym ją wywołano ostatnio. Mock nikogo nie nakarmił, tylko zapisał, że próbowano.
Mock z implementacją
Możesz nadać mockowi zachowanie: mockReturnValue ustawia wartość zwracaną przy każdym wywołaniu, mockReturnValueOnce tylko przy jednym, a funkcja przekazana do jest.fn staje się pełną implementacją:
test('mock z implementacją', () => {
// Mock z wartością zwracaną
const getHealth = jest.fn().mockReturnValue(100);
expect(getHealth()).toBe(100);
// Mock z różnymi wartościami dla kolejnych wywołań
const checkSensor = jest.fn()
.mockReturnValueOnce('OK')
.mockReturnValueOnce('WARNING')
.mockReturnValueOnce('DANGER');
expect(checkSensor()).toBe('OK');
expect(checkSensor()).toBe('WARNING');
expect(checkSensor()).toBe('DANGER');
// Mock z własną implementacją
const calculateDamage = jest.fn((attack, defense) => {
return Math.max(0, attack - defense);
});
expect(calculateDamage(50, 30)).toBe(20);
expect(calculateDamage(10, 30)).toBe(0);
});Łańcuch mockReturnValueOnce odtwarza scenariusz krok po kroku: czujnik melduje OK, potem ostrzeżenie, a na końcu zagrożenie. Gdy wartości jednorazowe się wyczerpią, mock wraca do mockReturnValue, a jeśli go nie ustawiono, do undefined. Dla funkcji asynchronicznych istnieją odpowiedniki: mockResolvedValue zwraca obietnicę spełnioną podaną wartością, a mockRejectedValue obietnicę odrzuconą.
jest.mock() - mockowanie modułów
jest.mock() pozwala zastąpić cały moduł mockiem. Najpierw spójrz na moduł, którego nie chcemy uruchamiać w testach - sendAlert wysyła alert przez fetch do API parku:
// Plik: alertService.js
export function sendAlert(zone, message) {
// W rzeczywistości wysyła email/SMS - nie chcemy tego w testach!
return fetch('/api/alerts', {
method: 'POST',
body: JSON.stringify({ zone, message })
});
}W pliku testowym wywołanie jest.mock('./alertService') zastępuje wszystkie funkcje tego modułu mockami zwracającymi undefined, a require pobiera już podmienioną wersję. SecuritySystem to testowana klasa, która wewnętrznie korzysta z alertService:
// Plik: securitySystem.test.js
jest.mock('./alertService');
const { sendAlert } = require('./alertService');
describe('SecuritySystem', () => {
beforeEach(() => {
// Resetuj mocki przed każdym testem
sendAlert.mockClear();
sendAlert.mockResolvedValue({ status: 'sent' });
});
it('should send alert on breach', async () => {
const system = new SecuritySystem();
await system.reportBreach('Zone A');
expect(sendAlert).toHaveBeenCalledWith(
'Zone A',
expect.stringContaining('naruszenie')
);
});
});Test sprawdza, że system poprosił o wysłanie alertu, ale żaden SMS nie wyszedł. expect.stringContaining to matcher asymetryczny: akceptuje każdy string zawierający podany fragment. Zwróć też uwagę na kolejność: z babel-jest wywołania jest.mock są automatycznie przenoszone na początek pliku (hoisting), więc mock zadziała, nawet gdy import stoi wyżej.
jest.mock z fabryką
Automatyczny mock nie zawsze wystarcza. Drugi argument jest.mock to fabryka: funkcja zwracająca obiekt, który udaje moduł. Masz wtedy pełną kontrolę nad tym, co moduł eksportuje:
jest.mock('./alertService', () => ({
sendAlert: jest.fn().mockResolvedValue({ status: 'sent' }),
}));Tym razem sendAlert od początku zwraca spełnioną obietnicę, więc konfiguracja w beforeEach przestaje być potrzebna. Hoisting ma jednak konsekwencję: fabryka nie może używać zmiennych zadeklarowanych poza nią, chyba że ich nazwa zaczyna się od słowa mock.
jest.spyOn() - szpiegowanie metod
spyOn monitoruje istniejącą metodę bez jej zastępowania (domyślnie). Różnica jest zasadnicza: jest.fn tworzy nową, pustą funkcję, a jest.spyOn owija metodę, która już istnieje w obiekcie, i nadal wywołuje oryginał:
test('spyOn - monitorowanie metody', () => {
const park = {
dinosaurs: [],
addDinosaur(dino) {
this.dinosaurs.push(dino);
return this.dinosaurs.length;
},
getDinosaurCount() {
return this.dinosaurs.length;
}
};
// Szpieguj metodę - zachowuje oryginalną implementację
const spy = jest.spyOn(park, 'addDinosaur');
park.addDinosaur({ name: 'Rex' });
park.addDinosaur({ name: 'Blue' });
// Sprawdź wywołania
expect(spy).toHaveBeenCalledTimes(2);
expect(spy).toHaveBeenCalledWith({ name: 'Rex' });
// Oryginalna funkcja nadal działa!
expect(park.dinosaurs).toHaveLength(2);
// Przywróć oryginalną implementację
spy.mockRestore();
});Szpieg zanotował oba wywołania, a dinozaury i tak trafiły do parku, bo oryginalna metoda zadziałała. mockRestore na końcu zdejmuje szpiega i przywraca metodę sprzed testu. Działa tylko dla mocków utworzonych przez spyOn.
spyOn z podmianą implementacji
Czasem chcesz podsłuchać metodę i jednocześnie zablokować jej prawdziwe działanie, bo na przykład łączy się z siecią. Wtedy do spyOn dopinasz mockImplementation. Podmieniona metoda zwraca obietnicę, więc test jest async i czeka na wynik przez await:
test('spyOn - podmiana implementacji', async () => {
const api = {
fetchDinoData(id) {
// Normalne wywołanie API - nie chcemy tego w testach
return fetch(`/api/dinosaurs/${id}`);
}
};
// Zastąp implementację na czas testu
const spy = jest.spyOn(api, 'fetchDinoData').mockImplementation((id) => {
return Promise.resolve({
id,
name: 'Mock Rex',
species: 'T-Rex'
});
});
// Teraz fetchDinoData zwraca mock data
const data = await api.fetchDinoData('001');
expect(data.name).toBe('Mock Rex');
spy.mockRestore();
});Gdybyś zamiast await dopisał samo .then(...) bez return, test zakończyłby się przed spełnieniem obietnicy i zostałby zaliczony, zanim asercja w ogóle się wykona. Tej pułapce przyjrzymy się dokładnie w następnej lekcji.
Sprawdzanie wywołań mock
Jest udostępnia bogaty zestaw matcherów dla mocków. Każdy mock ma też właściwość mock.calls: tablicę, w której każdy element to lista argumentów jednego wywołania:
test('matchery dla mocków', () => {
const callback = jest.fn();
callback('Rex');
callback('Blue', 'raptor');
// Czy został wywołany?
expect(callback).toHaveBeenCalled();
// Ile razy?
expect(callback).toHaveBeenCalledTimes(2);
// Z jakimi argumentami?
expect(callback).toHaveBeenCalledWith('Rex');
expect(callback).toHaveBeenNthCalledWith(1, 'Rex');
expect(callback).toHaveBeenNthCalledWith(2, 'Blue', 'raptor');
// Dostęp do szczegółów wywołań
expect(callback.mock.calls).toHaveLength(2);
expect(callback.mock.calls[0]).toEqual(['Rex']);
expect(callback.mock.calls[1]).toEqual(['Blue', 'raptor']);
});toHaveBeenNthCalledWith numeruje wywołania od 1, a mock.calls to zwykła tablica indeksowana od 0, stąd różne numery w tym samym teście. Matchery dają czytelniejsze komunikaty błędów, więc po mock.calls sięgaj tylko w nietypowych sytuacjach.
Sprzątanie po mockach
Mock pamięta wywołania także między testami. Dlatego w przykładzie z alertService hook beforeEach wywołuje mockClear, który czyści historię wywołań. mockReset robi to samo i dodatkowo usuwa ustawione zachowanie, a mockRestore przywraca jeszcze oryginalną metodę po spyOn. Dla wszystkich mocków naraz działają jest.clearAllMocks, jest.resetAllMocks i jest.restoreAllMocks, a opcja clearMocks: true w konfiguracji czyści historię automatycznie przed każdym testem.
Moja rada: mockuj granice systemu, czyli sieć, bazę danych, zegar i SMS-y, a nie własną logikę. Jeśli podmienisz wszystko, test sprawdzi tylko, czy mocki działają. W następnej lekcji mockResolvedValue spotka się z testowaniem kodu asynchronicznego, a w laboratorium poniżej zobaczysz, jak od środka działa uproszczony jest.fn().
Pamiętaj: mock to dubler dinozaura na próbie bezpieczeństwa - wygląda jak prawdziwy, nie gryzie i dokładnie notuje każdy ruch.
Kod do tej lekcji: index.js
// Mockowanie - jest.fn(), jest.mock(), spyOn
console.log("=== Park Jurajski - Klonowanie i Mockowanie ===\n");
// Symulacja jest.fn()
function createMockFn(impl) {
const mock = {
calls: [],
results: [],
returnValues: [],
implementations: impl ? [impl] : [],
};
function mockFn(...args) {
mock.calls.push(args);
let result;
if (mock.returnValues.length > 0) {
result = mock.returnValues.shift();
} else if (mock.implementations.length > 0) {
result = mock.implementations[0](...args);
} else {
result = undefined;
}
mock.results.push(result);
return result;
}
mockFn.mock = mock;
mockFn.mockReturnValue = (val) => {
mock.implementations = [() => val];
return mockFn;
};
mockFn.mockReturnValueOnce = (val) => {
mock.returnValues.push(val);
return mockFn;
};
mockFn.mockImplementation = (fn) => {
mock.implementations = [fn];
return mockFn;
};
mockFn.mockClear = () => {
mock.calls = [];
mock.results = [];
};
return mockFn;
}
// --- jest.fn() basics ---
console.log("--- jest.fn() - tworzenie mock funkcji ---\n");
const feedDino = createMockFn();
feedDino("Rex", "meat");
feedDino("Brachio", "plants");
console.log("Wywolania:", feedDino.mock.calls);
console.log("Liczba wywolan:", feedDino.mock.calls.length);
console.log("Pierwsze wywolanie:", feedDino.mock.calls[0]);
console.log("Drugie wywolanie:", feedDino.mock.calls[1]);
// --- Mock z wartoscia zwracana ---
console.log("\n--- Mock z wartoscia zwracana ---\n");
const getHealth = createMockFn();
getHealth.mockReturnValue(100);
console.log("getHealth():", getHealth());
console.log("getHealth():", getHealth());
// --- Mock z roznymi wartosciami ---
console.log("\n--- Mock z roznymi wartosciami (mockReturnValueOnce) ---\n");
const checkSensor = createMockFn();
checkSensor.mockReturnValueOnce("OK");
checkSensor.mockReturnValueOnce("WARNING");
checkSensor.mockReturnValueOnce("DANGER");
console.log("Odczyt 1:", checkSensor());
console.log("Odczyt 2:", checkSensor());
console.log("Odczyt 3:", checkSensor());
// --- Mock z implementacja ---
console.log("\n--- Mock z implementacja ---\n");
const calculateDamage = createMockFn((attack, defense) => {
return Math.max(0, attack - defense);
});
console.log("damage(50, 30):", calculateDamage(50, 30));
console.log("damage(10, 30):", calculateDamage(10, 30));
console.log("Wywolania:", calculateDamage.mock.calls);
// --- spyOn - szpiegowanie metod ---
console.log("\n--- spyOn - monitorowanie istniejacych metod ---\n");
const park = {
dinosaurs: [],
addDinosaur(dino) {
this.dinosaurs.push(dino);
return this.dinosaurs.length;
}
};
// Symulacja spyOn
const originalAdd = park.addDinosaur.bind(park);
const spyCalls = [];
park.addDinosaur = function(...args) {
spyCalls.push(args);
return originalAdd(...args);
};
park.addDinosaur({ name: "Rex" });
park.addDinosaur({ name: "Blue" });
console.log("Spy wywolania:", spyCalls.length);
console.log("Pierwsze wywolanie:", JSON.stringify(spyCalls[0]));
console.log("Dinozaurow w parku:", park.dinosaurs.length);
console.log("(Oryginalna funkcja nadal dziala!)");
// --- Matchery dla mockow ---
console.log("\n--- Sprawdzanie wywolan mock ---\n");
const callback = createMockFn();
callback("Rex");
callback("Blue", "raptor");
console.log("Czy wywolany?", callback.mock.calls.length > 0 ? "TAK" : "NIE");
console.log("Ile razy?", callback.mock.calls.length);
console.log("Wszystkie wywolania:", JSON.stringify(callback.mock.calls));Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Co robi jest.fn() w Jest?
2. Jaka jest główna różnica między jest.fn() a jest.spyOn()?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Użyj mock funkcji do testowania systemu alarmowego parku.
- Układanie w poziomie
Ułóż elementy konfiguracji mock return value:
- Edytor kodu
Monitoruj metody systemu parku za pomocą spyOn i sprawdź wywołania.