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

Test-Driven Development (TDD)

6 min czytania ·
W tej lekcji4

Zwykle najpierw piszesz kod, a potem, jeśli starczy czasu, testy. Tyle że czasu rzadko starcza, a testy pisane po fakcie mają skłonność do potwierdzania tego, co kod już robi, łącznie z jego błędami. TDD odwraca tę kolejność.

TDD to metodologia tworzenia oprogramowania, w której najpierw piszesz testy, a dopiero potem kod produkcyjny. W Parku Jurajskim to jak najpierw zaprojektowanie wszystkich systemów bezpieczeństwa, a dopiero potem sprowadzenie dinozaurów. Metodę spopularyzował Kent Beck, autor książki Test-Driven Development: By Example.

Cykl Red-Green-Refactor

TDD opiera się na trzech powtarzających się krokach. Kolory pochodzą z raportu testów: czerwony oznacza alarm, a zielony, że wszystko działa.

1. RED - Napisz test, który nie przechodzi

Zaczynamy od testu dla funkcji, która jeszcze nie istnieje. Opisujemy w nim, jak chcemy jej używać: createFence ma przyjąć strefę i napięcie, a zwrócić aktywne ogrodzenie:

// KROK 1: Piszemy test PRZED kodem produkcyjnym
describe('FenceSystem', () => {
  it('should create a fence with voltage', () => {
    const fence = createFence('Zone A', 10000);

    expect(fence.zone).toBe('Zone A');
    expect(fence.voltage).toBe(10000);
    expect(fence.isActive).toBe(true);
  });
});
// Wynik: RED - createFence nie istnieje!

Test pada z błędem ReferenceError, bo createFence nie istnieje, i to jest w porządku: porażka z powodu brakującej funkcji też liczy się jako czerwony stan. Ważne, by zobaczyć czerwień na własne oczy. Test, który nigdy nie był czerwony, może nie sprawdzać niczego.

2. GREEN - Napisz minimum kodu, żeby test przeszedł

Teraz piszemy najprostszy kod, który zadowoli test, bez żadnego zapasu na przyszłość ani funkcji "na wszelki wypadek":

// KROK 2: Piszemy najprostszy kod, który przejdzie test
function createFence(zone, voltage) {
  return {
    zone,
    voltage,
    isActive: true
  };
}
// Wynik: GREEN - test przechodzi!

Implementacja jest wręcz naiwna, ale test przechodzi. Na tym etapie nie liczy się elegancja, tylko zielone światło.

3. REFACTOR - Popraw kod zachowując zielone testy

Mając zielony test jako siatkę bezpieczeństwa, możemy przebudować kod. Zamieniamy literał obiektu na klasę Fence, a createFence staje się cienką fabryką:

// KROK 3: Ulepszamy kod (testy nadal zielone!)
class Fence {
  constructor(zone, voltage) {
    this.zone = zone;
    this.voltage = voltage;
    this.isActive = true;
  }

  getStatus() {
    return this.isActive ? 'ACTIVE' : 'OFFLINE';
  }
}

function createFence(zone, voltage) {
  return new Fence(zone, voltage);
}
// Wynik: GREEN - testy nadal przechodzą po refaktorze!

Test nie zmienił się ani o znak i nadal przechodzi, bo refaktor zmienia strukturę kodu, a nie jego zachowanie. Uczciwie przyznam jednak, że metoda getStatus przemknęła tu bez testu. W czystym TDD refaktor nie dodaje nowych funkcji: na getStatus powinien najpierw przyjść osobny czerwony test.

Praktyczny przykład TDD

Zbudujmy system karmienia dinozaurów krok po kroku. Każda iteracja dokłada jeden test i tylko tyle kodu, ile ten test wymusza.

Iteracja 1: Podstawowe karmienie

Pierwszy test opisuje najprostszy przypadek: T-Rex dostaje mięso i karmienie się udaje. DinoFeeder to klasa, której metoda feed przyjmuje gatunek i pokarm:

// RED: Piszemy test
test('carnivore eats meat', () => {
  const feeder = new DinoFeeder();
  const result = feeder.feed('T-Rex', 'meat');
  expect(result.success).toBe(true);
});

Teraz najprostsza implementacja, która zamienia czerwień w zieleń. Metoda feed na razie w ogóle nie patrzy na argumenty:

// GREEN: Minimalna implementacja
class DinoFeeder {
  feed(species, food) {
    return { success: true };
  }
}
// Test przechodzi - ale implementacja jest zbyt prosta!

Zwracanie zawsze success: true wygląda jak oszustwo, ale to celowe minimum. Kolejne testy zmuszą implementację, żeby zmądrzała, i właśnie o to chodzi w TDD.

Iteracja 2: Walidacja diety

Drugi test zamyka lukę: mięsożerca nie może przyjąć roślin, a wynik ma podać powód odmowy:

