E2E testing with supertest in NestJS - Performance & Optimization

Performance: E2E testing with supertest

MEDIUM IMPACT

This affects the speed and resource usage of automated end-to-end tests, impacting test suite run time and developer feedback loops.

Running E2E tests for API endpoints in NestJS using Supertest

NestJS

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

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

test('GET /users returns 200', async () => {
  await request(app.getHttpServer()).get('/users').expect(200);
});

Starting the app once before all tests and closing it after reduces server startup overhead and speeds up the entire test suite.

📈 Performance GainReduces server startups from N times to 1, cutting test suite runtime significantly

Running E2E tests for API endpoints in NestJS using Supertest

NestJS

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

test('GET /users returns 200', async () => {
  await request(app.getHttpServer()).get('/users').expect(200);
});

Starting a new NestJS app instance before each test causes repeated server startups, increasing total test time and CPU usage.

📉 Performance CostBlocks test execution for multiple seconds per test due to repeated app initialization

Performance Comparison

Pattern	Server Startups	Network Requests	Test Suite Runtime	Verdict
Start app before each test	N times	N requests	High (slow)	[X] Bad
Start app once before all tests	1 time	N requests	Low (fast)	[OK] Good

Rendering Pipeline

E2E tests with Supertest do not affect browser rendering but impact Node.js server startup and network request handling during tests.

→Server Initialization

→Network Request Handling

→Test Execution

⚠️ BottleneckServer Initialization (starting NestJS app instance)

Optimization Tips

1Reuse the NestJS app instance across multiple tests to avoid repeated startups.

2Close the app instance after all tests to free resources.

3Avoid starting the server before each individual test to reduce total runtime.

Performance Quiz - 3 Questions

What is the main performance issue when starting a NestJS app before each E2E test?

A Network requests become slower

B Tests fail due to app state sharing

C Repeated server startups increase total test runtime

D Browser rendering is blocked

DevTools: Node.js Profiler or Jest --runInBand with --detectOpenHandles

How to check: Run tests with profiling enabled or in single-thread mode to measure server startup time and open handles.

What to look for: Look for repeated server initialization logs and long delays before tests start running.

Practice

1. What is the main purpose of using supertest in NestJS E2E testing?

easy

A. To style the frontend components

B. To mock database calls inside unit tests

C. To compile TypeScript code before running tests

D. To simulate HTTP requests and test the whole app behavior

Solution

1. Step 1: Understand E2E testing goal

   E2E testing checks the entire app by simulating real HTTP requests and responses.

2. Step 2: Role of supertest in NestJS

   Supertest helps send HTTP requests to the running NestJS app and verify responses, enabling full app behavior testing.

3. Final Answer:

   To simulate HTTP requests and test the whole app behavior -> Option D

4. Quick Check:

   E2E testing = simulate HTTP requests [OK]

Hint: Remember: supertest sends HTTP requests to test app end-to-end [OK]

Common Mistakes:

• Confusing supertest with mocking libraries
• Thinking supertest is for styling or compiling
• Using supertest only for unit tests

2. Which of the following is the correct way to import and use supertest in a NestJS E2E test file?

easy

A. const request = import('supertest');

B. import * as request from 'supertest';

C. import request from 'supertest';

D. const request = require('supertest');

Solution

1. Step 1: Check ES module import style

   In modern NestJS with ES modules, import * as request from 'supertest'; is the correct syntax to import all exports as an object.

2. Step 2: Identify incorrect options

   const request = require('supertest'); uses CommonJS require, which is discouraged in ES module projects. import request from 'supertest'; assumes default export which supertest does not have. const request = import('supertest'); is invalid syntax.

3. Final Answer:

   import * as request from 'supertest'; -> Option B

4. Quick Check:

   Use ES module import * as for supertest [OK]

Hint: Use import * as request from 'supertest' in NestJS E2E tests [OK]

Common Mistakes:

