Kurs NestJS · Moduł 7: Testowanie
E2E Testing - symulacja pełnej kampanii
W tej lekcji6
Katapulta strzela, części do siebie pasują. Ale kampania to nie jeden wystrzał: zwiad odnajduje wroga, posłaniec niesie rozkaz, legion się ustawia, machiny biją, obóz zwija się o zmierzchu. Sprawdzenie każdego etapu osobno nie powie Ci, czy cała wyprawa dojdzie do końca.
Test E2E - od końca do końca - przechodzi tę drogę w całości. Uruchamia prawdziwą aplikację, wysyła prawdziwe żądania i sprawdza to, co zobaczyłby użytkownik. Żadnych atrap: jeśli po drodze zawiedzie walidacja, uwierzytelnienie albo zapis do bazy, test to wyłapie.
Gdzie mieszkają testy E2E
Testy E2E trzymamy osobno od reszty, bo mają własną konfigurację i własne tempo:
test/
app.e2e-spec.ts
jest-e2e.jsonPlik z testami ma przyrostek .e2e-spec.ts, a konfiguracja Jest dla nich leży w test/jest-e2e.json. To ona każe Jest szukać plików po innym wzorcu i ustawia dłuższy limit czasu, bo pełna droga trwa dłużej niż wywołanie jednej metody. Uruchamiasz je osobnym poleceniem npm run test:e2e, właśnie po to, żeby nie spowalniały szybkiego przebiegu testów jednostkowych.
Cztery kroki do działającej aplikacji
Przygotowanie aplikacji przebiega zawsze tak samo i warto znać kolejność:
describe('Legions (e2e)', () => {
let app: INestApplication;
beforeAll(async () => {
const moduleFixture = await Test.createTestingModule({
imports: [AppModule],
}).compile();
app = moduleFixture.createNestApplication();
app.useGlobalPipes(new ValidationPipe());
await app.init();
});
afterAll(async () => {
await app.close();
});
});Krok pierwszy: Test.createTestingModule({ imports: [AppModule] }) - importujemy AppModule, czyli korzeń całej aplikacji. To jest różnica wobec testu integracyjnego, gdzie braliśmy pojedynczy moduł: tu wchodzi wszystko.
Krok drugi: .compile() rozwiązuje zależności i tworzy instancje.
Krok trzeci: createNestApplication() zamienia moduł w aplikację zdolną obsłużyć żądanie.
Krok czwarty: await app.init() ją uruchamia.
Między trzecim a czwartym krokiem jest miejsce na jedną rzecz, o której łatwo zapomnieć: globalne elementy konfigurowane zwykle w main.ts. ValidationPipe, filtry wyjątków, prefiks tras - żadne z nich nie wchodzi automatycznie, bo main.ts w teście się nie wykonuje. Jeśli tego nie dopiszesz, aplikacja testowa przyjmie dane, które produkcja odrzuciłaby - i test przejdzie fałszywie.
Przejście pełnej drogi
Mając aplikację, wysyłamy żądania biblioteką supertest - tą samą, którą poznałeś przy testach integracyjnych:
it('tworzy legion i pozwala go pobrać', async () => {
const created = await request(app.getHttpServer())
.post('/legions')
.send({ name: 'Legio I' })
.expect(201);
await request(app.getHttpServer())
.get(`/legions/${created.body.id}`)
.expect(200)
.expect((res) => {
expect(res.body).toEqual({
id: created.body.id,
name: 'Legio I',
});
});
});Łańcuch czyta się jak opis rozmowy z serwerem: request(app.getHttpServer()) bierze serwer aplikacji, .post('/legions') wybiera metodę i adres, .send({...}) dokłada ciało żądania, .expect(201) sprawdza kod odpowiedzi. Zapamiętaj tę kolejność - to szkielet każdego testu E2E.
Ale najciekawsze jest tu coś innego: drugie żądanie korzysta z wyniku pierwszego. Zapisaliśmy legion, a potem pobraliśmy go po identyfikatorze zwróconym przez serwer. Właśnie tego nie zrobi żaden test niższego poziomu - sprawdzamy nie pojedynczy endpoint, tylko scenariusz użytkownika złożony z kilku kroków.
toEqual kontra toBe
W ostatniej asercji użyliśmy toEqual i to nie jest przypadek:
expect(res.body).toEqual({ id: 1, name: 'Legio I' }); // przechodzi
expect(res.body).toBe({ id: 1, name: 'Legio I' }); // padaRóżnica jest zasadnicza. toBe pyta, czy to ten sam obiekt - ta sama komórka pamięci. Odpowiedź serwera przyszła po sieci i została odtworzona z JSON-a, więc nigdy nie będzie tym samym obiektem co Twój literał; toBe zawsze tu padnie.
toEqual porównuje głęboko: schodzi po strukturze i sprawdza wartość każdego pola. Dla obiektów i tablic to jest właściwy wybór. toBe zostaw dla liczb, tekstów i wartości logicznych, gdzie „ten sam" i „równy" znaczą to samo.
Kiedy nie E2E - kontroler w izolacji
Pełna droga daje najwięcej pewności, ale kosztuje najwięcej czasu. Gdy chcesz sprawdzić samą logikę kontrolera - czy przekazuje właściwe argumenty dalej - zbuduj go z zamockowanym serwisem:
const mockService = { findAll: jest.fn().mockResolvedValue([]) };
const module = await Test.createTestingModule({
controllers: [LegionsController],
providers: [{ provide: LegionsService, useValue: mockService }],
}).compile();
const controller = module.get(LegionsController);
it('przekazuje filtr statusu do serwisu', async () => {
await controller.findAll('active');
expect(mockService.findAll).toHaveBeenCalledWith({ status: 'active' });
});Serwis jest tu atrapą, więc badamy wyłącznie kontroler. Asercja toHaveBeenCalledWith sprawdza, z jakimi argumentami wywołano atrapę - a to jedyny sposób, by potwierdzić, że kontroler poprawnie przetłumaczył parametr zapytania na obiekt filtra. Wynik nas tu nie interesuje; interesuje rozmowa między warstwami.
Wybór między jednym a drugim sprowadza się do pytania: czy sprawdzam logikę jednej warstwy, czy drogę przez wszystkie. E2E dla scenariuszy, izolacja dla szczegółów.
Podsumowanie
Kampania przeszła całą drogę:
- test E2E uruchamia prawdziwą aplikację i przechodzi pełną drogę żądania, bez atrap,
- pliki mają przyrostek
.e2e-spec.ts, konfiguracja leży wtest/jest-e2e.json, uruchamia jenpm run test:e2e, - cztery kroki przygotowania:
createTestingModule({ imports: [AppModule] }),.compile(),createNestApplication(),await app.init(), - globalne elementy z
main.tsnie wchodzą automatycznie -ValidationPipei filtry trzeba dopisać, inaczej test przejdzie fałszywie, - łańcuch supertest:
request(app.getHttpServer()),.post('/adres'),.send({...}),.expect(201), - siła E2E to scenariusz z wielu kroków, gdzie kolejne żądanie korzysta z wyniku poprzedniego,
toEqualporównuje głęboko strukturę i wartości - to wybór dla obiektów;toBesprawdza tożsamość i pasuje tylko do wartości prostych,- do zbadania samego kontrolera podmień serwis atrapą i użyj
toHaveBeenCalledWith, żeby sprawdzić przekazane argumenty, app.close()wafterAlljest obowiązkowe.
W następnej lekcji przyjrzymy się bliżej samym atrapom - poznasz cztery rodzaje dublerów i różnicę między jest.fn() a jest.spyOn(). A na razie zapamiętaj: E2E sprawdza, czy kampania dochodzi do końca; izolacja sprawdza, czy pojedynczy posłaniec niesie właściwy rozkaz.
Kod do tej lekcji: src/e2e-testing.spec.ts
// E2E Testing - Symulacja Pelnej Wyprawy
import { Test, TestingModule } from '@nestjs/testing';
import { INestApplication, ValidationPipe } from '@nestjs/common';
import * as request from 'supertest';
import { Controller, Get, Post, Body, Param, Module } from '@nestjs/common';
import { Injectable } from '@nestjs/common';
// Serwis legionow
@Injectable()
class LegionService {
private legions = [
{ id: 1, name: 'Legio X', province: 'Gallia', soldiers: 5000 },
];
findAll() { return this.legions; }
findOne(id: number) { return this.legions.find(l => l.id === id); }
create(data: any) {
const legion = { id: this.legions.length + 1, ...data };
this.legions.push(legion);
return legion;
}
}
// Kontroler
@Controller('legions')
class LegionController {
constructor(private service: LegionService) {}
@Get()
findAll() { return this.service.findAll(); }
@Get(':id')
findOne(@Param('id') id: string) {
return this.service.findOne(parseInt(id));
}
@Post()
create(@Body() data: any) {
return this.service.create(data);
}
}
// Modul
@Module({
controllers: [LegionController],
providers: [LegionService],
})
class LegionModule {}
// Testy E2E
describe('Legion E2E Tests', () => {
let app: INestApplication;
beforeAll(async () => {
const moduleFixture: TestingModule = await Test.createTestingModule({
imports: [LegionModule],
}).compile();
app = moduleFixture.createNestApplication();
app.useGlobalPipes(new ValidationPipe());
await app.init();
});
afterAll(async () => {
await app.close();
});
it('GET /legions - should return all legions', () => {
return request(app.getHttpServer())
.get('/legions')
.expect(200)
.expect((res) => {
expect(Array.isArray(res.body)).toBe(true);
expect(res.body.length).toBeGreaterThan(0);
});
});
it('POST /legions - should create a legion', () => {
return request(app.getHttpServer())
.post('/legions')
.send({ name: 'Legio XIV', province: 'Pannonia', soldiers: 4500 })
.expect(201)
.expect((res) => {
expect(res.body.name).toBe('Legio XIV');
expect(res.body.id).toBeDefined();
});
});
it('GET /legions/:id - should return single legion', () => {
return request(app.getHttpServer())
.get('/legions/1')
.expect(200)
.expect((res) => {
expect(res.body.name).toBe('Legio X');
});
});
});
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Przy testowaniu kontrolera NestJS serwisy powinny być:
2. expect(result).toEqual(expected) sprawdza:
To 2 z 4 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Przetestuj endpoint GET kontrolera legionów
- Układanie w poziomie
Ułóż asercję sprawdzającą wywołanie mocka z argumentami:
- Edytor kodu
Stwórz test E2E dla endpointu GET /legions
- Układanie w pionie
Ułóż kroki testu E2E z supertest w poprawnej kolejności:
- Układanie w pionie
Uporządkuj kroki przygotowania aplikacji do testu E2E:
Zadania po tej lekcji
- PytanieTestowanie kontrolerów NestJS
- PytanieAsercje w testach kontrolerów
- Zadanie z kodemPraktyka: Test kontrolera
- Ułóż w kolejnościWywołania mocka toHaveBeenCalled
- PytanieNarzędzie do testów E2E
- PytanieKonfiguracja E2E w NestJS
- Zadanie z kodemPraktyka: Test E2E
- Ułóż w kolejnościProces testu E2E
- Ułóż w kolejnościInicjalizacja app w E2E