// RED: Dodajemy test dla niepoprawnego jedzenia
test('carnivore rejects plants', () => {
  const feeder = new DinoFeeder();
  const result = feeder.feed('T-Rex', 'plants');
  expect(result.success).toBe(false);
  expect(result.reason).toBe('Wrong diet');
});

Żeby go spełnić, klasa potrzebuje mapy diet dla gatunków. Konstruktor zapisuje ją w this.diets, a feed sprawdza, czy pokarm pasuje do diety:

// GREEN: Rozszerzamy implementację
class DinoFeeder {
  constructor() {
    this.diets = {
      'T-Rex': 'carnivore',
      'Triceratops': 'herbivore',
      'Velociraptor': 'carnivore',
    };
  }

  feed(species, food) {
    const diet = this.diets[species];

    if (diet === 'carnivore' && food !== 'meat') {
      return { success: false, reason: 'Wrong diet' };
    }
    if (diet === 'herbivore' && food !== 'plants') {
      return { success: false, reason: 'Wrong diet' };
    }

    return { success: true };
  }
}

Oba testy są teraz zielone. Pierwszy nadal chroni pierwszy scenariusz: gdyby nowa walidacja zepsuła karmienie mięsem, od razu byśmy się o tym dowiedzieli.

Iteracja 3: Nieznany gatunek

Trzeci test sprawdza wyjątek, więc wywołanie opakowujemy w funkcję strzałkową, tak jak przy matcherze toThrow:

// RED: Test dla nieznanego gatunku
test('unknown species throws error', () => {
  const feeder = new DinoFeeder();
  expect(() => feeder.feed('Unknown', 'meat')).toThrow('Unknown species');
});

Implementacja dopisuje jeden warunek na początku feed. Komentarz "poprzedni kod" oznacza konstruktor z mapą diet z iteracji 2, który się nie zmienia:

// GREEN: Dodajemy obsługę błędów
class DinoFeeder {
  // ... poprzedni kod ...

  feed(species, food) {
    const diet = this.diets[species];

    if (!diet) {
      throw new Error('Unknown species');
    }

    if (diet === 'carnivore' && food !== 'meat') {
      return { success: false, reason: 'Wrong diet' };
    }
    if (diet === 'herbivore' && food !== 'plants') {
      return { success: false, reason: 'Wrong diet' };
    }

    return { success: true };
  }
}

Po trzech iteracjach dwa bliźniacze warunki dla carnivore i herbivore aż proszą się o refaktor, na przykład o mapę "dieta - dozwolony pokarm". Trzy zielone testy dają odwagę, by go przeprowadzić.

Zasady TDD

Cykl opiera się na kilku zasadach. Trzy pierwsze to w skrócie tak zwane trzy prawa TDD sformułowane przez Roberta C. Martina:

  1. Nie pisz kodu produkcyjnego bez czerwonego testu - zawsze najpierw test
  2. Napisz minimum testu - tyle, ile potrzeba do pokazania błędu
  3. Napisz minimum kodu - tyle, ile potrzeba do przejścia testu
  4. Refaktoruj często - ulepszaj kod przy zielonych testach
  5. Małe kroki - każda iteracja dodaje jedną małą funkcjonalność

Korzyści TDD

Co zyskujesz, pracując w tym rytmie? Zebraliśmy to w obiekcie, jak przystało na laboratorium parku:

// TDD prowadzi do:
const tddBenefits = {
  betterDesign: 'Kod jest projektowany pod testy = lepszy design',
  lessDebugging: 'Błędy wyłapywane natychmiast',
  documentation: 'Testy dokumentują zachowanie kodu',
  confidence: 'Pewność przy zmianach i refaktorze',
  coverage: 'Bardzo wysokie pokrycie kodu testami (ale nie gwarancja 100%)'
};

Uwaga na ostatnią pozycję: TDD zwykle daje bardzo wysokie pokrycie, bo każda linijka powstaje w odpowiedzi na test, ale nie gwarantuje 100%, a samo pokrycie nie świadczy jeszcze o jakości testów. Moja rada: stosuj TDD tam, gdzie wiesz, jaki ma być wynik, czyli w logice biznesowej, walidacji i obliczeniach. Przy szybkich prototypach sztywny cykl potrafi spowalniać.

W ćwiczeniach po tej lekcji zbudujesz metodą TDD system biletów i harmonogram karmienia, a w następnej lekcji przeniesiesz te nawyki do TypeScriptu. W laboratorium poniżej prześledzisz symulację kolejnych iteracji.

Pamiętaj: w TDD najpierw budujesz ogrodzenie, a dopiero potem wpuszczasz dinozaura - czerwony test to projekt, zielony to gotowy wybieg.

Kod do tej lekcji: index.js
// TDD - Test-Driven Development
console.log("=== Park Jurajski - Protokoly Bezpieczenstwa TDD ===\n");

// Symulacja TDD
let testsPassed = 0, testsFailed = 0;

function assert(condition, msg) {
  if (condition) {
    console.log("  [PASS] " + msg);
    testsPassed++;
  } else {
    console.log("  [FAIL] " + msg);
    testsFailed++;
  }
}

