Kurs NestJS · Moduł 7: Testowanie

Performance Testing - próby wytrzymałościowe

5 min czytania ·
W tej lekcji5

Legion sprawdził już, czy machiny działają. Zostało pytanie inne: ile wytrzymają? Katapulta, która oddaje jeden strzał, jest bezużyteczna przy oblężeniu trwającym tydzień. Testy wydajnościowe mierzą właśnie to - nie czy kod działa, ale jak długo i pod jakim naporem.

Takie próby są jednak wyjątkowo wrażliwe na bałagan. Test, który zostawia po sobie tysiąc rekordów w bazie, zafałszuje wynik następnego. Dlatego zanim zmierzymy wytrzymałość machin, ułożymy plac prób w porządku - i ten porządek przyda Ci się w każdym teście, nie tylko wydajnościowym.

Gdzie mieszka test

Zacznijmy od nazwy pliku, bo tu obowiązuje konwencja, której trzyma się cały ekosystem NestJS:

legions.service.spec.ts

Czyta się ją od lewej: co testujemy (legions), jakiego rodzaju to element (service), że to plik testowy (spec), i wreszcie rozszerzenie (ts). Testy E2E dostają zamiast tego .e2e-spec.ts.

Ta konwencja nie jest ozdobnikiem - Jest domyślnie wyszukuje pliki po tym wzorcu. Plik nazwany testLegions.ts po prostu nigdy się nie uruchomi, a Ty będziesz się zastanawiać, czemu warta w CI świeci na zielono. Plik trzymamy obok testowanego kodu, dzięki czemu widać na pierwszy rzut oka, co ma testy, a co nie.

Wzorzec AAA - trzy takty jednej próby

Blok describe grupujący testy jednego elementu nazywamy suite - zestawem prób. Wewnątrz niego każdy test układa się w ten sam rytm, znany jako AAA:

it('obsługuje 100 zapytań poniżej 2 sekund', async () => {
  // Arrange - przygotuj dane i atrapy
  const legions = Array.from({ length: 100 }, (_, i) => ({ id: i, name: `Legio ${i}` }));
  jest.spyOn(repo, 'find').mockResolvedValue(legions);

  // Act - wywołaj testowaną metodę
  const start = Date.now();
  await Promise.all(Array.from({ length: 100 }, () => service.findAll()));
  const duration = Date.now() - start;

  // Assert - sprawdź wynik
  expect(duration).toBeLessThan(2000);
});

Trzy takty odpowiadają trzem słowom. Arrange przygotowuje scenę: dane, atrapy, stan początkowy. Act to jedno wywołanie - to, co właśnie badamy. Assert sprawdza wynik jedną lub kilkoma asercjami.

Wartość tego podziału jest praktyczna: gdy test padnie, od razu wiesz, w którym takcie szukać. A gdy w sekcji Act znajdziesz więcej niż jedno wywołanie, to znak, że test bada dwie rzeczy naraz i warto go rozdzielić.

Do trzech taktów dochodzi czwarty, o którym łatwo zapomnieć: Cleanup - posprzątanie po teście, w żargonie nazywane teardown. Nie zapisujemy go zwykle w ciele testu, tylko w osobnym haku, i to właśnie on decyduje o rzetelności prób wydajnościowych.

Haki - kiedy przygotować, kiedy posprzątać

Jest daje cztery haki, a ich wybór sprowadza się do jednego pytania: czy to ma się dziać raz, czy przy każdym teście?

describe('LegionsService - wydajność', () => {
  let service: LegionsService;
  let module: TestingModule;

  beforeAll(async () => {
    module = await Test.createTestingModule({
      providers: [LegionsService, { provide: getRepositoryToken(Legion), useValue: repo }],
    }).compile();

    service = module.get(LegionsService);
  });

  afterEach(() => {
    jest.clearAllMocks();
  });

  afterAll(async () => {
    await module.close();
  });
});

beforeAll uruchamia się raz przed wszystkimi testami w bloku - tu budujemy moduł testowy, bo to operacja kosztowna i nie ma powodu powtarzać jej sto razy. beforeEach działałby przed każdym testem; tam trafia to, co musi być świeże, na przykład czyszczenie tabeli.

Po drugiej stronie afterEach sprząta po każdym teście - jak tutaj zerowanie atrap - a afterAll zamyka to, co otworzył beforeAll: połączenia, moduł, pliki.

Zasada jest symetryczna i warto ją zapamiętać: co otworzył beforeAll, zamyka afterAll; co przygotował beforeEach, sprząta afterEach. Niedomknięte połączenie sprawi, że Jest zawiesi się po ostatnim teście, wypisując, że coś jeszcze działa.

Przypadki brzegowe (edge cases) - gdzie machiny pękają

Test przy typowym obciążeniu mówi niewiele. Najciekawsze jest to, co dzieje się na krańcach, a dla prób wytrzymałościowych krańce są trzy: zero, jeden i bardzo dużo.

describe('findAll pod obciążeniem', () => {
  it('zwraca pustą tablicę, gdy legionów brak', async () => {
    jest.spyOn(repo, 'find').mockResolvedValue([]);

    await expect(service.findAll()).resolves.toEqual([]);
  });

  it('nie przekracza 5 sekund przy 10 000 legionów', async () => {
    jest.spyOn(repo, 'find').mockResolvedValue(makeLegions(10_000));

    const start = Date.now();
    await service.findAll();

    expect(Date.now() - start).toBeLessThan(5000);
  });
});

