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

Dlaczego testowanie jest ważne?

5 min czytania ·
W tej lekcji4

Wyobraź sobie Park Jurajski bez systemu weryfikacji DNA dinozaurów. Każdy nowo sklonowany gatunek mógłby mieć ukryte defekty genetyczne, które ujawniłyby się dopiero wtedy, gdy tyranozaur wyrwie się z wybiegu. W świecie programowania testowanie pełni dokładnie tę samą rolę - to system wczesnego ostrzegania, który wyłapuje błędy zanim trafią do użytkowników.

"Każdą próbkę sprawdzamy, zanim cokolwiek wykluje się z jaja" - powtarza Dr. Rex, szef laboratorium. W tym module zbudujesz taki system kontroli dla kodu: zestaw testów, które same pilnują, czy funkcje parku robią to, co obiecują.

Czego się nauczysz

  • pisać testy w Jest i czytać raport PASS/FAIL
  • dobierać matchery jak czujniki do konkretnego zagrożenia
  • przygotowywać i sprzątać wybieg przed każdym testem
  • podmieniać groźne zależności na bezpieczne mocki
  • testować kod asynchroniczny i przewijać czas sztucznym zegarem
  • pisać testy przed kodem metodą TDD i testować TypeScript

Testowanie manualne vs automatyczne

Testowanie manualne

Testowanie manualne to jak osobiste sprawdzanie każdego dinozaura w parku - czasochłonne, podatne na ludzkie błędy i niemożliwe do powtórzenia w identyczny sposób. Zobacz to na przykładzie funkcji calculateDinosaurAge, która liczy wiek okazu na podstawie roku wyklucia. Sprawdzamy ją "na oko", wypisując wyniki w konsoli:

// Testowanie manualne - musisz sam sprawdzić wynik
function calculateDinosaurAge(birthYear) {
  return 2024 - birthYear;
}

// Ręczne sprawdzenie w konsoli:
console.log(calculateDinosaurAge(2020)); // Czy to 4? Muszę sam sprawdzić...
console.log(calculateDinosaurAge(2015)); // A to 9? Znowu sam sprawdzam...

Kod działa, ale cała weryfikacja odbywa się w Twojej głowie: musisz pamiętać, że 2024 minus 2020 to 4. Nic nie zostaje zapisane, więc po każdej zmianie funkcji inspekcję trzeba powtarzać od zera.

Testowanie automatyczne

Testowanie automatyczne to jak zainstalowanie sensorów w każdym wybiegu - działają 24/7, natychmiast alertują o problemach i zawsze sprawdzają te same warunki. W kodzie funkcja test nadaje sprawdzeniu nazwę, expect przyjmuje rzeczywisty wynik, a toBe porównuje go z wartością oczekiwaną - szczegóły poznasz w następnej lekcji.

// Testowanie automatyczne - komputer sprawdza za Ciebie
function calculateDinosaurAge(birthYear) {
  return 2024 - birthYear;
}

// Test automatyczny:
test('oblicza wiek dinozaura', () => {
  expect(calculateDinosaurAge(2020)).toBe(4);
  expect(calculateDinosaurAge(2015)).toBe(9);
  expect(calculateDinosaurAge(2024)).toBe(0);
});
// Wynik: PASS lub FAIL - natychmiast wiesz!

Oczekiwania są teraz zapisane w kodzie, więc sprawdzenie trwa milisekundy i za każdym razem daje tę samą odpowiedź. Sama funkcja się nie zmieniła - zmieniło się tylko to, kto pilnuje wyniku. Uważaj jednak na pułapkę: rok 2024 jest wpisany na sztywno i w funkcji, i w oczekiwaniach, więc testy przejdą także w 2030 roku, kiedy funkcja będzie już zaniżać wiek. Test sprawdza wyłącznie to, o co go zapytasz.

Rodzaje testów

Piramida testów

