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

Setup i Teardown

5 min czytania ·
W tej lekcji5

Wyobraź sobie trzy testy, które korzystają z jednego wspólnego wybiegu. Pierwszy wpuszcza T-Rexa, drugi sprawdza, czy wybieg jest pusty - i pada, bo T-Rex wciąż tam siedzi. Testy, które dzielą stan, zaczynają od siebie zależeć: wynik zależy od kolejności uruchomienia, a błąd w jednym przewraca kolejne jak kostki domina.

W Parku Jurajskim przed każdą inspekcją wybiegu trzeba przygotować sprzęt, a po inspekcji posprzątać. W testach jest dokładnie tak samo - funkcje setup i teardown pozwalają przygotować i posprzątać środowisko testowe. W Jest nazywamy je hookami, a są cztery: beforeEach, afterEach, beforeAll i afterAll.

beforeEach - przed każdym testem

beforeEach wykonuje się przed każdym testem w bloku describe. To idealne miejsce na tworzenie świeżych danych testowych. Zmienne deklarujesz przez let w zasięgu describe, a wartości przypisujesz w hooku. Fabryki createEnclosure i createDinosaur znasz z poprzednich lekcji:

describe('DinosaurEnclosure', () => {
  let enclosure;
  let rex;

  beforeEach(() => {
    // Przed każdym testem tworzymy nowy wybieg i dinozaura
    enclosure = createEnclosure('Zone A', 5);
    rex = createDinosaur('Rex', 'T-Rex', 'carnivore');
  });

  it('should add dinosaur to enclosure', () => {
    enclosure.add(rex);
    expect(enclosure.dinosaurs).toHaveLength(1);
    expect(enclosure.dinosaurs[0].name).toBe('Rex');
  });

  it('should start with empty enclosure', () => {
    // Dzięki beforeEach enclosure jest zawsze świeży!
    expect(enclosure.dinosaurs).toHaveLength(0);
  });

  it('should track capacity', () => {
    enclosure.add(rex);
    expect(enclosure.remainingCapacity()).toBe(4);
  });
});

Drugi test przechodzi, choć pierwszy dodał Rexa do wybiegu. Stary obiekt nie zniknął magicznie - po prostu beforeEach przypisał do zmiennej enclosure zupełnie nowy wybieg. To sekcja Arrange ze wzorca AAA, przeniesiona do hooka, żeby nie powtarzać jej w każdym teście.

afterEach - po każdym teście

afterEach wykonuje się po każdym teście. Służy do czyszczenia po testach - zamykania połączeń, resetowania stanu. W przykładzie SecuritySystem to klasa systemu bezpieczeństwa: onAlarm rejestruje funkcję wywoływaną przy alarmie, simulateBreach symuluje naruszenie ogrodzenia, a deactivate wyłącza system:

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

  beforeEach(() => {
    securitySystem = new SecuritySystem();
    alarmLog = [];
    securitySystem.onAlarm((msg) => alarmLog.push(msg));
  });

  afterEach(() => {
    // Resetuj system bezpieczeństwa po każdym teście
    securitySystem.deactivate();
    alarmLog = [];
    console.log('System zresetowany po teście');
  });

  it('should detect breach', () => {
    securitySystem.simulateBreach('Zone A');
    expect(alarmLog).toContain('Naruszenie w Zone A');
  });

  it('should handle multiple alarms', () => {
    securitySystem.simulateBreach('Zone A');
    securitySystem.simulateBreach('Zone B');
    expect(alarmLog).toHaveLength(2);
  });
});

afterEach wykona się również wtedy, gdy test nie przejdzie, dlatego to najlepsze miejsce na etap sprzątania (cleanup). Linia z console.log pokazuje tylko moment wykonania - w prawdziwych testach nie jest potrzebna.

beforeAll i afterAll - raz dla całej grupy

beforeAll uruchamia się raz przed wszystkimi testami w describe, a afterAll raz po wszystkich. Używaj ich dla kosztownych operacji. connectToDatabase to przykładowa asynchroniczna funkcja łącząca z bazą. Hooki, tak jak testy, mogą być async, a Jest poczeka na ich zakończenie:

