Kurs JavaScript i TypeScript · Moduł 10: TypeScript w praktyce
Test-Driven Development (TDD) - Ewolucja kodu przez testy
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 cyklCzerwony 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?