W świecie testowania istnieje koncepcja piramidy testów. Na jej dole znajdują się testy jednostkowe (unit tests), w środku testy integracyjne (integration tests), a na szczycie testy end-to-end (E2E). Model spopularyzował Mike Cohn w książce Succeeding with Agile. W przykładzie poniżej getSpecies zamienia skrót na pełną nazwę gatunku, getDinosaur i feedDinosaur to dwa współpracujące moduły parku, a page to przeglądarka sterowana przez narzędzie do testów E2E - metody goto, click i fill pochodzą z Playwrighta.

// 1. Testy jednostkowe (Unit Tests) - testują pojedynczą funkcję
// Najszybsze, najtańsze, najwięcej ich potrzebujemy
test('sprawdza gatunek dinozaura', () => {
  expect(getSpecies('T-Rex')).toBe('Tyrannosaurus Rex');
});

// 2. Testy integracyjne (Integration Tests) - testują współpracę modułów
// Sprawdzają, czy moduły poprawnie ze sobą komunikują
test('system karmienia współpracuje z bazą dinozaurów', () => {
  const dino = getDinosaur('Rex-001');
  const result = feedDinosaur(dino, 'meat');
  expect(result.status).toBe('fed');
  expect(dino.hunger).toBe(0);
});

// 3. Testy E2E (End-to-End) - testują całą aplikację
// Najwolniejsze, najdroższe, najmniej ich potrzebujemy
test('użytkownik może zarezerwować wizytę w parku', async () => {
  await page.goto('/booking');
  await page.click('#select-date');
  await page.fill('#name', 'John Hammond');
  await page.click('#submit');
  expect(await page.textContent('.confirmation')).toContain('Rezerwacja potwierdzona');
});

Wszystkie trzy testy kończą się asercją, ale różnią się zasięgiem. Test jednostkowy nie dotyka bazy ani sieci, więc trwa ułamek milisekundy i od razu wskazuje winną funkcję. Test E2E uruchamia przeglądarkę i całą aplikację - jest najbliżej prawdziwego zwiedzającego, ale gdy zawiedzie, wiesz tylko, że problem leży gdzieś na trasie od kasy do rezerwacji.

Fundament i szczyt piramidy

Pod piramidą często dorysowuje się fundament: analizę statyczną. Linter (np. ESLint) i system typów TypeScriptu sprawdzają kod, zanim uruchomisz jakikolwiek test, i wyłapią literówkę albo tekst podany zamiast liczby. Na szczycie, ponad testami E2E, zostaje odrobina testów manualnych, tak zwanych eksploracyjnych: człowiek szuka dziwnych zachowań, których nikt nie przewidział. Pełna kolejność od podstawy brzmi więc: analiza statyczna, testy jednostkowe, integracyjne, E2E i eksploracyjne. Z trzech klasycznych pięter najliczniejsze są testy jednostkowe.

Proporcje testów

Ile testów każdego rodzaju? Google Testing Blog w 2015 roku zaproponował jako dobry punkt wyjścia taki podział:

  • 70% testów jednostkowych - szybkie, precyzyjne, łatwe do napisania
  • 20% testów integracyjnych - sprawdzają współpracę między modułami
  • 10% testów E2E - symulują prawdziwego użytkownika

To heurystyka, a nie prawo natury - autorzy sami zaznaczają, że każdy zespół dobierze własne liczby, byle zachować kształt piramidy. Odwrócona piramida, pełna powolnych testów E2E i ręcznego klikania, to znany antywzorzec nazywany rożkiem lodów (ice cream cone).

Korzyści z testowania

Testowanie to nie strata czasu - to inwestycja. Oto główne korzyści:

  1. Wykrywanie błędów wcześnie - im wcześniej znajdziesz błąd, tym taniej go naprawisz
  2. Dokumentacja zachowania - testy opisują, jak kod powinien działać
  3. Bezpieczne refaktorowanie - możesz zmieniać kod wiedząc, że testy wychwycą regresje
  4. Pewność przy wdrożeniach - zielone testy oznaczają gotowość do produkcji