function assertThrows(fn, expectedMsg) {
  try {
    fn();
    console.log("  [FAIL] Expected throw: " + expectedMsg);
    testsFailed++;
  } catch (e) {
    if (e.message === expectedMsg) {
      console.log("  [PASS] Threw: " + e.message);
      testsPassed++;
    } else {
      console.log("  [FAIL] Wrong error: " + e.message + " (expected: " + expectedMsg + ")");
      testsFailed++;
    }
  }
}

// --- Cykl Red-Green-Refactor ---
console.log("--- Cykl TDD: Red -> Green -> Refactor ---\n");
console.log("1. RED    - Napisz test ktory FAILUJE");
console.log("2. GREEN  - Napisz minimum kodu zeby PRZESZEDL");
console.log("3. REFACTOR - Ulepsz kod (testy nadal zielone)\n");

// --- Iteracja 1: Tworzenie ogrodzenia ---
console.log("=== Iteracja 1: Tworzenie ogrodzenia ===\n");

// RED -> GREEN
function createFence(zone, voltage) {
  return {
    zone,
    voltage,
    isActive: true,
    getStatus() { return this.isActive ? "ACTIVE" : "OFFLINE"; }
  };
}

assert(createFence("Zone A", 10000).zone === "Zone A", "fence has zone");
assert(createFence("Zone A", 10000).voltage === 10000, "fence has voltage");
assert(createFence("Zone A", 10000).isActive === true, "fence is active");

// --- Iteracja 2: DinoFeeder ---
console.log("\n=== Iteracja 2: System Karmienia (TDD) ===\n");

class DinoFeeder {
  constructor() {
    this.diets = {
      "T-Rex": "carnivore",
      "Triceratops": "herbivore",
      "Velociraptor": "carnivore",
      "Gallimimus": "omnivore",
    };
    this.feedLog = [];
  }

  feed(species, food) {
    const diet = this.diets[species];

    if (!diet) {
      throw new Error("Unknown species");
    }

    if (diet === "carnivore" && food !== "meat") {
      return { success: false, reason: "Wrong diet" };
    }
    if (diet === "herbivore" && food !== "plants") {
      return { success: false, reason: "Wrong diet" };
    }

    this.feedLog.push({ species, food, time: Date.now() });
    return { success: true };
  }

  getFeedCount() {
    return this.feedLog.length;
  }
}

// Test 1: Karnienie miesozercow
console.log("Test: Karmienie miesozercow");
const feeder = new DinoFeeder();
const result1 = feeder.feed("T-Rex", "meat");
assert(result1.success === true, "T-Rex eats meat");

// Test 2: Odrzucenie zlego jedzenia
console.log("\nTest: Odrzucenie zlego jedzenia");
const result2 = feeder.feed("T-Rex", "plants");
assert(result2.success === false, "T-Rex rejects plants");
assert(result2.reason === "Wrong diet", "reason is Wrong diet");

// Test 3: Roslinozerce
console.log("\nTest: Karmienie roslinozercow");
const result3 = feeder.feed("Triceratops", "plants");
assert(result3.success === true, "Triceratops eats plants");

// Test 4: Nieznany gatunek
console.log("\nTest: Nieznany gatunek");
assertThrows(() => feeder.feed("Unknown", "meat"), "Unknown species");

// Test 5: Licznik karmienia
console.log("\nTest: Licznik karmienia");
assert(feeder.getFeedCount() === 2, "2 successful feedings logged");

// --- Podsumowanie TDD ---
console.log("\n=== Zasady TDD ===");
console.log("1. NIE pisz kodu bez czerwonego testu");
console.log("2. Pisz minimum testu (jeden assert)");
console.log("3. Pisz minimum kodu (zeby przeszlo)");
console.log("4. Refaktoruj czesto");
console.log("5. Male kroki - jedna funkcjonalnosc na iteracje");

console.log(`\n=== Wyniki: ${testsPassed} passed, ${testsFailed} 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. Jaka jest prawidłowa kolejność kroków w cyklu TDD?

Zadania praktyczne w grze

  • Układanie w pionie

    Ułóż kroki jednej iteracji TDD w prawidłowej kolejności:

  • Edytor kodu

    Napisz testy dla systemu biletów parku, a następnie implementację spełniającą testy.

  • Klikanie w kolejności

    Ułóż elementy jednej iteracji TDD:

  • Układanie w poziomie

    Ułóż elementy testu sprawdzającego wyjątek:

  • Edytor kodu

    Zbuduj FeedingScheduler iteracyjnie: test -> kod -> refaktor.

  1. PytanieCykl TDD
  2. Ułóż w kolejnościKroki cyklu Red-Green-Refactor
  3. Zadanie z kodemTDD - pisanie testów przed kodem
  4. Kliknij w kolejnościIteracja TDD - składnia
  5. Ułóż w kolejnościSkładnia testu z wyjątkiem
  6. Zadanie z kodemTDD iteracyjny

Przydatne artykuły