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

Framework Jest - podstawy

6 min czytania ·
W tej lekcji5

W poprzedniej lekcji test pojawił się jak gotowy czujnik. Tylko kto go uruchamia, zbiera wyniki i podnosi alarm, gdy coś pójdzie nie tak? Potrzebujesz centrum kontroli, które samo znajdzie pliki z testami, wykona je i zamelduje, co przeszło, a co nie.

Jest należy do najpopularniejszych narzędzi do testowania JavaScriptu i TypeScriptu. Powstał w Facebooku (dziś Meta), a od 2022 roku rozwija go OpenJS Foundation. W naszym Parku Jurajskim Jest będzie głównym narzędziem do weryfikacji systemów bezpieczeństwa - w tym module opieramy się na jego wersji 30.

Instalacja i konfiguracja

Jest instalujesz jako zależność deweloperską: trafia do sekcji devDependencies w pliku package.json, bo potrzebujesz go podczas pracy nad kodem, a nie na produkcji. Oto komendy, od których zaczyna się każdy projekt:

# Instalacja Jest
npm install --save-dev jest

# Dla TypeScript
npm install --save-dev jest ts-jest @types/jest

# Inicjalizacja konfiguracji
npm init jest@latest

Pierwsza komenda wystarczy do testowania JavaScriptu, druga dokłada paczki dla TypeScriptu - wrócimy do nich w lekcji o testowaniu TS. Ostatnia uruchamia kreator, który zada kilka pytań i zapisze plik konfiguracyjny. W starszych wersjach służyła do tego komenda npx jest --init, ale Jest 30 ją usunął. Warto też dopisać w package.json skrypt "test": "jest" - wtedy całą baterię testów uruchomisz przez npm test.

Struktura testu

Każdy test w Jest składa się z trzech kluczowych elementów: describe, it (lub test) oraz expect. Nie musisz ich importować, bo Jest udostępnia je jako funkcje globalne w każdym pliku testowym. Same pliki też znajdzie bez Twojej pomocy: domyślnie uruchamia wszystko, co kończy się na .test.js lub .spec.js (także w wariantach TypeScript), oraz pliki w folderze __tests__.

describe - grupowanie testów

describe to blok grupujący powiązane testy. Pomyśl o nim jak o wybiegu w parku - grupuje dinozaury tego samego gatunku. Pierwszy argument to nazwa grupy, drugi to funkcja, w której umieszczasz testy:

describe('DinosaurEnclosure', () => {
  // Wszystkie testy związane z wybiegiem dinozaurów
});

Sam describe niczego nie sprawdza. Porządkuje raport: w wynikach zobaczysz nazwę DinosaurEnclosure, a pod nią wszystkie testy z tego wybiegu. Bloki można zagnieżdżać, co zobaczysz za chwilę w pełnym przykładzie.

it / test - pojedynczy przypadek testowy

it i test są zamienne - oba definiują pojedynczy test. Dokumentacja Jesta opisuje it wprost jako alias test: to ta sama funkcja pod dwiema nazwami. Konwencja: it czyta się jak zdanie w języku angielskim. W jednym describe możesz nawet mieszać obie formy:

describe('DinosaurEnclosure', () => {
  it('should have a fence', () => {
    // sprawdzenie
  });

  test('fence is electrified', () => {
    // sprawdzenie
  });
});

Oba testy działają identycznie. Pierwszy czyta się jak zdanie "it should have a fence", czyli "powinien mieć ogrodzenie". Polecam it wewnątrz describe, a test dla testów luzem, ale najważniejsza jest konsekwencja w całym projekcie.

expect - asercje

expect to serce każdego testu. Porównuje rzeczywisty wynik z oczekiwanym. Zapis zawsze ma dwie części: expect(wartość) opakowuje wynik, a matcher, np. toBe czy toEqual, mówi, czego oczekujesz. createEnclosure to fabryka zwracająca obiekt wybiegu z nazwą, pojemnością i pustą listą dinozaurów:

describe('DinosaurEnclosure', () => {
  it('should have correct capacity', () => {
    const enclosure = createEnclosure('T-Rex Zone', 5);
    expect(enclosure.capacity).toBe(5);
  });

  it('should start empty', () => {
    const enclosure = createEnclosure('Raptor Pen', 10);
    expect(enclosure.dinosaurs).toEqual([]);
    expect(enclosure.dinosaurs.length).toBe(0);
  });
});

Gdy asercja zawiedzie, Jest przerywa tylko ten jeden test, pokazuje wartość oczekiwaną (Expected) i otrzymaną (Received), po czym przechodzi do następnego. Dlaczego dla pustej tablicy użyliśmy toEqual, a nie toBe, wyjaśnię w lekcji o matcherach.

Kompletny przykład

Zobaczmy pełny przykład testowania modułu zarządzania dinozaurami. Najpierw kod produkcyjny: createDinosaur tworzy okaz z pełnym zdrowiem, a feedDinosaur podnosi zdrowie tylko wtedy, gdy pokarm pasuje do diety, i nigdy powyżej 100:

