Kurs JavaScript i React · Moduł 13: Testowanie React
Mockowanie Modułów i API - Symulator Lotów
W tej lekcji4
W prawdziwym centrum kontroli lotów używa się symulatorów, aby trenować pilotów bez ryzyka uszkodzenia prawdziwego statku. W testach React mockowanie pełni dokładnie tę samą rolę - pozwala testować komponenty bez prawdziwych połączeń z API, bazą danych czy zewnętrznymi serwisami.
Test, który za każdym razem woła prawdziwy serwer, jest wolny, zależy od sieci i potrafi paść w nocy tylko dlatego, że API miało przerwę. Mock zamienia zewnętrzny świat na przewidywalną atrapę, którą sam kontrolujesz.
jest.mock() - Zastępowanie modułów
jest.mock() pozwala zastąpić cały moduł jego mockiem. Każda eksportowana funkcja staje się automatycznie atrapą jest.fn():
// Mockujemy cały moduł API
jest.mock('./api/missionApi');
import { fetchMission, launchMission } from './api/missionApi';
test('displays mission data', async () => {
// Ustawiamy co ma zwrócić mock
fetchMission.mockResolvedValue({
id: 1,
name: 'Apollo 13',
status: 'Active'
});
render(<MissionPanel />);
expect(await screen.findByText('Apollo 13')).toBeInTheDocument();
expect(fetchMission).toHaveBeenCalledTimes(1);
});jest.mock stoi nad importem, ale nawet gdyby był niżej, babel-jest i tak przeniesie go na samą górę pliku. Dzięki temu import dostaje już wersję zmockowaną, a my ustalamy jej wynik przez mockResolvedValue. Funkcja launchMission, której ten test nie używa, też jest teraz atrapą i zwraca undefined, dopóki nie ustawisz jej wyniku.
Mockowanie z implementacją
Drugi argument jest.mock to fabryka, która zwraca własną wersję modułu. Przydaje się, gdy automatyczne atrapy zwracające undefined nie wystarczą:
jest.mock('./utils/navigation', () => ({
calculateRoute: jest.fn((from, to) => ({
distance: 100,
duration: '2 hours',
fuel: 50
})),
isValidCoordinate: jest.fn(() => true),
}));Każda funkcja jest nadal jest.fn, więc możesz sprawdzić jej wywołania, ale od razu zwraca sensowne dane.
Częściowe mockowanie
Czasem chcesz podmienić tylko jedną funkcję, a resztę modułu zostawić prawdziwą:
jest.mock('./utils/spacemath', () => ({
...jest.requireActual('./utils/spacemath'),
// Nadpisujemy TYLKO jedną funkcję
calculateGravity: jest.fn(() => 9.81),
}));jest.requireActual wczytuje oryginalny moduł, a rozproszenie ... kopiuje wszystkie jego eksporty. Nadpisujemy tylko calculateGravity, reszta działa jak w produkcji.
Mockowanie fetch / axios
Gdy komponent sam woła fetch lub axios, możemy podmienić właśnie te funkcje.
Mockowanie globalnego fetch
global.fetch to globalna funkcja, więc przed każdym testem zastępujemy ją świeżą atrapą:
beforeEach(() => {
global.fetch = jest.fn();
});
afterEach(() => {
jest.restoreAllMocks();
});
test('fetches planets from API', async () => {
fetch.mockResolvedValueOnce({
ok: true,
json: () => Promise.resolve([
{ id: 1, name: 'Mars' },
{ id: 2, name: 'Jupiter' },
]),
});
render(<PlanetList />);
expect(await screen.findByText('Mars')).toBeInTheDocument();
expect(screen.getByText('Jupiter')).toBeInTheDocument();
expect(fetch).toHaveBeenCalledWith('/api/planets');
});Atrapa zwraca obiekt z polem ok i metodą json, bo tylko z nich korzysta komponent. Uwaga na jest.restoreAllMocks(): przywraca oryginały tylko dla mocków utworzonych przez jest.spyOn. Ręcznie przypisany global.fetch zostaje nadpisany dopiero w kolejnym beforeEach. Do zerowania licznika wywołań służy jest.clearAllMocks().
Sprzątanie mocków między testami
Atrapa pamięta swoje wywołania między testami, więc licznik z jednego testu potrafi zepsuć asercję toHaveBeenCalledTimes w następnym. Dlatego czyszczenie stawia się w beforeEach:
beforeEach(() => {
jest.clearAllMocks();
});Trzy funkcje sprzątające łatwo pomylić:
jest.clearAllMocks()zeruje historię wywołań (mock.calls,mock.results), ale zostawia ustawione odpowiedzi, np.mockResolvedValuejest.resetAllMocks()robi to samo i dodatkowo usuwa odpowiedzi, więc atrapy znów zwracająundefinedjest.restoreAllMocks()przywraca prawdziwe funkcje podmienione przezjest.spyOn
Ten sam efekt bez pisania beforeEach dają opcje clearMocks, resetMocks i restoreMocks w konfiguracji Jest.
Mockowanie axios
Z biblioteką axios postępujemy jak z każdym modułem. Do wpisywania tekstu używamy userEvent.setup():
jest.mock('axios');
import axios from 'axios';
import userEvent from '@testing-library/user-event';
test('posts new mission', async () => {
const user = userEvent.setup();
axios.post.mockResolvedValue({
data: { id: 42, name: 'New Mission', status: 'Created' }
});
render(<CreateMissionForm />);
await user.type(screen.getByLabelText('Mission Name'), 'Artemis');
await user.click(screen.getByRole('button', { name: 'Create' }));
expect(axios.post).toHaveBeenCalledWith('/api/missions', {
name: 'Artemis'
});
expect(await screen.findByText('Mission created!')).toBeInTheDocument();
});Sprawdzamy dwie rzeczy: czy axios.post dostał właściwy adres i dane oraz czy użytkownik zobaczył komunikat o sukcesie.
MSW (Mock Service Worker) - Zaawansowane Mockowanie API
Mockowanie fetch czy axios bezpośrednio działa, ale ma pewną wadę - testujesz implementację (czy użyłeś fetch, czy axios), a nie zachowanie (czy dane zostały pobrane). MSW rozwiązuje ten problem, przechwytując żądania na poziomie sieci. To jak symulator, który udaje prawdziwą komunikację satelitarną - Twój komponent "myśli", że rozmawia z prawdziwym serwerem, ale w rzeczywistości odpowiedzi generuje MSW. Dzięki temu test jest bardziej realistyczny i odporny na zmiany implementacji. Poniższy kod używa API MSW 2, czyli http i HttpResponse. Starsze rest z res(ctx.json()) to składnia MSW 1, usunięta w wersji 2:
import { http, HttpResponse } from 'msw';
import { setupServer } from 'msw/node';
// Definiujemy handlery
const handlers = [
http.get('/api/missions', () => {
return HttpResponse.json([
{ id: 1, name: 'Apollo 11', status: 'Completed' },
{ id: 2, name: 'Artemis I', status: 'Active' },
]);
}),
http.post('/api/missions', async ({ request }) => {
const body = await request.json();
return HttpResponse.json(
{ id: 3, name: body.name, status: 'Created' },
{ status: 201 }
);
}),
];
// Tworzymy serwer
const server = setupServer(...handlers);
// Setup i teardown
beforeAll(() => server.listen());
afterEach(() => server.resetHandlers());
afterAll(() => server.close());
test('lists missions from API', async () => {
render(<MissionList />);
expect(await screen.findByText('Apollo 11')).toBeInTheDocument();
expect(screen.getByText('Artemis I')).toBeInTheDocument();
});setupServer z msw/node uruchamia przechwytywanie w środowisku Node, w którym działa Jest. Handler dla POST odczytuje treść żądania przez await request.json(), tak jak zrobiłby to prawdziwy serwer.
W Jest MSW wymaga dwóch poprawek konfiguracji. Pierwsza: MSW potrzebuje globalnych Request, Response i fetch, których środowisko jsdom nie ma, więc z samym testEnvironment: 'jsdom' test padnie z błędem Request is not defined. Dokumentacja MSW zaleca pakiet jest-fixed-jsdom i ustawienie testEnvironment: 'jest-fixed-jsdom'. Druga: część zależności MSW jest wydana tylko jako moduły ESM, więc na Node starszym niż 24.9 Jest zgłosi Must use import to load ES Module. Wtedy dodaj wskazane w komunikacie pakiety do wyjątków w transformIgnorePatterns i ustaw transform tak, żeby babel-jest obsługiwał też pliki .mjs.
Nadpisywanie handlerów w pojedynczym teście
server.use dodaje handler tylko na czas jednego testu, a resetHandlers w afterEach przywraca stan wyjściowy:
test('handles server error', async () => {
// Tylko dla tego testu -- zwracamy błąd
server.use(
http.get('/api/missions', () => {
return HttpResponse.json({ error: 'Server error' }, { status: 500 });
})
);
render(<MissionList />);
expect(await screen.findByText('Failed to load missions')).toBeInTheDocument();
});Tak testujesz ścieżkę błędu bez zmieniania wspólnych handlerów. Komponent dostaje status 500 i pokazuje komunikat o awarii.
Mockowanie timerów
Wiele komponentów korzysta z setTimeout lub setInterval - na przykład automatyczne odświeżanie danych co 30 sekund, odliczanie do startu misji czy animacje. W testach nie chcemy czekać prawdziwych 30 sekund! Jest udostępnia fake timery, które pozwalają "przewijać czas" jak w symulatorze lotów. Wywołujesz jest.useFakeTimers(), a potem jest.advanceTimersByTime(ms), aby przeskoczyć o określoną liczbę milisekund. Weźmy panel, który pobiera dane przy montowaniu, a potem co interval milisekund:
function AutoRefreshPanel({ fetchData, interval }) {
const [data, setData] = useState(null);
useEffect(() => {
const load = () => fetchData().then(setData);
load();
const id = setInterval(load, interval);
return () => clearInterval(id);
}, [fetchData, interval]);
return <p>{data ? 'Dane odświeżone' : 'Ładowanie...'}</p>;
}Test podaje komponentowi atrapę fetchData, która od razu zwraca dane, i przewija zegar o pełne interwały:
test('auto-refreshes data every 30 seconds', async () => {
jest.useFakeTimers();
const mockFetch = jest.fn().mockResolvedValue({ data: [] });
render(<AutoRefreshPanel fetchData={mockFetch} interval={30000} />);
// Pierwsze wywołanie przy montowaniu
expect(mockFetch).toHaveBeenCalledTimes(1);
// Po 30 sekundach: drugie wywołanie
await act(async () => {
jest.advanceTimersByTime(30000);
});
expect(mockFetch).toHaveBeenCalledTimes(2);
// Po kolejnych 30 sekundach
await act(async () => {
jest.advanceTimersByTime(30000);
});
expect(mockFetch).toHaveBeenCalledTimes(3);
jest.useRealTimers();
});Każde przewinięcie o 30 sekund odpala jeden cykl odświeżania, więc licznik wywołań rośnie o jeden. Atrapa zwraca Promise, więc nowy stan pojawia się dopiero po jego rozwiązaniu, chwilę po przewinięciu zegara. Dlatego używamy asynchronicznej wersji await act(async () => ...): czeka ona także na takie obietnice, zanim się zakończy. Ze zwykłym act(() => ...) liczniki też by się zgadzały, ale React wypisałby w konsoli trzy ostrzeżenia "not wrapped in act(...)".
Moja rada: do komponentów, które rozmawiają z API, wybieraj MSW, a jest.mock zostaw na moduły bez sieci. W następnej lekcji przetestujesz własne hooki. Pamiętaj: mock to symulator lotu, w którym trenujesz każdy scenariusz, także awarię, zanim ruszysz w prawdziwy kosmos.
Kod do tej lekcji: App.jsx
import React, { useState, useEffect, useCallback } from 'react';
// ===== Moduł API (w projekcie byłby to osobny plik missionApi.js) =====
// Podgląd nie ma serwera, więc moduł udaje sieć: Promise + setTimeout.
// W teście podmieniasz go przez jest.mock('./missionApi') albo MSW.
const STATUS_LABELS = { completed: 'zakończona', active: 'aktywna', created: 'utworzona' };
let serverMissions = [
{ id: 1, name: 'Apollo 11', status: 'completed' },
{ id: 2, name: 'Artemis I', status: 'active' },
];
let serverDown = false;
const missionApi = {
fetchMissions() {
return new Promise((resolve, reject) => {
setTimeout(() => {
if (serverDown) reject(new Error('HTTP 500'));
else resolve([...serverMissions]);
}, 700);
});
},
createMission(data) {
return new Promise(resolve => {
setTimeout(() => {
const created = { id: Date.now(), name: data.name, status: 'created' };
serverMissions = [...serverMissions, created];
resolve(created);
}, 400);
});
},
setServerDown(value) {
serverDown = value;
},
};
// Komponent, który w testach dostaje zmockowane API
function MissionCenter() {
const [missions, setMissions] = useState([]);
const [loading, setLoading] = useState(true);
const [error, setError] = useState(null);
const [newName, setNewName] = useState('');
const loadMissions = useCallback(async () => {
setLoading(true);
try {
// W testach: missionApi.fetchMissions.mockResolvedValue([...])
const data = await missionApi.fetchMissions();
setMissions(data);
setError(null);
} catch (err) {
setError('Nie udało się pobrać misji');
} finally {
setLoading(false);
}
}, []);
useEffect(() => {
loadMissions();
}, [loadMissions]);
const handleCreate = async (e) => {
e.preventDefault();
if (!newName.trim()) return;
const created = await missionApi.createMission({ name: newName.trim() });
setMissions(prev => [...prev, created]);
setNewName('');
};
if (loading) return <div className="status" role="status">Ładowanie misji...</div>;
if (error) {
return (
<div className="status error">
<p role="alert">{error}</p>
<button className="refresh" onClick={loadMissions}>Spróbuj ponownie</button>
</div>
);
}
return (
<div className="mission-center">
<h2>Centrum misji</h2>
<form className="create-form" onSubmit={handleCreate}>
<input
type="text"
placeholder="Nazwa nowej misji..."
value={newName}
onChange={e => setNewName(e.target.value)}
aria-label="Nazwa misji"
/>
<button type="submit">Utwórz</button>
</form>
<ul className="mission-list">
{missions.map(m => (
<li key={m.id}>{m.name} - {STATUS_LABELS[m.status]}</li>
))}
</ul>
<button className="refresh" onClick={loadMissions}>
Odśwież
</button>
</div>
);
}
// Automatyczne odświeżanie: w testach przewijasz czas fake timerami
function AutoRefreshStatus({ interval = 5000 }) {
const [systemStatus, setSystemStatus] = useState({
engine: 'w normie',
shields: 100,
lastUpdate: new Date().toLocaleTimeString('pl-PL'),
});
const [refreshCount, setRefreshCount] = useState(0);
useEffect(() => {
const timer = setInterval(() => {
setRefreshCount(c => c + 1);
setSystemStatus(prev => ({
...prev,
shields: Math.max(prev.shields - 1, 0),
lastUpdate: new Date().toLocaleTimeString('pl-PL'),
}));
}, interval);
return () => clearInterval(timer);
}, [interval]);
return (
<div className="auto-refresh">
<h2>Stan systemów (odświeżanie co {interval / 1000} s)</h2>
<div className="status-grid">
<div>Silnik: {systemStatus.engine}</div>
<div>Osłony: {systemStatus.shields}%</div>
<div>Ostatni odczyt: {systemStatus.lastUpdate}</div>
<div>Liczba odświeżeń: {refreshCount}</div>
</div>
</div>
);
}
export default function App() {
const [down, setDown] = useState(false);
const [run, setRun] = useState(0);
const toggleServer = (e) => {
missionApi.setServerDown(e.target.checked);
setDown(e.target.checked);
setRun(r => r + 1);
};
return (
<div className="app">
<h1>Mockowanie modułów i API</h1>
<p className="info">
Podgląd nie uruchamia Jesta. Tutaj moduł missionApi udaje serwer
(Promise + setTimeout), a w testach z lekcji podmieniasz go mockiem.
</p>
<label className="server-toggle">
<input type="checkbox" checked={down} onChange={toggleServer} />
Symuluj awarię serwera (HTTP 500)
</label>
<MissionCenter key={run} />
<AutoRefreshStatus interval={3000} />
</div>
);
}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.mock('./api/missionApi') w teście?
2. Jaka jest główna zaleta MSW (Mock Service Worker) w porównaniu z mockowaniem fetch?
Zadania praktyczne w grze
- Układanie w pionie
Ułóż cykl życia mockowanego fetch w testach:
- Edytor kodu
Dokończ reducer missionReducer i hook useMissionTracker dziennika misji. ___BLANK1___: akcja START zmienia status zaplanowanej misji na 'active', zwracając nowy obiekt z pozostałymi polami misji (nie zmieniaj obiektu, który jest w stanie). ___BLANK2___: akcja REMOVE zwraca nową tablicę bez misji o id z akcji (action.id). ___BLANK3___: hook przekazuje do useReducer reducer missionReducer. Test sprawdza reducer jak czystą funkcję na zamrożonym stanie (Object.freeze), a hook uruchamia w małym komponencie testowym: dodaje dwie misje, startuje, kończy i usuwa.
- Klikanie w kolejności
Ułóż składnię tworzenia mocka z wartością Promise:
- Układanie w poziomie
Ułóż składnię bloku beforeEach z czyszczeniem mocków: