Testing

import { defineConfig } from 'vitest/config';
import tsconfigPaths from 'vite-tsconfig-paths';

export default defineConfig({
  plugins: [tsconfigPaths()],
  test: {
    globals: true,
    root: './',
    include: ['**/*.e2e-spec.ts'],
  },
});

import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';

@Entity()
export class Book {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  title: string;

  @Column({ type: 'integer', default: 0 })
  stock: number;
}

// --- notifier.service.ts ---
import { Injectable } from '@nestjs/common';

@Injectable()
export class NotifierService {
  async bookCreated(title: string): Promise<void> {
    // would publish to a queue or send an e-mail in the real application
    console.log(`notify: ${title}`);
  }
}

import { Injectable, NotFoundException } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Book } from './book.entity.js';
import { NotifierService } from './notifier.service.js';

@Injectable()
export class BooksService {
  constructor(
    @InjectRepository(Book) private readonly books: Repository<Book>,
    private readonly notifier: NotifierService,
  ) {}

  findAll(): Promise<Book[]> {
    return this.books.find({ order: { id: 'ASC' } });
  }

  async findOne(id: number): Promise<Book> {
    const book = await this.books.findOneBy({ id });
    if (!book) throw new NotFoundException(`Book ${id} not found`);
    return book;
  }

  async create(title: string): Promise<Book> {
    const book = await this.books.save(this.books.create({ title }));
    await this.notifier.bookCreated(title);
    return book;
  }

  async remove(id: number): Promise<void> {
    const result = await this.books.delete(id);
    if (!result.affected) throw new NotFoundException(`Book ${id} not found`);
  }
}

// --- jwt-auth.guard.ts ---
import { CanActivate, ExecutionContext, Injectable, UnauthorizedException } from '@nestjs/common';
import type { Request } from 'express';

@Injectable()
export class JwtAuthGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    const req = context.switchToHttp().getRequest<Request>();
    if (!req.headers.authorization?.startsWith('Bearer ')) {
      throw new UnauthorizedException();
    }
    return true; // the real guard would verify the token with JwtService
  }
}

// --- admin.guard.ts ---
import { ForbiddenException } from '@nestjs/common';

@Injectable()
export class AdminGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    const role = context.switchToHttp().getRequest().headers['x-role'];
    if (role !== 'admin') throw new ForbiddenException();
    return true;
  }
}

// --- title.pipe.ts ---
import { BadRequestException, PipeTransform } from '@nestjs/common';

@Injectable()
export class TitlePipe implements PipeTransform<unknown, string> {
  transform(value: unknown): string {
    if (typeof value !== 'string' || value.trim().length === 0) {
      throw new BadRequestException('title must be a non-empty string');
    }
    return value.trim();
  }
}

// --- timing.interceptor.ts ---
import { CallHandler, NestInterceptor } from '@nestjs/common';
import { HttpAdapterHost } from '@nestjs/core';
import { Observable, tap } from 'rxjs';

@Injectable()
export class TimingInterceptor implements NestInterceptor {
  constructor(private readonly adapterHost: HttpAdapterHost) {}

  intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
    const res = context.switchToHttp().getResponse();
    const started = Date.now();
    // httpAdapter.setHeader() works on Express and on Fastify; res.setHeader() only on Express
    return next
      .handle()
      .pipe(tap(() => this.adapterHost.httpAdapter.setHeader(res, 'X-Elapsed-Ms', String(Date.now() - started))));
  }
}

// --- domain-error.filter.ts ---
import { ArgumentsHost, Catch, ExceptionFilter } from '@nestjs/common';
import type { Response } from 'express';

export class OutOfStockError extends Error {}

@Catch(OutOfStockError)
export class OutOfStockFilter implements ExceptionFilter {
  catch(error: OutOfStockError, host: ArgumentsHost) {
    host.switchToHttp().getResponse<Response>().status(409).json({ code: 'OUT_OF_STOCK', message: error.message });
  }
}

