Kurs JavaScript i TypeScript · Moduł 11: Testowanie z Jest
Dlaczego testowanie jest ważne?
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:
- Wykrywanie błędów wcześnie - im wcześniej znajdziesz błąd, tym taniej go naprawisz
- Dokumentacja zachowania - testy opisują, jak kod powinien działać
- Bezpieczne refaktorowanie - możesz zmieniać kod wiedząc, że testy wychwycą regresje
- 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. Która warstwa piramidy testów zawiera najwięcej testów?