Moja rada: zaczynaj od testów jednostkowych dla małych, czystych funkcji, takich jak calculateDinosaurAge. Są najtańsze w pisaniu i najszybciej odwdzięczają się złapanymi błędami. Już w następnej lekcji poznasz Jest, czyli narzędzie, które uruchamia takie testy.

W laboratorium poniżej działa miniaturowy runner testów napisany w czystym JavaScripcie. Zwróć uwagę na ostatni test z dopiskiem "bug": przechodzi, choć pilnuje ujemnego wieku. Zielony test jest tylko tak mądry, jak oczekiwanie, które w nim zapisałeś.

Pamiętaj: test to czujnik na wybiegu - raz zamontowany, pilnuje dinozaura przy każdej zmianie kodu, dzień i noc.

Kod do tej lekcji: index.js
// Testowanie JS/TS - Dlaczego testowanie jest ważne?
console.log("=== Park Jurajski - System Weryfikacji DNA ===\n");

// Testowanie manualne vs automatyczne

// PRZYKŁAD 1: Testowanie manualne (problematyczne)
function calculateDinosaurAge(birthYear) {
  return 2024 - birthYear;
}

console.log("--- Testowanie manualne ---");
console.log("Wiek (2020):", calculateDinosaurAge(2020));  // Sam sprawdzam: czy to 4?
console.log("Wiek (2015):", calculateDinosaurAge(2015));  // Sam sprawdzam: czy to 9?
console.log("Wiek (2024):", calculateDinosaurAge(2024));  // Sam sprawdzam: czy to 0?

// PRZYKŁAD 2: Testowanie automatyczne (niezawodne)
function autoTest(description, actual, expected) {
  const passed = actual === expected;
  const icon = passed ? "PASS" : "FAIL";
  console.log(`[${icon}] ${description}: got ${actual}, expected ${expected}`);
  return passed;
}

console.log("\n--- Testowanie automatyczne ---");
autoTest("Wiek dinozaura z 2020", calculateDinosaurAge(2020), 4);
autoTest("Wiek dinozaura z 2015", calculateDinosaurAge(2015), 9);
autoTest("Wiek dinozaura z 2024", calculateDinosaurAge(2024), 0);

// PRZYKŁAD 3: Piramida testów
console.log("\n--- Piramida testów ---");
console.log("Baza:    Unit Tests     (70%) - szybkie, precyzyjne");
console.log("Srodek:  Integration    (20%) - wspolpraca modulow");
console.log("Szczyt:  E2E Tests      (10%) - cala aplikacja");

// Symulacja prostego test runnera
console.log("\n--- Mini Test Runner ---");

function runTests(suiteName, tests) {
  console.log(`\nSuite: ${suiteName}`);
  let passed = 0;
  let failed = 0;

  tests.forEach(({ name, fn }) => {
    try {
      fn();
      console.log(`  [PASS] ${name}`);
      passed++;
    } catch (e) {
      console.log(`  [FAIL] ${name}: ${e.message}`);
      failed++;
    }
  });

  console.log(`  Results: ${passed} passed, ${failed} failed`);
}

function assertEqual(actual, expected) {
  if (actual !== expected) {
    throw new Error(`Expected ${expected}, got ${actual}`);
  }
}

runTests("DinosaurAge", [
  {
    name: "calculates age correctly",
    fn: () => assertEqual(calculateDinosaurAge(2020), 4)
  },
  {
    name: "handles current year",
    fn: () => assertEqual(calculateDinosaurAge(2024), 0)
  },
  {
    name: "handles negative age (bug!)",
    fn: () => assertEqual(calculateDinosaurAge(2025), -1)
  }
]);

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. Która warstwa piramidy testów zawiera najwięcej testów?

  1. PytaniePiramida testów - warstwa podstawowa

Przydatne artykuły