• Using require() instead of import
• Assuming supertest has a default export
• Using dynamic import incorrectly

3. Given this NestJS E2E test snippet, what will be the HTTP status code returned by the test?

const app = await NestFactory.create(AppModule);
await app.init();
return request(app.getHttpServer())
  .get('/users')
  .expect(200);

medium

A. 200

B. 404

C. 500

D. 301

Solution

1. Step 1: Analyze the test request

   The test sends a GET request to '/users' on the initialized app and expects status 200.

2. Step 2: Understand .expect(200) behavior

   The .expect(200) asserts the response status must be 200 for the test to pass.

3. Final Answer:

   200 -> Option A

4. Quick Check:

   Test expects status 200, so response = 200 [OK]

Hint: Check the .expect() status code to predict response [OK]

Common Mistakes:

• Confusing expected status with actual response
• Assuming 404 if route not defined without context
• Ignoring .expect() assertion meaning

4. Identify the error in this NestJS E2E test code snippet:

const app = await NestFactory.create(AppModule);
return request(app.getHttpServer())
  .post('/login')
  .send({ username: 'user', password: 'pass' })
  .expect(201);
await app.close();

medium

A. Using .send() with POST request is invalid

B. Missing await before request call

C. Calling app.close() after return statement

D. Expecting status 201 instead of 200

Solution

1. Step 1: Check code flow with return and await

   The return statement ends the function immediately, so await app.close() after return is unreachable and never runs.

2. Step 2: Identify proper app closing

   To close the app properly, await app.close() must be called before returning the request promise.

3. Final Answer:

   Calling app.close() after return statement -> Option C

4. Quick Check:

   Code after return is unreachable [OK]

Hint: Place app.close() before return to ensure cleanup [OK]

Common Mistakes:

• Ignoring unreachable code after return
• Thinking .send() is invalid for POST
• Assuming status 201 is always wrong

5. You want to write an E2E test in NestJS that sends a POST request with JSON data, verifies the response body contains a specific property, and then closes the app properly. Which code snippet correctly implements this?

hard

A. const app = await NestFactory.create(AppModule);
await app.init();
const response = await request(app.getHttpServer())
.post('/items')
.send({ name: 'item1' })
.expect(201);
expect(response.body).toHaveProperty('id');
await app.close();

B. const app = await NestFactory.create(AppModule);
const response = request(app.getHttpServer())
.post('/items')
.send({ name: 'item1' })
.expect(201);
expect(response.body).toHaveProperty('id');
await app.close();

C. const app = await NestFactory.create(AppModule);
await app.init();
request(app.getHttpServer())
.post('/items')
.send({ name: 'item1' })
.expect(201)
.then(response => {
expect(response.body).toHaveProperty('id');
});
await app.close();

D. const app = await NestFactory.create(AppModule);
await app.init();
const response = await request(app.getHttpServer())
.post('/items')
.send({ name: 'item1' })
.expect(200);
expect(response.body).toHaveProperty('id');
await app.close();

Solution

1. Step 1: Initialize and start the app

   Await NestFactory.create(AppModule) and app.init() to fully bootstrap and start the HTTP server before sending requests.

2. Step 2: Send POST request and await response

   Await the supertest chain request(app.getHttpServer()).post('/items').send({ name: 'item1' }).expect(201) to capture the response object.

3. Step 3: Verify response body and close app

   Assert expect(response.body).toHaveProperty('id') then await app.close() for proper cleanup.

4. Final Answer:

   The snippet with await app.init(), await request.expect(201), body check, and await app.close() -> Option A

5. Quick Check:

   Await init, await request, assert body, await close [OK]

Hint: Always await app.init(), request, and app.close() in E2E tests [OK]

Common Mistakes:

• Not awaiting app.init() before requests
• Not awaiting request call causing missing response
• Expecting wrong status code (200 vs 201)
• Calling app.close() too early or after return