Kurs NestJS · Moduł 6: Obsługa błędów i monitoring
Graceful Shutdown i Recovery - godny odwrót legionów
W tej lekcji9
Wdrażasz nową wersję. Kubernetes wysyła sygnał zamknięcia, proces znika w pół sekundy, a razem z nim trzy płatności w połowie zapisu. Nawet najpotężniejsze Imperium Rzymskie musiało umieć wycofywać wojska w porządku: gdy Cezar nakazywał odwrót, każdy centurion wiedział, jak zabezpieczyć sprzęt i ewakuować rannych. W NestJS graceful shutdown to ta sama sztuka - zamykanie aplikacji bez chaosu.
Czym jest Graceful Shutdown?
Gdy aplikacja dostaje sygnał zamknięcia (np. SIGTERM podczas deploymentu), musi:
- dokończyć aktywne żądania - nie porzucaj legionistów w trakcie walki,
- zamknąć połączenia z bazą danych - zabezpiecz archiwa Imperium,
- wyczyścić timery i interwały - wycofaj zwiadowców,
- rozłączyć klientów WebSocket - odwołaj posłańców,
- zapisać stan aplikacji - sporządź raport z pola bitwy.
Lifecycle Hooks w NestJS
NestJS woła trzy hooki w stałej kolejności. onModuleDestroy() rusza po sygnale, gdy serwer HTTP wciąż obsługuje ruch. beforeApplicationShutdown(signal) dostaje nazwę sygnału; po nim NestJS zamyka serwer HTTP i czeka na trwające żądania. onApplicationShutdown(signal) przychodzi na końcu, gdy serwer już milczy:
// graceful-shutdown.service.ts
import {
Injectable,
OnModuleDestroy,
BeforeApplicationShutdown,
OnApplicationShutdown,
Logger
} from '@nestjs/common';
@Injectable()
export class LegionShutdownService
implements OnModuleDestroy, BeforeApplicationShutdown, OnApplicationShutdown
{
private readonly logger = new Logger(LegionShutdownService.name);
private activeOperations = 0;
// Operacje w tle (importy, zadania z kolejki) zgłaszają start i koniec
operationStarted() { this.activeOperations++; }
operationFinished() { this.activeOperations--; }
// 1. OnModuleDestroy - pierwszy sygnał do odwrotu
// Serwer HTTP nadal przyjmuje żądania
async onModuleDestroy() {
this.logger.warn('OnModuleDestroy: Rozpoczynam procedurę odwrotu legionów!');
// Zatrzymaj to, czego żądania już nie potrzebują (timery, subskrypcje)
}
// 2. BeforeApplicationShutdown - przygotowanie do zamknięcia
// Otrzymuje sygnał (SIGTERM, SIGINT) jako argument
async beforeApplicationShutdown(signal?: string) {
this.logger.warn(
`BeforeApplicationShutdown: Sygnał ${signal} - czekam na dokończenie operacji`
);
// Czekaj na operacje w tle, ale najwyżej 8 sekund
const deadline = Date.now() + 8000;
while (this.activeOperations > 0 && Date.now() < deadline) {
this.logger.log(`Pozostało ${this.activeOperations} aktywnych operacji...`);
await new Promise(resolve => setTimeout(resolve, 1000));
}
}
// 3. OnApplicationShutdown - finalne zamknięcie
// Serwer HTTP jest już zamknięty
async onApplicationShutdown(signal?: string) {
this.logger.warn(`OnApplicationShutdown: Sygnał ${signal} - zamykam bramy Imperium!`);
// Ostateczne czyszczenie zasobów
}
}Na żądania HTTP NestJS czeka sam, więc licznik pilnuje tylko pracy w tle. Limit 8 sekund nie jest przypadkowy: docker stop po 10 sekundach wysyła SIGKILL, którego nie da się obsłużyć.
Aktywacja Shutdown Hooks
Domyślnie NestJS nie nasłuchuje na sygnały systemowe, więc bez jednej linijki w main.ts żaden z tych hooków nie ruszy po SIGTERM:
// main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { Logger } from '@nestjs/common';
async function bootstrap() {
const app = await NestFactory.create(AppModule);
const logger = new Logger('Bootstrap');
// Aktywuj nasłuchiwanie na sygnały SIGTERM i SIGINT
app.enableShutdownHooks();
// SIGTERM - wysyłany przez Docker/Kubernetes przy zatrzymywaniu
// SIGINT - wysyłany przez Ctrl+C w terminalu
const port = process.env.PORT || 3000;
await app.listen(port);
logger.log(`Imperium nasłuchuje na porcie ${port}`);
}
bootstrap();enableShutdownHooks() wołamy przed listen(). Na Windowsie SIGTERM nie działa wcale, działa za to SIGINT.
Bezpieczne zamykanie połączeń z bazą danych
Bazę zamykamy dopiero w onApplicationShutdown, bo wcześniej serwer HTTP wciąż obsługuje żądania, które z niej korzystają:
// database-shutdown.service.ts
import { Injectable, OnApplicationShutdown, Logger } from '@nestjs/common';
import { InjectConnection } from '@nestjs/mongoose';
import { Connection } from 'mongoose';
@Injectable()
export class DatabaseShutdownService implements OnApplicationShutdown {
private readonly logger = new Logger(DatabaseShutdownService.name);
constructor(
@InjectConnection() private readonly connection: Connection,
) {}
async onApplicationShutdown() {
this.logger.warn('Zamykam połączenie z bazą danych Imperium...');
try {
// Mongoose - zamknij połączenie gracefully
await this.connection.close();
this.logger.log('Archiwum Imperium zabezpieczone - połączenie zamknięte.');
} catch (error) {
this.logger.error('Błąd przy zamykaniu bazy danych:', error.message);
}
}
}Pierwsza wersja tej lekcji zamykała połączenie w onModuleDestroy - za wcześnie, bo żądania obsługiwane w tej chwili traciły bazę. MongooseModule i TypeOrmModule zamykają swoje połączenia same, właśnie w onApplicationShutdown; taki serwis piszesz dla połączeń tworzonych ręcznie.
Czyszczenie timerów i interwałów
Niezamknięte timery mogą blokować zamknięcie procesu Node.js, a ich sprzątanie to dobre zadanie dla onModuleDestroy:
// scheduler-cleanup.service.ts
import { Injectable, OnModuleDestroy, Logger } from '@nestjs/common';
@Injectable()
export class SchedulerCleanupService implements OnModuleDestroy {
private readonly logger = new Logger(SchedulerCleanupService.name);
private intervals: NodeJS.Timeout[] = [];
private timeouts: NodeJS.Timeout[] = [];
// Rejestruj interwały przy tworzeniu
registerInterval(callback: () => void, ms: number): NodeJS.Timeout {
const interval = setInterval(callback, ms);
this.intervals.push(interval);
return interval;
}
registerTimeout(callback: () => void, ms: number): NodeJS.Timeout {
const timeout = setTimeout(callback, ms);
this.timeouts.push(timeout);
return timeout;
}
async onModuleDestroy() {
this.logger.warn('Wycofuję zwiadowców - czyszczę timery i interwały...');
this.intervals.forEach(interval => clearInterval(interval));
this.logger.log(`Wyczyszczono ${this.intervals.length} interwałów`);
this.timeouts.forEach(timeout => clearTimeout(timeout));
this.logger.log(`Wyczyszczono ${this.timeouts.length} timeoutów`);
this.intervals = [];
this.timeouts = [];
}
}Serwis zapamiętuje każdy timer, który utworzył, i przy odwrocie czyści wszystkie naraz.
Health Check Recovery Pattern
Gdy aplikacja przeżywa problemy, potrzebny jest mechanizm recovery - automatycznego powrotu do zdrowia:
// health-recovery.service.ts
import { Injectable, Logger } from '@nestjs/common';
@Injectable()
export class HealthRecoveryService {
private readonly logger = new Logger(HealthRecoveryService.name);
private isHealthy = true;
private failureCount = 0;
private readonly MAX_FAILURES = 3;
reportFailure(component: string) {
this.failureCount++;
this.logger.warn(
`Awaria komponentu ${component}! Licznik: ${this.failureCount}/${this.MAX_FAILURES}`
);
if (this.failureCount >= this.MAX_FAILURES) {
this.isHealthy = false;
this.logger.error('Imperium w stanie krytycznym! Uruchamiam procedurę recovery...');
this.startRecovery();
}
}
private async startRecovery() {
this.logger.warn('Procedura recovery: próba przywrócenia usług...');
try {
await this.reconnectDatabase();
await this.clearCache();
this.failureCount = 0;
this.isHealthy = true;
this.logger.log('Recovery zakończony sukcesem!');
} catch (error) {
this.logger.error('Recovery nie powiódł się:', error.message);
}
}
private async reconnectDatabase() {
this.logger.log('Ponowne łączenie z archiwum...');
await new Promise(resolve => setTimeout(resolve, 1000));
}
private async clearCache() {
this.logger.log('Czyszczenie skrytek cache...');
await new Promise(resolve => setTimeout(resolve, 500));
}
getHealthStatus() {
return {
healthy: this.isHealthy,
failureCount: this.failureCount,
maxFailures: this.MAX_FAILURES,
};
}
}Po trzech awariach serwis oznacza się jako chory i próbuje się naprawić. startRecovery() działa w tle, bez await, więc zgłaszający awarię nie czeka.
Circuit Breaker Pattern - zabezpieczenie murów Imperium
Circuit Breaker chroni aplikację przed kaskadowymi awariami - jak zamykanie bram miasta, gdy wróg atakuje:
// circuit-breaker.service.ts
import { Injectable, Logger } from '@nestjs/common';
enum CircuitState {
CLOSED = 'CLOSED', // Wszystko działa - bramy otwarte
OPEN = 'OPEN', // Awaria - bramy zamknięte
HALF_OPEN = 'HALF_OPEN' // Testujemy - bramy uchylone
}
@Injectable()
export class CircuitBreakerService {
private readonly logger = new Logger(CircuitBreakerService.name);
private state = CircuitState.CLOSED;
private failureCount = 0;
private lastFailureTime = 0;
private readonly FAILURE_THRESHOLD = 5;
private readonly RECOVERY_TIMEOUT = 30000; // 30 sekund
async execute<T>(operation: () => Promise<T>): Promise<T> {
if (this.state === CircuitState.OPEN) {
if (Date.now() - this.lastFailureTime > this.RECOVERY_TIMEOUT) {
this.state = CircuitState.HALF_OPEN;
this.logger.warn('Circuit HALF_OPEN - wysyłamy posłańca na próbę...');
} else {
throw new Error('Circuit OPEN - bramy Imperium zamknięte!');
}
}
try {
const result = await operation();
if (this.state === CircuitState.HALF_OPEN) {
this.state = CircuitState.CLOSED;
this.logger.log('Circuit CLOSED - bramy ponownie otwarte!');
}
this.failureCount = 0; // liczymy tylko awarie z rzędu
return result;
} catch (error) {
this.failureCount++;
this.lastFailureTime = Date.now();
if (this.failureCount >= this.FAILURE_THRESHOLD) {
this.state = CircuitState.OPEN;
this.logger.error(
`Circuit OPEN po ${this.failureCount} awariach - zamykam bramy!`
);
}
throw error;
}
}
getState() {
return {
state: this.state,
failureCount: this.failureCount,
threshold: this.FAILURE_THRESHOLD,
};
}
}Po pięciu awariach z rzędu bramy się zamykają i żądania od razu dostają błąd, zamiast czekać na martwy serwis. Po 30 sekundach próbne wywołanie decyduje, czy wracamy do CLOSED. Wcześniej licznik nie zerował się po sukcesie, więc pięć awarii rozrzuconych po tygodniu też otwierało obwód.
Obsługa sygnałów SIGTERM i SIGINT
Warto wiedzieć, skąd przychodzą sygnały:
- SIGTERM - wysyła go
docker stop(SIGKILL po 10 s) i Kubernetes (domyślnie po 30 s), - SIGINT - Ctrl+C w terminalu; z
enableShutdownHooks()też uruchamia pełny odwrót.
// main.ts - własne reakcje na sygnały, obok enableShutdownHooks()
process.once('SIGTERM', () => {
console.log('Otrzymano SIGTERM - rozpoczynam graceful shutdown...');
});
process.once('SIGINT', () => {
console.log('Otrzymano SIGINT - rozpoczynam graceful shutdown...');
});
// Złapanie nieobsłużonych wyjątków
process.on('uncaughtException', (error) => {
console.error('Nieobsłużony wyjątek:', error);
process.exit(1);
});
process.on('unhandledRejection', (reason) => {
console.error('Nieobsłużona obietnica:', reason);
process.kill(process.pid, 'SIGTERM'); // uruchom odwrót zamiast udawać, że nic się nie stało
});once ma znaczenie: stały listener SIGTERM wyłącza domyślne wyjście Node.js, a NestJS po sprzątaniu ponawia sygnał, żeby zakończyć proces - z listenerem on aplikacja potrafi zawisnąć. Samo nasłuchiwanie unhandledRejection też wyłącza domyślny crash, więc świadomie uruchamiamy odwrót.
Sprawdź odwrót, zanim nadejdzie
Recovery, którego nie przetestowałeś, jest tylko nadzieją. W testach Jest describe grupuje przypadki, it opisuje jeden, a expect(result).toEqual(expected) porównuje wynik z oczekiwanym. beforeEach uruchamia się przed każdym testem, beforeAll raz przed wszystkimi w bloku. Od NestJS 12 nowe projekty dostają Vitest z tym samym API, tylko zamiast jest.fn() piszesz vi.fn().
Testować będziemy serwis, który przy braku legionu rzuca HttpException z obiektem odpowiedzi i kodem statusu:
// legions.service.ts
@Injectable()
export class LegionsService {
constructor(
@InjectRepository(Legion) private readonly repo: Repository<Legion>,
) {}
async findOne(id: number) {
const legion = await this.repo.findOne({ where: { id } });
if (!legion) {
throw new HttpException(
{ message: 'Legion not found', error: 'Not Found' },
HttpStatus.NOT_FOUND);
}
return legion;
}
}W teście jednostkowym prawdziwe repozytorium zastępujemy atrapą: getRepositoryToken(Legion) to token, pod którym @InjectRepository szuka repozytorium, a jest.fn() tworzy funkcję, której wynik ustalamy sami:
// legions.service.spec.ts
describe('LegionsService', () => {
let service: LegionsService;
let repo: { findOne: jest.Mock; save: jest.Mock };
beforeEach(async () => {
repo = { findOne: jest.fn(), save: jest.fn() };
const moduleRef = await Test.createTestingModule({
providers: [
LegionsService,
{ provide: getRepositoryToken(Legion), useValue: repo },
],
}).compile();
service = moduleRef.get(LegionsService);
});
it('zwraca legion o podanym id', async () => {
// Arrange
const legion = { id: 9, name: 'Legio IX Hispana' };
repo.findOne.mockResolvedValue(legion);
// Act
const result = await service.findOne(9);
// Assert
expect(result).toEqual(legion);
});
it('rzuca HttpException, gdy legionu nie ma', async () => {
repo.findOne.mockResolvedValue(null);
await expect(service.findOne(99)).rejects.toThrow(HttpException);
});
});Komentarze pokazują wzorzec AAA: Arrange przygotowuje dane i atrapy, Act wykonuje operację, Assert sprawdza wynik. beforeEach buduje świeży moduł przed każdym testem, więc atrapy nie przenoszą stanu między przypadkami.
Test end-to-end uruchamia całą aplikację i wysyła prawdziwe żądanie przez supertest:
// test/health.e2e-spec.ts
import request from 'supertest';
import { Test } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import { AppModule } from '../src/app.module';
describe('Health (e2e)', () => {
let app: INestApplication;
beforeAll(async () => {
const moduleFixture = await Test.createTestingModule({
imports: [AppModule],
}).compile();
app = moduleFixture.createNestApplication();
await app.init();
});
it('GET /health odpowiada 200', () => {
return request(app.getHttpServer()).get('/health').expect(200);
});
afterAll(async () => {
await app.close();
});
});Aplikację budujemy raz, w beforeAll, bo to kosztowne. app.close() w afterAll uruchamia te same hooki zamykania, więc test sprawdza też odwrót.
Filtr wyjątków z pierwszej lekcji modułu testujemy bez serwera, podając atrapę ArgumentsHost:
// legion-http-exception.filter.spec.ts
it('should catch NotFoundException', () => {
const filter = new LegionHttpExceptionFilter();
const mockRes = { status: jest.fn().mockReturnThis(), json: jest.fn() };
const mockReq = { url: '/legions/99' };
const mockHost = {
switchToHttp: () => ({
getResponse: () => mockRes,
getRequest: () => mockReq,
}),
} as unknown as ArgumentsHost;
filter.catch(new NotFoundException(), mockHost);
expect(mockRes.status).toHaveBeenCalledWith(404);
});mockReturnThis() pozwala na łańcuch response.status(404).json(...), a toHaveBeenCalledWith(404) sprawdza, z jakim argumentem wywołano atrapę.
Jest jeszcze haczyk: filtr zarejestrowany przez app.useGlobalFilters() w main.ts nie działa w teście e2e, bo test nie uruchamia main.ts. Rejestracja w module z tokenem APP_FILTER działa wszędzie i pozwala wstrzykiwać zależności:
// app.module.ts - filtr globalny z Dependency Injection
@Module({
providers: [
{ provide: APP_FILTER, useClass: LegionHttpExceptionFilter },
],
})
export class AppModule {}Raport pokrycia kodu dostaniesz przez npm run test -- --coverage albo gotowy skrypt test:cov.
Polecam Ci prosty nawyk: każdy hook zamykania i każdy filtr niech ma choć jeden test, bo awarie zdarzają się rzadko i nigdy wtedy, gdy masz czas na ręczne sprawdzanie. W projekcie kończącym moduł połączysz filtry, logi, health checki i testy w jeden system monitorowania.
Pamiętaj: szczęście sprzyja przygotowanym - aplikacja, która umie się zamknąć i podnieść po awarii, jest jak legion gotowy na każdą ewentualność.
Kod do tej lekcji: src/graceful-shutdown.service.ts
// Graceful Shutdown i Recovery - Godny Odwrot Legionow
import { Injectable, OnModuleDestroy, BeforeApplicationShutdown, Logger } from '@nestjs/common';
// ===========================================
// 1. Serwis Graceful Shutdown
// ===========================================
@Injectable()
export class LegionShutdownService
implements OnModuleDestroy, BeforeApplicationShutdown
{
private readonly logger = new Logger(LegionShutdownService.name);
private activeRequests = 0;
private intervals: any[] = [];
// Sledz aktywne zadania
incrementRequests() { this.activeRequests++; }
decrementRequests() { this.activeRequests--; }
// Rejestruj interwaly do czyszczenia
registerInterval(interval: any) {
this.intervals.push(interval);
}
// OnModuleDestroy - pierwszy krok odwrotu
async onModuleDestroy() {
this.logger.warn('OnModuleDestroy: Rozpoczynam procedure odwrotu!');
// Wyczysc interwaly
this.intervals.forEach(i => clearInterval(i));
this.logger.log('Wyczyszczono ' + this.intervals.length + ' interwalow');
this.intervals = [];
}
// BeforeApplicationShutdown - czekaj na aktywne operacje
async beforeApplicationShutdown(signal?: string) {
this.logger.warn('BeforeApplicationShutdown: Sygnal ' + signal);
// Czekaj na zakonczenie aktywnych zadan
let waitCount = 0;
while (this.activeRequests > 0 && waitCount < 10) {
this.logger.log('Aktywne operacje: ' + this.activeRequests);
await new Promise(r => setTimeout(r, 1000));
waitCount++;
}
this.logger.log('Wszystkie operacje zakonczone - bramy zamkniete');
}
}
// ===========================================
// 2. Circuit Breaker Pattern
// ===========================================
enum CircuitState {
CLOSED = 'CLOSED',
OPEN = 'OPEN',
HALF_OPEN = 'HALF_OPEN'
}
class CircuitBreaker {
private state = CircuitState.CLOSED;
private failures = 0;
private lastFailure = 0;
private readonly threshold = 5;
private readonly timeout = 30000;
async execute<T>(operation: () => Promise<T>): Promise<T> {
if (this.state === CircuitState.OPEN) {
if (Date.now() - this.lastFailure > this.timeout) {
this.state = CircuitState.HALF_OPEN;
} else {
throw new Error('Circuit OPEN - bramy zamkniete!');
}
}
try {
const result = await operation();
if (this.state === CircuitState.HALF_OPEN) {
this.state = CircuitState.CLOSED;
this.failures = 0;
}
return result;
} catch (error) {
this.failures++;
this.lastFailure = Date.now();
if (this.failures >= this.threshold) {
this.state = CircuitState.OPEN;
}
throw error;
}
}
getState() {
return { state: this.state, failures: this.failures };
}
}
// ===========================================
// 3. Demonstracja
// ===========================================
const service = new LegionShutdownService();
// Symulacja aktywnych zadan
service.incrementRequests();
service.incrementRequests();
console.log('=== Graceful Shutdown ===');
console.log('Aktywne zadania przed shutdown: 2');
service.decrementRequests();
service.decrementRequests();
console.log('Aktywne zadania po zakonczeniu: 0');
console.log('');
// Circuit Breaker
const breaker = new CircuitBreaker();
console.log('=== Circuit Breaker ===');
console.log('Stan:', breaker.getState().state);
console.log('');
console.log('Hooki: OnModuleDestroy -> BeforeApplicationShutdown -> OnApplicationShutdown');
console.log('Sygnaly: SIGTERM (Docker), SIGINT (Ctrl+C)');
console.log('app.enableShutdownHooks() - aktywacja w main.ts');
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. Co robi hook OnModuleDestroy w NestJS?
2. Jak aktywować nasłuchiwanie na sygnały systemowe (SIGTERM/SIGINT) w NestJS?
To 2 z 5 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Uzupełnij serwis implementujący OnModuleDestroy i OnApplicationShutdown: w onModuleDestroy() wyczyść interwały (clearInterval), a w onApplicationShutdown(), gdy serwer HTTP nie przyjmuje już żądań, zamknij połączenie z bazą danych (this.connection.close())
- Układanie w pionie
Uporządkuj hooki lifecycle NestJS w kolejności wywoływania przy zamykaniu aplikacji
- Klikanie w kolejności
Ułóż kod aktywacji shutdown hooks w main.ts
- Edytor kodu
Uzupełnij E2E test, który tworzy NestApplication z Test.createTestingModule, inicjalizuje ją (app.init()) i używa request(app.getHttpServer()).get('/health').expect(200)
- Układanie w poziomie
Ułóż składnię asercji Jest od oczekiwanej wartości do matchera
- Edytor kodu
Uzupełnij test it('should catch NotFoundException'), który tworzy mock response i request, wywołuje filter.catch(new NotFoundException(), mockHost) i sprawdza czy response.status został wywołany z 404
- Układanie w pionie
Uporządkuj etapy wzorca AAA (Arrange-Act-Assert) stosowanego w testach
- Klikanie w kolejności
Ułóż kroki rejestracji globalnego Exception Filter w main.ts
- Układanie w poziomie
Ułóż składnię rejestracji globalnego filtra z Dependency Injection w module
- Układanie w pionie
Uporządkuj kroki konfiguracji modułu z Exception Filters od tworzenia do uruchomienia
- Układanie w poziomie
Ułóż składnię rzucania HttpException z obiektem odpowiedzi i kodem statusu
- Układanie w poziomie
Ułóż składnię tworzenia mock repository z jest.fn() od provide do useValue
Zadania po tej lekcji
- PytanieLifecycle hook OnModuleDestroy
- PytanieAktywacja Shutdown Hooks
- Zadanie z kodemImplementacja OnModuleDestroy i OnApplicationShutdown
- Ułóż w kolejnościKolejność lifecycle hooks przy shutdown
- Kliknij w kolejnościAktywacja shutdown hooks w main.ts
- PytanieCircuit Breaker Pattern
- Zadanie z kodemE2E test z supertest
- Ułóż w kolejnościAsercje expect() w Jest
- PytaniebeforeEach vs beforeAll
- Zadanie z kodemTest Exception Filter
- Ułóż w kolejnościWzorzec Arrange-Act-Assert
- PytaniePokrycie kodu testami
- Kliknij w kolejnościRejestracja globalnego Exception Filter
- Ułóż w kolejnościGlobalny filtr z DI
- Ułóż w kolejnościKolejność konfiguracji modułu z Exception Filters
- Ułóż w kolejnościSkładnia throw new HttpException
- Ułóż w kolejnościSkładnia mockowania w Jest