// --- request-context.service.ts ---
import { Inject, Injectable, Scope } from '@nestjs/common';
import { REQUEST } from '@nestjs/core';
import type { Request } from 'express';

@Injectable({ scope: Scope.REQUEST })
export class RequestContextService {
  constructor(@Inject(REQUEST) private readonly request: Request) {}

  get requestId(): string {
    return String(this.request.headers['x-request-id'] ?? 'none');
  }
}

// --- books.controller.ts ---
import { Body, Controller, Delete, Get, HttpCode, Param, ParseIntPipe, Post, UseFilters, UseGuards, UseInterceptors } from '@nestjs/common';

@Controller('books')
@UseInterceptors(TimingInterceptor)
@UseFilters(OutOfStockFilter)
export class BooksController {
  constructor(
    private readonly books: BooksService,
    private readonly context: RequestContextService,
  ) {}

  @Get()
  async findAll() {
    return { requestId: this.context.requestId, data: await this.books.findAll() };
  }

  @Get(':id')
  findOne(@Param('id', ParseIntPipe) id: number) {
    return this.books.findOne(id);
  }

  @Post()
  create(@Body('title', TitlePipe) title: string) {
    return this.books.create(title);
  }

  @Post(':id/borrow')
  async borrow(@Param('id', ParseIntPipe) id: number) {
    const book = await this.books.findOne(id);
    if (book.stock === 0) throw new OutOfStockError(`"${book.title}" is out of stock`);
    return book;
  }

  @Delete(':id')
  @HttpCode(204)
  @UseGuards(AdminGuard)
  async remove(@Param('id', ParseIntPipe) id: number) {
    await this.books.remove(id);
  }
}

// --- books.module.ts ---
import { Module } from '@nestjs/common';
import { APP_GUARD } from '@nestjs/core';
import { TypeOrmModule } from '@nestjs/typeorm';

@Module({
  imports: [TypeOrmModule.forFeature([Book])],
  controllers: [BooksController],
  providers: [
    BooksService,
    NotifierService,
    RequestContextService,
    // useExisting (not useClass) makes the guard a normal provider that tests can override
    { provide: APP_GUARD, useExisting: JwtAuthGuard },
    JwtAuthGuard,
  ],
  exports: [BooksService],
})
export class BooksModule {}

// --- app.module.ts ---
@Module({
  imports: [
    TypeOrmModule.forRoot({ type: 'better-sqlite3', database: ':memory:', entities: [Book], synchronize: true }),
    BooksModule,
  ],
})
export class TestingAppModule {}

it('auto-mocks every missing dependency', async () => {
  const moduleRef = await Test.createTestingModule({ controllers: [BooksController] })
    .useMocker((token) => {
      if (token === BooksService) {
        return { findAll: vi.fn().mockResolvedValue([{ id: 1, title: 'Dune', stock: 1 }]) };
      }
      if (token === RequestContextService) return { requestId: 'r-1' };
    })
    .compile();
  // static here: the request-scoped service was replaced by a plain value
  const controller = moduleRef.get(BooksController);
  expect(await controller.findAll()).toEqual({ requestId: 'r-1', data: [{ id: 1, title: 'Dune', stock: 1 }] });
});

import { vi } from 'vitest';
import { INestApplication, CanActivate, ExecutionContext } from '@nestjs/common';
import { Test } from '@nestjs/testing';
import { getRepositoryToken } from '@nestjs/typeorm';
import request from 'supertest';
import type { Repository } from 'typeorm';

class AllowAllGuard implements CanActivate {
  canActivate(_context: ExecutionContext) {
    return true;
  }
}

