Kurs NestJS · Moduł 7: Testowanie
Performance Testing - próby wytrzymałościowe
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.tsCzyta 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:
Arrangeprzygotowuje dane i atrapy,Actwywołuje badaną metodę,Assertsprawdza wynik, aCleanupsprząta, - więcej niż jedno wywołanie w sekcji
Actznaczy, że test bada dwie rzeczy naraz, - suite to blok
describe; przygotowanie nazywamy setup, sprzątanie - teardown, beforeAlliafterAllobsługują to, co kosztowne i jednorazowe;beforeEachiafterEach- to, co musi być świeże przy każdym teście,- co otworzył
beforeAll, zamykaafterAll- 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: