Kurs JavaScript i TypeScript · Moduł 10: TypeScript w praktyce

Test-Driven Development (TDD) - Ewolucja kodu przez testy

8 min czytania ·
W tej lekcji6

Witaj w świecie Test-Driven Development! Wyobraź sobie, że zmieniasz jedną linijkę w systemie ogrodzeń i nie wiesz, czy przy okazji nie wyłączyłeś alarmu na wybiegu Velociraptorów. Podobnie jak naukowcy w Parku Jurajskim musieli najpierw zrozumieć DNA dinozaurów, zanim mogli je sklonować, TDD wymaga najpierw zdefiniowania oczekiwanego zachowania (testu), a dopiero potem napisania implementacji.

Czym jest TDD?

Test-Driven Development to technika programowania, w której najpierw piszemy test, który początkowo nie przechodzi, następnie minimalny kod potrzebny do jego zaliczenia, a na końcu refaktoryzujemy kod, zachowując przechodzące testy. Technikę spopularyzował Kent Beck na przełomie XX i XXI wieku.

Cykl Red-Green-Refactor

Ten rytm powtarza się w kółko, a każdy obrót powinien być krótki, najlepiej kilkuminutowy:

    ┌──────────────────────────────────────┐
    │                                      │
    │   RED                             │
    │   Napisz test, który nie przechodzi  │
    │                                      │
    └───────────────┬──────────────────────┘
                    │
                    ▼
    ┌──────────────────────────────────────┐
    │                                      │
    │   GREEN                           │
    │   Napisz minimalny kod do           │
    │   zaliczenia testu                   │
    │                                      │
    └───────────────┬──────────────────────┘
                    │
                    ▼
    ┌──────────────────────────────────────┐
    │                                      │
    │   REFACTOR                        │
    │   Ulepsz kod zachowując             │
    │   przechodzące testy                 │
    │                                      │
    └───────────────┬──────────────────────┘
                    │
                    └──────────► Powtórz cykl

Czerwony test udowadnia, że test w ogóle potrafi coś wykryć. Zielony oznacza spełnione wymaganie, a refaktoryzacja poprawia kod bez zmiany zachowania.

TDD w praktyce - przykład z Parku Jurajskiego

Wyobraź sobie, że budujesz system monitorowania dinozaurów. Zaczynamy od testu.

Krok 1: RED - Piszemy test

Test w Vitest opisuje zachowanie w blokach describe i it, a komentarze pokazują wzorzec AAA: Arrange (przygotuj), Act (wykonaj), Assert (sprawdź):

// dinosaur.test.js
import { describe, it, expect } from 'vitest';
import { Dinosaur } from './dinosaur';

describe('Dinosaur', () => {
  describe('constructor', () => {
    it('should create a dinosaur with name and species', () => {
      // Arrange & Act
      const dino = new Dinosaur('Rex', 'Tyrannosaurus');

      // Assert
      expect(dino.name).toBe('Rex');
      expect(dino.species).toBe('Tyrannosaurus');
    });
  });

  describe('isDangerous', () => {
    it('should return true for carnivore dinosaurs', () => {
      const dino = new Dinosaur('Rex', 'Tyrannosaurus', 'carnivore');
      expect(dino.isDangerous()).toBe(true);
    });

    it('should return false for herbivore dinosaurs', () => {
      const dino = new Dinosaur('Steggy', 'Stegosaurus', 'herbivore');
      expect(dino.isDangerous()).toBe(false);
    });
  });
});

Ten test teraz nie przechodzi i to dobrze, bo nie mamy jeszcze klasy Dinosaur, więc raport świeci na czerwono.

Krok 2: GREEN - Minimalny kod

Piszemy najprostszy kod, który spełni testy, bez zapasów na przyszłość:

// dinosaur.js
export class Dinosaur {
  constructor(name, species, diet = 'unknown') {
    this.name = name;
    this.species = species;
    this.diet = diet;
  }

  isDangerous() {
    return this.diet === 'carnivore';
  }
}

Teraz testy przechodzą. Kod wygląda skromnie, ale robi dokładnie to, co opisują testy, i nic więcej.

Krok 3: REFACTOR - Ulepszamy kod

