Kurs JavaScript i TypeScript · Moduł 11: Testowanie z Jest

Mockowanie w Jest

6 min czytania ·
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. 1. Co robi jest.fn() w Jest?

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

  1. PytanieFunkcja jest.fn()
  2. PytanieRóżnica między jest.fn() a spyOn
  3. Zadanie z kodemMockowanie systemu alertów
  4. Ułóż w kolejnościSkładnia mockReturnValue
  5. PytanieMatcher toHaveBeenCalledWith
  6. Zadanie z kodemSpyOn - monitorowanie metod

Przydatne artykuły