Pierwszy test pilnuje pustki - tam, gdzie kod lubi rzucić błędem przy legions[0]. Drugi to spike: nagły, wielokrotnie większy ładunek, sprawdzający, czy metoda skaluje się rozsądnie, czy zaczyna dławić się przy każdym rekordzie z osobna.

Jedna uwaga o progach czasowych: ustawiaj je z zapasem. Maszyna w CI bywa wolniejsza od Twojej, a test, który pada losowo raz na dziesięć przebiegów, zostanie wyłączony przez pierwszą osobę, której zablokuje wdrożenie - i słusznie. Lepszy próg luźny, ale wiarygodny, niż ostry i ignorowany.

Podsumowanie

Plac prób uporządkowany, machiny zmierzone:

  • testy wydajnościowe pytają nie czy kod działa, ale jak długo i pod jakim naporem,
  • nazwa pliku to konwencja, po której Jest wyszukuje testy: nazwa.service.spec.ts, a dla E2E .e2e-spec.ts,
  • wzorzec AAA: Arrange przygotowuje dane i atrapy, Act wywołuje badaną metodę, Assert sprawdza wynik, a Cleanup sprząta,
  • więcej niż jedno wywołanie w sekcji Act znaczy, że test bada dwie rzeczy naraz,
  • suite to blok describe; przygotowanie nazywamy setup, sprzątanie - teardown,
  • beforeAll i afterAll obsługują to, co kosztowne i jednorazowe; beforeEach i afterEach - to, co musi być świeże przy każdym teście,
  • co otworzył beforeAll, zamyka afterAll - niedomknięte połączenie zawiesza Jest po ostatnim teście,
  • przypadki brzegowe dla wytrzymałości to zero, jeden i bardzo dużo; ostatni z nich to spike,
  • progi czasowe ustawiaj z zapasem - test padający losowo zostanie wyłączony i przestanie chronić cokolwiek.

W następnej lekcji te próby przestaną zależeć od Twojej pamięci - wpuścimy je do automatycznej warty w CI. A na razie zapamiętaj: wzorzec AAA to trzy takty jednej próby, a haki pilnują, żeby każda zaczynała się na czystym placu.

Kod do tej lekcji: src/performance-testing.ts
// Performance Testing - Proby Wytrzymalosciowe Fortu

// Narzedzia do testowania wydajnosci w NestJS

// 1. Mierzenie czasu wykonania
class PerformanceTester {
  static async measureExecution<T>(
    fn: () => Promise<T>,
    label: string
  ): Promise<{ result: T; duration: number }> {
    const start = performance.now();
    const result = await fn();
    const duration = performance.now() - start;
    console.log(`[PERF] ${label}: ${duration.toFixed(2)}ms`);
    return { result, duration };
  }

  // Testuj obciazenie - symuluj wielu uzytkownikow
  static async loadTest(
    fn: () => Promise<any>,
    concurrency: number,
    iterations: number
  ) {
    const results: number[] = [];

    for (let i = 0; i < iterations; i++) {
      const promises = Array.from({ length: concurrency }, () => {
        const start = performance.now();
        return fn().then(() => performance.now() - start);
      });
      const times = await Promise.all(promises);
      results.push(...times);
    }

    const sorted = [...results].sort((a, b) => a - b);
    const avg = results.reduce((a, b) => a + b, 0) / results.length;

    return {
      totalRequests: results.length,
      avgResponseTime: avg.toFixed(2) + 'ms',
      maxResponseTime: Math.max(...results).toFixed(2) + 'ms',
      minResponseTime: Math.min(...results).toFixed(2) + 'ms',
      p95: sorted[Math.floor(results.length * 0.95)].toFixed(2) + 'ms',
    };
  }
}

// 2. Serwis z roznymi zlozonosci operacji
class LegionQueryService {
  private legions: Array<{ id: number; name: string; soldiers: number }>;

  constructor() {
    this.legions = Array.from({ length: 10000 }, (_, i) => ({
      id: i + 1,
      name: `Legio ${i + 1}`,
      soldiers: Math.floor(Math.random() * 10000),
    }));
  }

  findByName(name: string) {
    return this.legions.find(l => l.name === name); // O(n)
  }

  findById(id: number) {
    return this.legions[id - 1]; // O(1)
  }

  getTopLegions(count: number) {
    return [...this.legions]
      .sort((a, b) => b.soldiers - a.soldiers)
      .slice(0, count); // O(n log n)
  }
}

// 3. Benchmark
async function runBenchmark() {
  const service = new LegionQueryService();

  console.log('=== BENCHMARK: Wyszukiwanie Legionow ===');

  await PerformanceTester.measureExecution(
    async () => service.findById(5000),
    'findById (O(1))'
  );

  await PerformanceTester.measureExecution(
    async () => service.findByName('Legio 5000'),
    'findByName (O(n))'
  );

  await PerformanceTester.measureExecution(
    async () => service.getTopLegions(10),
    'getTopLegions (O(n log n))'
  );
}

Widzisz błąd w tej lekcji?

Zadania praktyczne w grze

  • Edytor kodu

    Stwórz pełny suite testowy z setup, teardown i edge cases

  • Układanie w poziomie

    Ułóż poprawną konwencję nazewnictwa pliku testowego:

  • Klikanie w kolejności

    Ułóż wzorzec AAA (Arrange-Act-Assert) testu:

  1. Zadanie z kodemPraktyka: Pełny suite testowy
  2. Ułóż w kolejnościBest practice: Naming conventions
  3. Kliknij w kolejnościWzorce AAA i best practices

Przydatne artykuły