Z zieloną siatką bezpieczeństwa porządkujemy kod: pola prywatne #, gettery i stała z listą niebezpiecznych diet:

// dinosaur.js - po refaktoryzacji
const DANGEROUS_DIETS = ['carnivore', 'omnivore'];

export class Dinosaur {
  #name;
  #species;
  #diet;

  constructor(name, species, diet = 'unknown') {
    this.#validateInput(name, species);
    this.#name = name;
    this.#species = species;
    this.#diet = diet;
  }

  get name() { return this.#name; }
  get species() { return this.#species; }
  get diet() { return this.#diet; }

  #validateInput(name, species) {
    if (!name || !species) {
      throw new Error('Name and species are required');
    }
  }

  isDangerous() {
    return DANGEROUS_DIETS.includes(this.#diet);
  }
}

Uwaga: to nie jest czysta refaktoryzacja. Ta wersja uznaje wszystkożerców za groźnych i rzuca błąd przy braku nazwy, czyli zmienia zachowanie. W prawdziwym TDD każda z tych reguł zaczyna się od nowego, czerwonego testu, a refaktoryzacja zmienia wyłącznie strukturę kodu.

Zaawansowane TDD - System Bezpieczeństwa Parku

Teraz zbudujemy bardziej złożony system, zaczynając od pełnego zestawu testów.

Test Suite dla SecuritySystem

beforeEach tworzy świeży system przed każdym testem, więc testy nie wpływają na siebie, a vi.fn() tworzy funkcję szpiegującą (spy), która zapamiętuje swoje wywołania:

// security-system.test.js
import { describe, it, expect, beforeEach, vi } from 'vitest';
import { SecuritySystem } from './security-system';
import { Enclosure } from './enclosure';
import { Dinosaur } from './dinosaur';

describe('SecuritySystem', () => {
  let securitySystem;
  let mockEnclosure;
  let mockDinosaur;

  beforeEach(() => {
    mockDinosaur = new Dinosaur('Rex', 'Tyrannosaurus', 'carnivore');
    mockEnclosure = new Enclosure('Paddock 1', [mockDinosaur], {
      fenceVoltage: 10000,
      isActive: true
    });
    securitySystem = new SecuritySystem();
    securitySystem.addEnclosure(mockEnclosure);
  });

  describe('addEnclosure', () => {
    it('should add an enclosure to monitoring', () => {
      const newEnclosure = new Enclosure('Paddock 2', [], { fenceVoltage: 5000 });
      securitySystem.addEnclosure(newEnclosure);

      expect(securitySystem.getEnclosures()).toHaveLength(2);
    });

    it('should throw error for duplicate enclosure names', () => {
      const duplicate = new Enclosure('Paddock 1', [], { fenceVoltage: 5000 });

      expect(() => securitySystem.addEnclosure(duplicate))
        .toThrow('Enclosure with this name already exists');
    });
  });

  describe('checkStatus', () => {
    it('should return SAFE when all fences are active', () => {
      expect(securitySystem.checkStatus()).toBe('SAFE');
    });

    it('should return DANGER when any fence is inactive', () => {
      mockEnclosure.deactivateFence();

      expect(securitySystem.checkStatus()).toBe('DANGER');
    });

    it('should return CRITICAL when dangerous dino escapes', () => {
      mockEnclosure.deactivateFence();
      mockEnclosure.markEscaped(mockDinosaur);

      expect(securitySystem.checkStatus()).toBe('CRITICAL');
    });
  });

  describe('getAlerts', () => {
    it('should return empty array when everything is safe', () => {
      expect(securitySystem.getAlerts()).toEqual([]);
    });

    it('should generate alert when fence voltage drops', () => {
      mockEnclosure.setFenceVoltage(1000);

      const alerts = securitySystem.getAlerts();

      expect(alerts).toHaveLength(1);
      expect(alerts[0]).toMatchObject({
        type: 'LOW_VOLTAGE',
        enclosure: 'Paddock 1',
        severity: 'WARNING'
      });
    });
  });

  describe('emergencyProtocol', () => {
    it('should trigger alarms for all affected zones', async () => {
      const alarmSpy = vi.fn();
      securitySystem.onAlarm(alarmSpy);

      await securitySystem.emergencyProtocol('Paddock 1');

      expect(alarmSpy).toHaveBeenCalledWith({
        type: 'EMERGENCY',
        enclosure: 'Paddock 1',
        actions: ['LOCKDOWN', 'EVACUATE', 'ALERT_SECURITY']
      });
    });
  });
});

Testy mówią językiem parku: duplikat wybiegu to błąd, wyłączone ogrodzenie to stan DANGER, a uciekinier drapieżnik to CRITICAL.

Implementacja po TDD

Implementacja powstaje test po teście, aż wszystkie zaświecą się na zielono:

// security-system.js
export class SecuritySystem {
  #enclosures = new Map();
  #alarmCallbacks = [];

  addEnclosure(enclosure) {
    if (this.#enclosures.has(enclosure.name)) {
      throw new Error('Enclosure with this name already exists');
    }
    this.#enclosures.set(enclosure.name, enclosure);
  }

  getEnclosures() {
    return Array.from(this.#enclosures.values());
  }

  checkStatus() {
    const enclosures = this.getEnclosures();

    for (const enclosure of enclosures) {
      const escaped = enclosure.getEscapedDinosaurs();
      if (escaped.some(dino => dino.isDangerous())) {
        return 'CRITICAL';
      }
    }

    for (const enclosure of enclosures) {
      if (!enclosure.isFenceActive()) {
        return 'DANGER';
      }
    }

    return 'SAFE';
  }

  getAlerts() {
    const alerts = [];
    const MINIMUM_SAFE_VOLTAGE = 5000;

    for (const enclosure of this.getEnclosures()) {
      if (enclosure.getFenceVoltage() < MINIMUM_SAFE_VOLTAGE) {
        alerts.push({
          type: 'LOW_VOLTAGE',
          enclosure: enclosure.name,
          severity: 'WARNING',
          currentVoltage: enclosure.getFenceVoltage()
        });
      }
    }

    return alerts;
  }

  onAlarm(callback) {
    this.#alarmCallbacks.push(callback);
  }

  async emergencyProtocol(enclosureName) {
    const alarmData = {
      type: 'EMERGENCY',
      enclosure: enclosureName,
      actions: ['LOCKDOWN', 'EVACUATE', 'ALERT_SECURITY']
    };

    for (const callback of this.#alarmCallbacks) {
      await callback(alarmData);
    }
  }
}

Kolejność w checkStatus nie jest przypadkowa: najpierw ucieczka, potem ogrodzenia, bo test CRITICAL wyłącza ogrodzenie i oznacza ucieczkę jednocześnie. Klasy Enclosure tu nie widać, ale jej interfejs wynika wprost z testów.

Korzyści z TDD

Pewność zmian

Najważniejsza korzyść to siatka bezpieczeństwa przy każdej zmianie:

// Z TDD masz siatkę bezpieczeństwa: jeśli testy przechodzą, sprawdzone zachowania nadal działają

Testy chronią tylko to, co sprawdzają. Zielony wynik nie dowodzi braku błędów, ale mówi, że opisane zachowania nadal działają.

Dokumentacja w kodzie

Dobrze nazwane testy czyta się jak specyfikację parku, bez zaglądania do implementacji:

describe('DinosaurFeeder', () => {
  it('should feed herbivores plants only', () => {
    // Ten test jasno dokumentuje oczekiwane zachowanie
  });

  it('should not feed carnivores to each other', () => {
    // Reguła biznesowa zapisana w teście!
  });
});

Opisy w it to reguły biznesowe, które nie zdezaktualizują się po cichu jak zwykła dokumentacja, bo test przestanie przechodzić.

Lepszy design - TDD wymusza loose coupling

Klasę, która sama tworzy bazę i mailer, trudno przetestować, więc TDD naturalnie prowadzi do wstrzykiwania zależności przez konstruktor:

// TDD prowadzi do Dependency Injection
class GoodParkManager {
  constructor(database, mailer) {
    this.database = database;
    this.mailer = mailer;
  }
}

// Łatwo testować z mockami:
const mockDb = { query: vi.fn() };
const manager = new GoodParkManager(mockDb, mockMailer);

W teście podajesz atrapy (mocki), w produkcji prawdziwe obiekty, a klasa nie widzi różnicy. To zasada odwrócenia zależności z lekcji o SOLID.

TDD Anti-patterns - czego unikać

Testy też bywają złe. Porównaj dwie pary przykładów:

// ANTI-PATTERN: Test zbyt ogólny
it('should work', () => {
  expect(doSomething()).toBeTruthy();
});

// POPRAWNIE: Test konkretny
it('should return dinosaur count for specific species', () => {
  expect(countDinosaurs('Velociraptor')).toBe(8);
});

// ANTI-PATTERN: Testowanie implementacji zamiast zachowania
it('should call database.query', () => {
  service.getDinosaurs();
  expect(database.query).toHaveBeenCalled();
});

// POPRAWNIE: Testowanie zachowania
it('should return all dinosaurs from paddock', () => {
  const result = service.getDinosaurs();
  expect(result).toHaveLength(5);
});

Test sprawdzający wywołanie database.query pęka przy każdej zmianie implementacji, choć zachowanie jest poprawne. Testuj wynik, a nie sposób jego uzyskania.

Narzędzia do TDD

Vitest - nowoczesny framework

Vitest to szybki runner zgodny z API Jesta, naturalny wybór w projektach na Vite. Progi pokrycia kodu ustawiasz w polu coverage.thresholds:

// vitest.config.js
import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    globals: true,
    environment: 'node',
    coverage: {
      provider: 'v8',
      thresholds: { statements: 80, branches: 80, functions: 80, lines: 80 }
    }
  }
});

Uruchomienie testów z pokryciem zakończy się błędem, gdy wynik spadnie poniżej 80%. Traktuj ten próg jako alarm, a nie cel sam w sobie.

Jest - popularny framework

W Jest ten sam próg zapisujesz w polu coverageThreshold:

// jest.config.js
module.exports = {
  testEnvironment: 'node',
  coverageThreshold: {
    global: { statements: 80, branches: 80, functions: 80, lines: 80 }
  }
};

Oba narzędzia mają podobne API (describe, it, expect), więc przesiadka jest łatwa. W nowych projektach polecam Vitest, a w istniejących zostań przy Jest, jeśli dobrze działa.

TDD to potężna technika, która zmienia sposób myślenia o kodzie. Zamiast "najpierw pisz, potem testuj" przyjmujesz podejście "najpierw zdefiniuj oczekiwania, potem implementuj". W kolejnej lekcji połączysz TypeScript z popularnymi frameworkami.

Pamiętaj: test to ogrodzenie postawione przed przywiezieniem dinozaura, a nie po jego ucieczce.

Kod do tej lekcji: index.js
// SharedArrayBuffer i Atomics - współdzielona pamięć między wątkami
console.log("Park Jurajski - System Współdzielonej Pamięci DNA");
console.log("Symulacja SharedArrayBuffer i Atomics\n");

// ====================================
// 1. SHAREDARRAY BUFFER - PODSTAWY
// ====================================
console.log("=== 1. SharedArrayBuffer ===\n");

// Tworzenie SharedArrayBuffer (16 bajtów = 4 x Int32)
const sharedBuffer = new SharedArrayBuffer(16);
const sharedView = new Int32Array(sharedBuffer);

console.log("SharedArrayBuffer utworzony:");
console.log("  Rozmiar:", sharedBuffer.byteLength, "bajtów");
console.log("  Elementy Int32:", sharedView.length);

// Inicjalizacja wartości
sharedView[0] = 100; // Liczba dinozaurów
sharedView[1] = 85;  // Poziom bezpieczeństwa
sharedView[2] = 0;   // Licznik alertów
sharedView[3] = 1;   // Status systemu (1 = aktywny)

console.log("\nPoczątkowe wartości:");
console.log("  Dinozaury:", sharedView[0]);
console.log("  Bezpieczeństwo:", sharedView[1], "%");
console.log("  Alerty:", sharedView[2]);
console.log("  Status:", sharedView[3] === 1 ? "AKTYWNY" : "NIEAKTYWNY");

// ====================================
// 2. ATOMICS - OPERACJE ATOMOWE
// ====================================
console.log("\n=== 2. Operacje Atomics ===\n");

// Atomics.add - dodanie wartości atomowo
const previousAlerts = Atomics.add(sharedView, 2, 1);
console.log("Atomics.add(alerts, 1):");
console.log("  Poprzednia wartość:", previousAlerts);
console.log("  Nowa wartość:", Atomics.load(sharedView, 2));

// Atomics.sub - odjęcie wartości atomowo
const previousSafety = Atomics.sub(sharedView, 1, 10);
console.log("\nAtomics.sub(safety, 10):");
console.log("  Poprzednia wartość:", previousSafety);
console.log("  Nowa wartość:", Atomics.load(sharedView, 1));

// Atomics.exchange - zamiana wartości
const oldStatus = Atomics.exchange(sharedView, 3, 0);
console.log("\nAtomics.exchange(status, 0):");
console.log("  Stara wartość:", oldStatus);
console.log("  Nowa wartość:", Atomics.load(sharedView, 3));

// Atomics.compareExchange - warunkowa zamiana
const result = Atomics.compareExchange(sharedView, 3, 0, 1);
console.log("\nAtomics.compareExchange(status, expected=0, new=1):");
console.log("  Wynik (poprzednia):", result);
console.log("  Aktualna wartość:", Atomics.load(sharedView, 3));

// ====================================
// 3. SYMULACJA KOMUNIKACJI WATKOW
// ====================================
console.log("\n=== 3. Symulacja komunikacji wątków ===\n");

// Symulacja producent-konsument z Atomics
class DinoMonitorSystem {
  constructor() {
    this.buffer = new SharedArrayBuffer(32);
    this.data = new Int32Array(this.buffer);
    // Indeksy: 0=lock, 1=dinoCount, 2=alertCount, 3=safetyLevel
  }