// dinosaur.js - kod produkcyjny
function createDinosaur(name, species, diet) {
  return {
    name,
    species,
    diet,
    health: 100,
    isAlive: true,
  };
}

function feedDinosaur(dinosaur, food) {
  if (dinosaur.diet === 'carnivore' && food === 'meat') {
    dinosaur.health = Math.min(100, dinosaur.health + 20);
    return { success: true, message: 'Dinozaur najedzony!' };
  }
  if (dinosaur.diet === 'herbivore' && food === 'plants') {
    dinosaur.health = Math.min(100, dinosaur.health + 15);
    return { success: true, message: 'Dinozaur najedzony!' };
  }
  return { success: false, message: 'Niewłaściwe jedzenie!' };
}

Teraz plik z testami. Dwa zagnieżdżone describe odpowiadają dwóm funkcjom, a każdy it sprawdza jeden scenariusz:

// dinosaur.test.js - testy
describe('Dinosaur Management', () => {
  describe('createDinosaur', () => {
    it('should create a dinosaur with correct properties', () => {
      const rex = createDinosaur('Rex', 'T-Rex', 'carnivore');

      expect(rex.name).toBe('Rex');
      expect(rex.species).toBe('T-Rex');
      expect(rex.diet).toBe('carnivore');
      expect(rex.health).toBe(100);
      expect(rex.isAlive).toBe(true);
    });
  });

  describe('feedDinosaur', () => {
    it('should feed carnivore with meat', () => {
      const rex = createDinosaur('Rex', 'T-Rex', 'carnivore');
      rex.health = 70;

      const result = feedDinosaur(rex, 'meat');

      expect(result.success).toBe(true);
      expect(rex.health).toBe(90);
    });

    it('should reject wrong food for carnivore', () => {
      const rex = createDinosaur('Rex', 'T-Rex', 'carnivore');

      const result = feedDinosaur(rex, 'plants');

      expect(result.success).toBe(false);
    });
  });
});

W prawdziwym projekcie plik testów importuje funkcje, np. przez require('./dinosaur'), a dinosaur.js musi je wyeksportować. Zauważ też lukę: test odrzuconego pokarmu nie sprawdza, czy zdrowie Rexa zostało nietknięte. To dobry kandydat na Twój pierwszy samodzielny test.

Uruchamianie testów

Testy uruchamiasz z terminala. Oto cztery warianty, których będziesz używać najczęściej:

# Uruchom wszystkie testy
npx jest

# Uruchom konkretny plik
npx jest dinosaur.test.js

# Uruchom w trybie watch (reaguje na zmiany)
npx jest --watch

# Uruchom z raportowaniem pokrycia kodu
npx jest --coverage

Tryb --watch po każdym zapisie uruchamia ponownie tylko testy związane ze zmienionymi plikami (zmiany wykrywa przez Gita), a --coverage tworzy raport pokrycia: pokazuje, które linie kodu wykonał choć jeden test, a których nie odwiedził żaden.

Wzorzec AAA (Arrange-Act-Assert)

Każdy dobry test powinien być napisany według wzorca AAA: Arrange (przygotuj), Act (wykonaj), Assert (sprawdź). Trzy części oddzielone pustą linią sprawiają, że test czyta się jak raport z inspekcji:

it('should increase health when fed correctly', () => {
  // Arrange (Przygotowanie) - stwórz potrzebne obiekty
  const dino = createDinosaur('Brachio', 'Brachiosaurus', 'herbivore');
  dino.health = 60;

  // Act (Akcja) - wykonaj testowaną operację
  const result = feedDinosaur(dino, 'plants');

  // Assert (Sprawdzenie) - zweryfikuj wynik
  expect(result.success).toBe(true);
  expect(dino.health).toBe(75);
});

Kod produkcyjny się nie zmienił - zmienił się tylko porządek testu, dzięki któremu od razu widać, co jest przygotowaniem, a co właściwym sprawdzeniem. Moja rada: jedna akcja w sekcji Act. Jeśli wywołujesz tam trzy różne funkcje, prawdopodobnie piszesz trzy testy naraz.

W następnej lekcji poznasz cały arsenał matcherów. W laboratorium poniżej działa uproszczona symulacja describe, it i expect napisana w czystym JavaScripcie, bo Sandpack nie uruchamia prawdziwego Jesta.

Pamiętaj: describe to wybieg, it to pojedyncza inspekcja, a expect to czujnik, który melduje PASS albo FAIL.

Kod do tej lekcji: index.js
// Jest - Podstawy frameworka testowego
console.log("=== Park Jurajski - System Testowania Jest ===\n");

// Symulacja frameworka Jest (Sandpack nie uruchamia prawdziwego Jest)
// Pokaz struktury: describe, it/test, expect

