1---
2title: Use Supertest for E2E Testing
3impact: HIGH
4impactDescription: Validates the full request/response cycle
5tags: testing, e2e, supertest, integration
6---
7 
8## Use Supertest for E2E Testing
9 
10End-to-end tests use Supertest to make real HTTP requests against your NestJS application. They test the full stack including middleware, guards, pipes, and interceptors. E2E tests catch integration issues that unit tests miss.
11 
12**Incorrect (no proper E2E setup or teardown):**
13 
14```typescript
15// Only unit test controllers
16describe('UsersController', () => {
17  it('should return users', async () => {
18    const service = { findAll: jest.fn().mockResolvedValue([]) };
19    const controller = new UsersController(service as any);
20 
21    const result = await controller.findAll();
22 
23    expect(result).toEqual([]);
24    // Doesn't test: routes, guards, pipes, serialization
25  });
26});
27 
28// E2E tests without proper setup/teardown
29describe('Users API', () => {
30  it('should create user', async () => {
31    const app = await NestFactory.create(AppModule);
32    // No proper initialization
33    // No cleanup after test
34    // Hits real database
35  });
36});
37```
38 
39**Correct (proper E2E setup with Supertest):**
40 
41```typescript
42// Proper E2E test setup
43import { Test, TestingModule } from '@nestjs/testing';
44import { INestApplication, ValidationPipe } from '@nestjs/common';
45import * as request from 'supertest';
46import { AppModule } from '../src/app.module';
47 
48describe('UsersController (e2e)', () => {
49  let app: INestApplication;
50 
51  beforeAll(async () => {
52    const moduleFixture: TestingModule = await Test.createTestingModule({
53      imports: [AppModule],
54    }).compile();
55 
56    app = moduleFixture.createNestApplication();
57 
58    // Apply same config as production
59    app.useGlobalPipes(
60      new ValidationPipe({
61        whitelist: true,
62        transform: true,
63        forbidNonWhitelisted: true,
64      }),
65    );
66 
67    await app.init();
68  });
69 
70  afterAll(async () => {
71    await app.close();
72  });
73 
74  describe('/users (POST)', () => {
75    it('should create a user', () => {
76      return request(app.getHttpServer())
77        .post('/users')
78        .send({ name: 'John', email: '[email protected]' })
79        .expect(201)
80        .expect((res) => {
81          expect(res.body).toHaveProperty('id');
82          expect(res.body.name).toBe('John');
83          expect(res.body.email).toBe('[email protected]');
84        });
85    });
86 
87    it('should return 400 for invalid email', () => {
88      return request(app.getHttpServer())
89        .post('/users')
90        .send({ name: 'John', email: 'invalid-email' })
91        .expect(400)
92        .expect((res) => {
93          expect(res.body.message).toContain('email');
94        });
95    });
96  });
97 
98  describe('/users/:id (GET)', () => {
99    it('should return 404 for non-existent user', () => {
100      return request(app.getHttpServer())
101        .get('/users/non-existent-id')
102        .expect(404);
103    });
104  });
105});
106 
107// Testing with authentication
108describe('Protected Routes (e2e)', () => {
109  let app: INestApplication;
110  let authToken: string;
111 
112  beforeAll(async () => {
113    const moduleFixture = await Test.createTestingModule({
114      imports: [AppModule],
115    }).compile();
116 
117    app = moduleFixture.createNestApplication();
118    app.useGlobalPipes(new ValidationPipe({ whitelist: true }));
119    await app.init();
120 
121    // Get auth token
122    const loginResponse = await request(app.getHttpServer())
123      .post('/auth/login')
124      .send({ email: '[email protected]', password: 'password' });
125 
126    authToken = loginResponse.body.accessToken;
127  });
128 
129  it('should return 401 without token', () => {
130    return request(app.getHttpServer())
131      .get('/users/me')
132      .expect(401);
133  });
134 
135  it('should return user profile with valid token', () => {
136    return request(app.getHttpServer())
137      .get('/users/me')
138      .set('Authorization', `Bearer ${authToken}`)
139      .expect(200)
140      .expect((res) => {
141        expect(res.body.email).toBe('[email protected]');
142      });
143  });
144});
145 
146// Database isolation for E2E tests
147describe('Orders API (e2e)', () => {
148  let app: INestApplication;
149  let dataSource: DataSource;
150 
151  beforeAll(async () => {
152    const moduleFixture = await Test.createTestingModule({
153      imports: [
154        ConfigModule.forRoot({
155          envFilePath: '.env.test', // Test database config
156        }),
157        AppModule,
158      ],
159    }).compile();
160 
161    app = moduleFixture.createNestApplication();
162    dataSource = moduleFixture.get(DataSource);
163    await app.init();
164  });
165 
166  beforeEach(async () => {
167    // Clean database between tests
168    await dataSource.synchronize(true);
169  });
170 
171  afterAll(async () => {
172    await dataSource.destroy();
173    await app.close();
174  });
175});
176```
177 
178Reference: [NestJS E2E Testing](https://docs.nestjs.com/fundamentals/testing#end-to-end-testing)
179