Kurs NestJS · Moduł 7: Testowanie

E2E Testing - symulacja pełnej kampanii

5 min czytania ·
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.json

Plik 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' });      // pada

Róż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 w test/jest-e2e.json, uruchamia je npm run test:e2e,
  • cztery kroki przygotowania: createTestingModule({ imports: [AppModule] }), .compile(), createNestApplication(), await app.init(),
  • globalne elementy z main.ts nie wchodzą automatycznie - ValidationPipe i 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,
  • toEqual porównuje głęboko strukturę i wartości - to wybór dla obiektów; toBe sprawdza 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() w afterAll jest 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. 1. Przy testowaniu kontrolera NestJS serwisy powinny być:

  2. 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:

  1. PytanieTestowanie kontrolerów NestJS
  2. PytanieAsercje w testach kontrolerów
  3. Zadanie z kodemPraktyka: Test kontrolera
  4. Ułóż w kolejnościWywołania mocka toHaveBeenCalled
  5. PytanieNarzędzie do testów E2E
  6. PytanieKonfiguracja E2E w NestJS
  7. Zadanie z kodemPraktyka: Test E2E
  8. Ułóż w kolejnościProces testu E2E
  9. Ułóż w kolejnościInicjalizacja app w E2E

Przydatne artykuły