Integration testing in NestJS - Step-by-Step Execution

Concept Flow - Integration testing

Setup Test Module

↓

Initialize Application

↓

Run Test Cases

↓

Send HTTP Requests

↓

Check Responses & Database

↓

Tear Down Application

↓

Report Results

Integration testing in NestJS sets up a test module, runs HTTP requests against the app, checks responses and database, then cleans up.

Execution Sample

NestJS

import { Test, TestingModule } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import * as request from 'supertest';
import { AppModule } from '../src/app.module';

describe('AppController (integration)', () => {
  let app: INestApplication;

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

  it('/GET hello', () => {
    return request(app.getHttpServer())
      .get('/hello')
      .expect(200)
      .expect('Hello World!');
  });

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

This code sets up a NestJS app for testing, sends a GET request to '/hello', checks the response, then closes the app.

Execution Table

Step	Action	Evaluation	Result
1	Create testing module with AppModule	Module created	ModuleRef ready
2	Create Nest application from module	App instance created	app initialized
3	Call app.init()	App starts listening internally	App ready for requests
4	Send GET request to '/hello'	Request sent	Response received
5	Check response status	Status is 200	Pass
6	Check response body	Body is 'Hello World!'	Pass
7	Call app.close()	App shuts down	Resources released
8	Test suite ends	All tests passed	Integration test success

💡 Test ends after app closes and all assertions pass

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 7	Final
app	undefined	undefined	NestApplication instance	Initialized app	Initialized app	Closed app	Closed app

Key Moments - 3 Insights

Why do we call app.init() before sending requests?

app.init() starts the NestJS app internally so it can handle HTTP requests, as shown in step 3 of the execution_table.

What happens if we forget to call app.close() after tests?

The app keeps running and resources stay allocated, which can cause tests to hang or leak memory, as explained in step 7.

Why do we use Test.createTestingModule instead of the real app directly?

It creates a test environment isolated from production, allowing controlled testing with modules, as shown in step 1.

Visual Quiz - 3 Questions

Look at the execution_table, what is the state of 'app' after step 3?

A App module is created but app not started

B App is closed and resources released

C App is initialized and ready to handle requests

D App is sending HTTP requests

💡 Hint

Check the 'Result' column at step 3 in execution_table

At which step does the test verify the response body is 'Hello World!'?

A Step 4

B Step 6

C Step 5

D Step 7

💡 Hint

Look for 'Check response body' in the 'Action' column in execution_table

If we skip calling app.close(), what impact would it have on the test suite?

A Tests might hang or leak resources

B No impact, tests run normally

C Tests would pass faster

D App would not start

💡 Hint

Refer to the key_moments explanation about app.close() and step 7 in execution_table

Concept Snapshot

Integration testing in NestJS:
- Use Test.createTestingModule({imports: [AppModule]}) to set up
- Create app with moduleRef.createNestApplication()
- Call app.init() to start app internally
- Use supertest (request) to send HTTP calls
- Assert response status and body
- Call app.close() to clean up
- Tests check app behavior end-to-end

Full Transcript

Integration testing in NestJS involves creating a test module with the app's modules, then creating a Nest application instance from it. Before sending HTTP requests, app.init() is called to start the app internally. Tests send requests using supertest and check the responses for expected status codes and bodies. After tests finish, app.close() is called to release resources. This process ensures the app works correctly as a whole, including routing and services.