describe('DatabaseTests', () => {
  let database;

  beforeAll(async () => {
    // Kosztowna operacja - połączenie z bazą, tylko raz!
    database = await connectToDatabase();
    console.log('Baza danych podłączona');
  });

  afterAll(async () => {
    // Zamknij połączenie po wszystkich testach
    await database.close();
    console.log('Baza danych odłączona');
  });

  beforeEach(async () => {
    // Wyczyść dane przed każdym testem
    await database.clear();
  });

  it('should save dinosaur', async () => {
    await database.save({ name: 'Rex', species: 'T-Rex' });
    const dinos = await database.findAll();
    expect(dinos).toHaveLength(1);
  });

  it('should find by species', async () => {
    await database.save({ name: 'Rex', species: 'T-Rex' });
    await database.save({ name: 'Blue', species: 'Velociraptor' });

    const raptors = await database.findBySpecies('Velociraptor');
    expect(raptors).toHaveLength(1);
    expect(raptors[0].name).toBe('Blue');
  });
});

Połączenie powstaje tylko raz, ale dane czyścimy przed każdym testem w beforeEach. To typowy duet: drogi zasób współdzielony, tani stan odświeżany. Moja rada: wszystko, co da się szybko odtworzyć, twórz w beforeEach, a beforeAll zostaw dla naprawdę kosztownych operacji. Współdzielony stan to najczęstsze źródło testów, które przechodzą tylko w określonej kolejności.

Jak rozpoznać taki przeciek? Test przechodzi, gdy uruchomisz go samodzielnie, a pada w całym zestawie. Dokumentacja Jesta radzi wtedy tymczasowo zamienić test na test.only (albo it na it.only), żeby uruchomić tylko ten jeden przypadek, i poszukać stanu, który zmienia inny test.

Kolejność wykonywania

Ważne jest zrozumienie kolejności, w jakiej Jest wykonuje setup i teardown. Poniższy blok wypisuje w konsoli numer kroku z każdego hooka i z każdego testu:

describe('Kolejność wykonywania', () => {
  beforeAll(() => console.log('1. beforeAll'));
  afterAll(() => console.log('5. afterAll'));
  beforeEach(() => console.log('2. beforeEach'));
  afterEach(() => console.log('4. afterEach'));

  it('test 1', () => console.log('3. test 1'));
  it('test 2', () => console.log('3. test 2'));
});

// Wynik:
// 1. beforeAll
// 2. beforeEach
// 3. test 1
// 4. afterEach
// 2. beforeEach
// 3. test 2
// 4. afterEach
// 5. afterAll

beforeAll i afterAll pojawiają się w wyniku tylko raz, a para beforeEach i afterEach otacza każdy test osobno. Jest ma jeszcze jedną cechę, o której warto wiedzieć: najpierw wykonuje wszystkie funkcje describe w pliku, zbierając listę testów, a dopiero potem uruchamia same testy. Kod wpisany bezpośrednio w describe, poza hookiem, wykona się więc wcześniej, niż się spodziewasz.

Zagnieżdżone describe

Setup i teardown działają hierarchicznie w zagnieżdżonych describe. Przypomina to strefy parku, które mają własne procedury, ale obowiązuje je też regulamin całego parku:

describe('Park Jurajski', () => {
  beforeEach(() => console.log('Setup: Park'));

  describe('Strefa Drapieżników', () => {
    beforeEach(() => console.log('Setup: Strefa Drapieżników'));

    it('T-Rex jest w wybiegu', () => {
      console.log('Test: T-Rex');
      // Kolejność setup: Park -> Strefa Drapieżników
    });
  });

  describe('Strefa Roślinożerców', () => {
    beforeEach(() => console.log('Setup: Strefa Roślinożerców'));

    it('Triceratops jest w wybiegu', () => {
      console.log('Test: Triceratops');
      // Kolejność setup: Park -> Strefa Roślinożerców
    });
  });
});

Zagnieżdżone describe dziedziczą setup z nadrzędnych bloków. beforeEach z rodzica wykonuje się przed beforeEach dziecka. Przy sprzątaniu kolejność się odwraca: najpierw afterEach dziecka, potem rodzica. Hooki zadeklarowane na najwyższym poziomie pliku, poza jakimkolwiek describe, dotyczą każdego testu w tym pliku.

W lekcji o mockowaniu użyjesz beforeEach do czyszczenia sztucznych funkcji, a przy kodzie asynchronicznym do włączania sztucznych zegarów. W laboratorium poniżej zobaczysz kolejność hooków wypisaną krok po kroku.

Pamiętaj: beforeEach to poranna inspekcja wybiegu - każdy test zaczyna dzień na czystym, sprawdzonym terenie.

Kod do tej lekcji: index.js
// Setup i Teardown - beforeEach, afterEach, beforeAll, afterAll
console.log("=== Park Jurajski - Inspekcja Wybiegow ===\n");

// Symulacja setup/teardown
const log = [];
let currentDescribe = "";