describe('e2e with overrides', () => {
  let app: INestApplication;
  const notifier = { bookCreated: vi.fn() };

  beforeAll(async () => {
    const moduleRef = await Test.createTestingModule({ imports: [TestingAppModule] })
      .overrideProvider(JwtAuthGuard) // the APP_GUARD uses useExisting, so this works
      .useClass(AllowAllGuard)
      .overrideProvider(NotifierService)
      .useValue(notifier)
      .overridePipe(TitlePipe)
      .useValue({ transform: (v: string) => v.toUpperCase() })
      .compile();

    app = moduleRef.createNestApplication();
    await app.init();
    const repo = app.get<Repository<Book>>(getRepositoryToken(Book));
    await repo.save([{ title: 'Dune', stock: 2 }, { title: 'Emma', stock: 0 }]);
  });
  afterAll(() => app.close());

  it('GET /books with the guard replaced, the request-scoped provider and the header', async () => {
    const res = await request(app.getHttpServer()).get('/books').set('x-request-id', 'r-42').expect(200);
    expect(res.body.requestId).toBe('r-42');
    expect(res.body.data.map((b: Book) => b.title)).toEqual(['Dune', 'Emma']);
    expect(res.headers['x-elapsed-ms']).toBeDefined();
  });

  it('POST /books uses the overridden pipe and the notifier mock', async () => {
    const res = await request(app.getHttpServer()).post('/books').send({ title: 'ulysses' }).expect(201);
    expect(res.body.title).toBe('ULYSSES');
    expect(notifier.bookCreated).toHaveBeenCalledWith('ULYSSES');
  });

  it('exception filter and parameter pipes', async () => {
    await request(app.getHttpServer()).post('/books/2/borrow').expect(409).expect({
      code: 'OUT_OF_STOCK',
      message: '"Emma" is out of stock',
    });
    await request(app.getHttpServer()).get('/books/99').expect(404);
    await request(app.getHttpServer()).get('/books/abc').expect(400);
  });
});

import { FastifyAdapter, NestFastifyApplication } from '@nestjs/platform-fastify';

let app: NestFastifyApplication;
beforeAll(async () => {
  const moduleRef = await Test.createTestingModule({ imports: [TestingAppModule] })
    .overrideProvider(JwtAuthGuard).useClass(AllowAllGuard)
    .overrideProvider(NotifierService).useValue({ bookCreated: vi.fn() })
    .overrideGuard(AdminGuard)
    .useValue({ canActivate: () => true })
    .compile();
  app = moduleRef.createNestApplication<NestFastifyApplication>(new FastifyAdapter());
  await app.init();
  await app.getHttpAdapter().getInstance().ready();
});
afterAll(() => app.close());

it('creates, then deletes without the x-role header', async () => {
  const created = await app.inject({ method: 'POST', url: '/books', payload: { title: 'Dune' } });
  expect(created.statusCode).toBe(201);
  expect(created.headers['x-elapsed-ms']).toBeDefined();
  const { id } = created.json();
  expect((await app.inject({ method: 'DELETE', url: `/books/${id}` })).statusCode).toBe(204);
  expect((await app.inject({ method: 'DELETE', url: `/books/${id}` })).statusCode).toBe(404);
});

const moduleRef = await Test.createTestingModule({
  providers: [
    { provide: ConfigService, useValue: { get: () => 'x' } },
    { provide: NotifierService, useClass: NotifierService },
  ],
})
  .overrideProvider(NotifierService)
  .useFactory({
    factory: (config: ConfigService) => ({ bookCreated: async () => config.get('x') }),
    inject: [ConfigService],
  })
  .compile();

@Module({
  providers: [{ provide: BooksService, useValue: { findAll: async () => [] } }],
  exports: [BooksService],
})
class FakeBooksModule {}

// replace a whole module
const moduleRef = await Test.createTestingModule({ imports: [BooksModule] })
  .overrideModule(BooksModule)
  .useModule(FakeBooksModule)
  .compile();
expect(await moduleRef.get(BooksService).findAll()).toEqual([]);

// replace an interceptor and a filter
const app = (
  await Test.createTestingModule({ imports: [TestingAppModule] })
    .overrideProvider(JwtAuthGuard).useClass(AllowAllGuard)
    .overrideInterceptor(TimingInterceptor).useValue({ intercept: (_: unknown, next: { handle(): unknown }) => next.handle() })
    .overrideFilter(OutOfStockFilter).useValue({ catch: (_e: unknown, host: ExecutionContext) => host.switchToHttp().getResponse().status(418).end() })
    .compile()
).createNestApplication();

