Kurs JavaScript i React · Moduł 13: Testowanie React

Mockowanie Modułów i API - Symulator Lotów

7 min czytania ·
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. mockResolvedValue
  • jest.resetAllMocks() robi to samo i dodatkowo usuwa odpowiedzi, więc atrapy znów zwracają undefined
  • jest.restoreAllMocks() przywraca prawdziwe funkcje podmienione przez jest.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. 1. Co robi jest.mock('./api/missionApi') w teście?

  2. 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:

  1. Pytaniejest.mock() - zastępowanie modułów
  2. Ułóż w kolejnościŻycie mocka w testach
  3. Zadanie z kodemPraktyka: Hook useReducer
  4. Kliknij w kolejnościSkładnia jest.fn().mockResolvedValue
  5. PytanieMSW vs mockowanie fetch
  6. Ułóż w kolejnościSkładnia beforeEach w testach

Przydatne artykuły