function logStep(step) {
  log.push(step);
  console.log(`  ${step}`);
}

// --- Demonstracja kolejnosci ---
console.log("--- Kolejnosc wykonywania ---\n");

// Symulacja
const steps = [];

function simulateTestRun() {
  // beforeAll
  steps.push("1. beforeAll - polaczenie z baza");

  // Test 1
  steps.push("2. beforeEach - tworzenie srodowiska");
  steps.push("3. TEST 1 - sprawdzenie wybiegu");
  steps.push("4. afterEach - czyszczenie");

  // Test 2
  steps.push("5. beforeEach - tworzenie srodowiska");
  steps.push("6. TEST 2 - sprawdzenie sensora");
  steps.push("7. afterEach - czyszczenie");

  // afterAll
  steps.push("8. afterAll - zamkniecie bazy");
}

simulateTestRun();
steps.forEach(s => console.log(s));

// --- Praktyczny przyklad ---
console.log("\n--- Praktyczny przyklad: beforeEach ---\n");

function createEnclosure(name, capacity) {
  return {
    name,
    capacity,
    dinosaurs: [],
    add(dino) { this.dinosaurs.push(dino); },
    remainingCapacity() { return this.capacity - this.dinosaurs.length; }
  };
}

// Symulacja testow z beforeEach
let enclosure;
let rex;

function beforeEach() {
  enclosure = createEnclosure("Zone A", 5);
  rex = { name: "Rex", species: "T-Rex" };
  console.log("  [setup] Nowy wybieg i dinozaur stworzony");
}

// Test 1
beforeEach();
enclosure.add(rex);
console.log(`  [test1] Dinozaurow: ${enclosure.dinosaurs.length} -> ${enclosure.dinosaurs.length === 1 ? "PASS" : "FAIL"}`);

// Test 2 - wybieg jest swiezy dzieki beforeEach!
beforeEach();
console.log(`  [test2] Pusty wybieg: ${enclosure.dinosaurs.length} -> ${enclosure.dinosaurs.length === 0 ? "PASS" : "FAIL"}`);

// Test 3
beforeEach();
enclosure.add(rex);
console.log(`  [test3] Remaining: ${enclosure.remainingCapacity()} -> ${enclosure.remainingCapacity() === 4 ? "PASS" : "FAIL"}`);

// --- Zagniezdzone describe ---
console.log("\n--- Zagniezdzone describe ---\n");

function simulateNested() {
  const order = [];

  // Outer beforeEach
  order.push("Park: beforeEach");

  // Inner: Drapiezniki
  order.push("  Drapiezniki: beforeEach");
  order.push("    TEST: T-Rex w wybiegu");
  order.push("  Drapiezniki: afterEach");
  order.push("Park: afterEach");

  order.push(""); // separator

  order.push("Park: beforeEach");
  order.push("  Roslinozerce: beforeEach");
  order.push("    TEST: Triceratops w wybiegu");
  order.push("  Roslinozerce: afterEach");
  order.push("Park: afterEach");

  return order;
}

simulateNested().forEach(s => console.log(s));

// --- beforeAll vs beforeEach ---
console.log("\n--- beforeAll vs beforeEach ---\n");
console.log("beforeAll:  raz przed WSZYSTKIMI testami (np. polaczenie z baza)");
console.log("beforeEach: przed KAZDYM testem (np. czyszczenie danych)");
console.log("afterEach:  po KAZDYM tescie (np. reset stanu)");
console.log("afterAll:   raz po WSZYSTKICH testach (np. zamkniecie polaczenia)");

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. Kiedy wykonuje się funkcja beforeEach w Jest?

  2. 2. Jaka jest różnica między beforeAll a beforeEach?

Zadania praktyczne w grze

  • Edytor kodu

    Napisz testy systemu ogrodzeń z beforeEach zapewniającym czysty stan.

  • Układanie w pionie

    Ułóż kolejność wykonywania funkcji setup/teardown w Jest:

  • Klikanie w kolejności

    Ułóż elementy deklaracji beforeEach:

  • Edytor kodu

    Stwórz testy z zagnieżdżonymi describe i osobnymi beforeEach.

  1. PytanieFunkcja beforeEach
  2. PytanieRóżnica beforeAll vs beforeEach
  3. Zadanie z kodemTesty z beforeEach
  4. Ułóż w kolejnościKolejność wykonywania setup/teardown
  5. Kliknij w kolejnościSkładnia beforeEach
  6. Zadanie z kodemZagnieżdżone describe

Przydatne artykuły