  // Symulacja mutex z Atomics
  acquireLock() {
    while (Atomics.compareExchange(this.data, 0, 0, 1) !== 0) {
      // Spin-wait (w prawdziwym kodzie: Atomics.wait)
    }
    console.log("  Lock acquired");
  }

  releaseLock() {
    Atomics.store(this.data, 0, 0);
    console.log("  Lock released");
  }

  // Dodaj dinozaura (bezpiecznie)
  addDinosaur() {
    this.acquireLock();
    const current = Atomics.load(this.data, 1);
    Atomics.store(this.data, 1, current + 1);
    console.log(`  Dinozaur dodany. Łącznie: ${current + 1}`);
    this.releaseLock();
  }

  // Zgłoś alert (bezpiecznie)
  reportAlert() {
    // Atomics.add jest sam w sobie atomowy - nie potrzeba locka
    const prev = Atomics.add(this.data, 2, 1);
    console.log(`  Alert #${prev + 1} zgłoszony`);
  }

  getStatus() {
    return {
      dinosaurs: Atomics.load(this.data, 1),
      alerts: Atomics.load(this.data, 2),
      safety: Atomics.load(this.data, 3)
    };
  }
}

const monitor = new DinoMonitorSystem();

console.log("Symulacja operacji z wielu wątków:");
monitor.addDinosaur();
monitor.addDinosaur();
monitor.reportAlert();
monitor.addDinosaur();
monitor.reportAlert();

console.log("\nStan systemu:", monitor.getStatus());

// ====================================
// 4. POROWNANIE Z ZWYKLYM BUFOREM
// ====================================
console.log("\n=== 4. SharedArrayBuffer vs ArrayBuffer ===\n");

console.log("ArrayBuffer:");
console.log("  - Kopiowany między wątkami (structured clone)");
console.log("  - Bezpieczny ale wolniejszy");
console.log("  - Brak problemów z race conditions");

console.log("\nSharedArrayBuffer:");
console.log("  - Współdzielony między wątkami (zero-copy)");
console.log("  - Szybszy ale wymaga synchronizacji");
console.log("  - Wymaga Atomics do bezpiecznego dostępu");
console.log("  - Wymaga nagłówków COOP/COEP");

console.log("\nKiedy używać SharedArrayBuffer:");
console.log("- Intensywne obliczenia numeryczne");
console.log("- Przetwarzanie dużych zbiorów danych");
console.log("- Aplikacje real-time (gry, symulacje)");
console.log("- Współdzielenie stanu między Web Workers");

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Przydatne artykuły