providers: [
  {
    provide: APP_GUARD,
    useExisting: JwtAuthGuard,
    // ^^^^^^^^ useExisting instead of useClass
  },
  JwtAuthGuard,
],

describe('without the override, the global guard blocks', () => {
  let app: INestApplication;
  beforeAll(async () => {
    const moduleRef = await Test.createTestingModule({ imports: [TestingAppModule] })
      .overrideProvider(NotifierService).useValue({ bookCreated: vi.fn() })
      .compile();
    app = moduleRef.createNestApplication();
    await app.init();
  });
  afterAll(() => app.close());

  it('401 without a token', () => request(app.getHttpServer()).get('/books').expect(401));
  it('200 with one', () =>
    request(app.getHttpServer()).get('/books').set('Authorization', 'Bearer x').expect(200));
});

it('resolve() gives a fresh instance per context id; get() throws', async () => {
  const moduleRef = await Test.createTestingModule({
    providers: [RequestContextService, { provide: 'REQUEST', useValue: {} }],
  })
    .overrideProvider(RequestContextService)
    .useClass(class extends RequestContextService {
      constructor() {
        super({ headers: { 'x-request-id': 'abc' } } as never);
      }
    })
    .compile();
  const a = await moduleRef.resolve(RequestContextService);
  const b = await moduleRef.resolve(RequestContextService);
  expect(a).not.toBe(b);
  expect(a.requestId).toBe('abc');
  expect(() => moduleRef.get(RequestContextService)).toThrow();
});

import { ContextIdFactory } from '@nestjs/core';

it('retrieves the request-scoped instance of a tested request with a fixed context id', async () => {
  const contextId = ContextIdFactory.create();
  const spy = vi.spyOn(ContextIdFactory, 'getByRequest').mockImplementation(() => contextId);
  await request(app.getHttpServer()).get('/books').set('x-request-id', 'r-7').expect(200);
  const ctx = await moduleRef.resolve(RequestContextService, contextId);
  expect(ctx.requestId).toBe('r-7');
  spy.mockRestore(); // restore it: the spy is global to the process
});

import request from 'supertest';
import { Test } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';

describe('Books (e2e)', () => {
  let app: INestApplication;

  beforeAll(async () => {
    const moduleRef = await Test.createTestingModule({ imports: [TestingAppModule] }).compile();
    app = moduleRef.createNestApplication();
    await app.init();
  });

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

  it('GET /books', () => request(app.getHttpServer()).get('/books').set('Authorization', 'Bearer x').expect(200));
});

it('global pipes must be repeated in the test', async () => {
  const moduleRef = await Test.createTestingModule({ imports: [BooksOnlyModule] })
    .overrideProvider(AdminGuard).useValue({ canActivate: () => true })
    .compile();
  const app = moduleRef.createNestApplication();
  app.useGlobalPipes(new ValidationPipe({ whitelist: true })); // what main.ts does
  await app.init();
  await request(app.getHttpServer()).get('/books/abc').expect(400);
  await app.close();
});

import { defineConfig } from 'vitest/config';
import swc from 'unplugin-swc';

export default defineConfig({
  test: {
    globals: true,
    root: './',
    include: ['**/*.spec.ts', '**/*.e2e-spec.ts'],
    coverage: {
      provider: 'v8',
      include: ['src/**/*.ts'],
      exclude: ['**/*.module.ts', 'src/main.ts'],
      reporter: ['text-summary', 'lcov'],
      thresholds: { statements: 90, branches: 80 },
    },
  },
  plugins: [swc.vite({ module: { type: 'es6' } })],
});

Statements   : 93.87% ( 46/49 )
Branches     : 83.33% ( 15/18 )
Functions    : 96% ( 24/25 )
Lines        : 93.33% ( 42/45 )