// --- Mini implementacja Jest ---
const results = { passed: 0, failed: 0, suites: [] };

function describe(name, fn) {
  const suite = { name, tests: [] };
  results.suites.push(suite);
  const prevSuite = results.currentSuite;
  results.currentSuite = suite;
  fn();
  results.currentSuite = prevSuite;
}

function it(name, fn) {
  try {
    fn();
    results.currentSuite.tests.push({ name, status: "PASS" });
    results.passed++;
  } catch (e) {
    results.currentSuite.tests.push({ name, status: "FAIL", error: e.message });
    results.failed++;
  }
}
const test = it; // test i it sa zamienne

function expect(actual) {
  return {
    toBe(expected) {
      if (actual !== expected)
        throw new Error(`Expected ${expected}, got ${actual}`);
    },
    toEqual(expected) {
      if (JSON.stringify(actual) !== JSON.stringify(expected))
        throw new Error(`Expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
    },
    toHaveLength(expected) {
      if (actual.length !== expected)
        throw new Error(`Expected length ${expected}, got ${actual.length}`);
    },
    toBeTruthy() {
      if (!actual) throw new Error(`Expected truthy, got ${actual}`);
    },
    not: {
      toBe(expected) {
        if (actual === expected) throw new Error(`Expected not ${expected}`);
      }
    }
  };
}

// --- Kod produkcyjny ---
function createDinosaur(name, species, diet) {
  return { name, species, diet, health: 100, isAlive: true };
}

function feedDinosaur(dinosaur, food) {
  if (dinosaur.diet === "carnivore" && food === "meat") {
    dinosaur.health = Math.min(100, dinosaur.health + 20);
    return { success: true, message: "Dinozaur najedzony!" };
  }
  if (dinosaur.diet === "herbivore" && food === "plants") {
    dinosaur.health = Math.min(100, dinosaur.health + 15);
    return { success: true, message: "Dinozaur najedzony!" };
  }
  return { success: false, message: "Niewlasciwe jedzenie!" };
}

// --- Testy ---
describe("Dinosaur Management", () => {
  describe("createDinosaur", () => {
    it("should create a dinosaur with correct properties", () => {
      const rex = createDinosaur("Rex", "T-Rex", "carnivore");
      expect(rex.name).toBe("Rex");
      expect(rex.species).toBe("T-Rex");
      expect(rex.diet).toBe("carnivore");
      expect(rex.health).toBe(100);
      expect(rex.isAlive).toBe(true);
    });

    it("should create herbivore dinosaur", () => {
      const brachio = createDinosaur("Brachio", "Brachiosaurus", "herbivore");
      expect(brachio.diet).toBe("herbivore");
      expect(brachio.health).toBe(100);
    });
  });

  describe("feedDinosaur", () => {
    it("should feed carnivore with meat (AAA pattern)", () => {
      // Arrange
      const rex = createDinosaur("Rex", "T-Rex", "carnivore");
      rex.health = 70;

      // Act
      const result = feedDinosaur(rex, "meat");

      // Assert
      expect(result.success).toBe(true);
      expect(rex.health).toBe(90);
    });

    it("should reject wrong food for carnivore", () => {
      const rex = createDinosaur("Rex", "T-Rex", "carnivore");
      const result = feedDinosaur(rex, "plants");
      expect(result.success).toBe(false);
    });

    it("should feed herbivore with plants", () => {
      const brachio = createDinosaur("Brachio", "Brachiosaurus", "herbivore");
      brachio.health = 50;
      const result = feedDinosaur(brachio, "plants");
      expect(result.success).toBe(true);
      expect(brachio.health).toBe(65);
    });
  });
});

// --- Wyswietl wyniki ---
console.log("Test Results:\n");
results.suites.forEach(suite => {
  console.log(`  ${suite.name}`);
  suite.tests.forEach(t => {
    const icon = t.status === "PASS" ? "PASS" : "FAIL";
    console.log(`    [${icon}] ${t.name}`);
    if (t.error) console.log(`           ${t.error}`);
  });
});
console.log(`\nTotal: ${results.passed} passed, ${results.failed} failed`);

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 oznacza wzorzec AAA stosowany w testach jednostkowych?

  2. 2. Jaki jest cel funkcji expect() w Jest?

Zadania praktyczne w grze

  • Edytor kodu

    Uzupełnij brakujące asercje w testach dla funkcji getDinosaurSpecies.

  • Klikanie w kolejności

    Ułóż elementy podstawowego testu Jest:

  • Edytor kodu

    Napisz testy dla systemu punktów życia dinozaura używając describe, it, expect.

  1. PytanieWzorzec AAA w testach
  2. Zadanie z kodemPierwszy test w Jest
  3. PytanieFunkcja expect w Jest
  4. Kliknij w kolejnościSkładnia bloku testowego
  5. Zadanie z kodemStruktura describe/it/expect

Przydatne artykuły