How To Write Integration Tests in NestJS?

//src/appointment/appointment.model.ts

export interface Appointment {
    patientId: number;
    startTime: Date;
    endTime: Date;
    confirmed: boolean;
}

//src/appointment/appointment.module.ts

import { Module } from '@nestjs/common';
import { PatientModule } from '../patient/patient.module';
import { AppointmentService } from './appointment.service';

@Module({
    imports: [PatientModule],
    providers: [AppointmentService],
})
export class AppointmentModule { }

//src/appointment/appointment.service.spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { PatientModule } from '../patient/patient.module';
import { PatientService } from '../patient/patient.service';
import { AppointmentService } from './appointment.service';

describe('AppointmentService', () => {
    let service: AppointmentService;
    let patientService: PatientService;

    beforeEach(async () => {
        const module: TestingModule = await Test.createTestingModule({
            imports: [PatientModule],
            providers: [AppointmentService],
        }).compile();

        service = module.get<AppointmentService>(AppointmentService);
        patientService = module.get(PatientService);
    });

    it('should be defined', () => {
        expect(service).toBeDefined();
    });

    it('should schedule an unconfirmed appointment for a user on success', async () => {
        const startTime = new Date('2022-01-01T14:00:00Z');
        const endTime = new Date('2022-01-01T15:00:00Z');
        const { id: patientId } = await patientService.register({
            name: 'John Doe',
        });

        const newAppointment = await service.scheduleAppointment({
            patientId,
            startTime,
            endTime,
        });

        expect(newAppointment).toEqual({
            patientId,
            startTime,
            endTime,
            confirmed: false,
        });
    });

    it('should throw an error when end time is before start time', async () => {
        const startTime = new Date('2022-01-01T14:00:00Z');
        const endTime = new Date('2022-01-01T13:00:00Z');

        await expect(
            service.scheduleAppointment({
                patientId: 1,
                startTime,
                endTime,
            }),
        ).rejects.toThrowError("appointment's endTime should be after startTime");
    });

    it('should throw an error when end time is equal to start time', async () => {
        const startTime = new Date('2022-01-01T14:00:00Z');
        const endTime = startTime;

        await expect(
            service.scheduleAppointment({
                patientId: 1,
                startTime,
                endTime,
            }),
        ).rejects.toThrowError("appointment's endTime should be after startTime");
    });

    it('should throw an error when end time is in the next day', async () => {
        const startTime = new Date('2022-01-01T14:00:00Z');
        const endTime = new Date('2022-01-02T00:00:00Z');

        await expect(
            service.scheduleAppointment({
                patientId: 1,
                startTime,
                endTime,
            }),
        ).rejects.toThrowError(
            "appointment's endTime should be in the same day as start time's",
        );
    });

    it('should throw an error when end time is in same day and hour of next month', async () => {
        const startTime = new Date('2022-01-01T14:00:00Z');
        const endTime = new Date('2022-02-01T14:00:00Z');

        await expect(
            service.scheduleAppointment({
                patientId: 1,
                startTime,
                endTime,
            }),
        ).rejects.toThrowError(
            "appointment's endTime should be in the same day as start time's",
        );
    });

    it('should throw an error when end time is in same day, hour and month of the next year', async () => {
        const startTime = new Date('2022-01-01T14:00:00Z');
        const endTime = new Date('2023-01-01T14:00:00Z');

        await expect(
            service.scheduleAppointment({
                patientId: 1,
                startTime,
                endTime,
            }),
        ).rejects.toThrowError(
            "appointment's endTime should be in the same day as start time's",
        );
    });

    it('should throw an error when the patient does not exist', async () => {
        const startTime = new Date('2022-01-01T14:00:00Z');
        const endTime = new Date('2022-01-01T15:00:00Z');

        await expect(
            service.scheduleAppointment({
                patientId: 1,
                startTime,
                endTime,
            }),
        ).rejects.toThrowError('Patient does not exist');
    });
});

//src/appointment/appointment.service.ts

import { Injectable } from '@nestjs/common';
import { PatientService } from '../patient/patient.service';
import { Appointment } from './appointment.model';

export interface AppointmentInput {
    patientId: number;
    startTime: Date;
    endTime: Date;
}

@Injectable()
export class AppointmentService {
    constructor(private readonly patientService: PatientService) { }

    public async scheduleAppointment(
        appointmentData: AppointmentInput,
    ): Promise<Appointment> {
        if (appointmentData.endTime <= appointmentData.startTime) {
            throw new Error("appointment's endTime should be after startTime");
        }

        if (this.endTimeIsInTheNextDay(appointmentData)) {
            throw new Error(
                "appointment's endTime should be in the same day as start time's",
            );
        }

        const patientExists = await this.patientService.doesPatientExist(
            appointmentData.patientId,
        );

        if (!patientExists) {
            throw new Error('Patient does not exist');
        }

        return {
            ...appointmentData,
            confirmed: false,
        };
    }

    private endTimeIsInTheNextDay(appointmentData: AppointmentInput): boolean {
        const differentDays =
            appointmentData.endTime.getUTCDate() !==
            appointmentData.startTime.getUTCDate();

        const differentMonths =
            appointmentData.endTime.getUTCMonth() !==
            appointmentData.startTime.getUTCMonth();

        const differentYears =
            appointmentData.endTime.getUTCFullYear() !==
            appointmentData.startTime.getUTCFullYear();

        return differentDays || differentMonths || differentYears;
    }
}

//src/patient/patient.model.ts

export interface Patient {
    id: number;
    name: string;
}

//src/patient/patient.module.ts

import { Module } from '@nestjs/common';
import { PatientService } from './patient.service';

@Module({
    providers: [PatientService],
    exports: [PatientService],
})
export class PatientModule { }

//src/patient/patient.service.spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { PatientService } from './patient.service';

describe('PatientService', () => {
    let service: PatientService;

    beforeEach(async () => {
        const module: TestingModule = await Test.createTestingModule({
            providers: [PatientService],
        }).compile();

        service = module.get<PatientService>(PatientService);
    });

    it('should be defined', () => {
        expect(service).toBeDefined();
    });

    describe('register', () => {
        it('should return a new patient with given name', async () => {
            const newPatient = await service.register({ name: 'John Doe' });

            expect(newPatient).toEqual({
                id: expect.any(Number),
                name: 'John Doe',
            });
        });

        it('should return different patients when called twice', async () => {
            const firstPatient = await service.register({ name: 'John Doe' });
            const secondPatient = await service.register({ name: 'John Doe' });

            expect(firstPatient).not.toEqual(secondPatient);
        });
    });

    describe('doesPatientExist', () => {
        it('should return false when no patient was registered', async () => {
            const patientId = 1;
            const exists = await service.doesPatientExist(patientId);

            expect(exists).toBe(false);
        });

        it('should return true when patient was registered', async () => {
            const { id: patientId } = await service.register({ name: 'John Doe' });
            const exists = await service.doesPatientExist(patientId);

            expect(exists).toBe(true);
        });
    });
});

//src/patient/patient.service.ts

import { Injectable } from '@nestjs/common';
import { Patient } from './patient.model';

export interface PatientInput {
    name: string;
}

@Injectable()
export class PatientService {
    private readonly patients: Patient[] = [];
    private nextId = 1;

    public async register(patientInput: PatientInput): Promise<Patient> {
        const newPatient = {
            id: this.nextId++,
            name: patientInput.name,
        };

        this.patients.push(newPatient);

        return newPatient;
    }

    public async doesPatientExist(patientId: number): Promise<boolean> {
        return this.patients.some((patient) => patient.id === patientId);
    }
}

//src/main.ts

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
    const app = await NestFactory.create(AppModule);
    await app.listen(3000);
}
bootstrap();

//src/app.module.ts

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { PatientModule } from './patient/patient.module';
import { AppointmentModule } from './appointment/appointment.module';

@Module({
    imports: [PatientModule, AppointmentModule],
    controllers: [AppController],
    providers: [AppService],
})
export class AppModule { }

//src/app.service.ts

import { Injectable } from '@nestjs/common';

@Injectable()
export class AppService {
    getHello(): string {
        return 'Hello World!';
    }
}

//src/app.controller.ts

import { Controller, Get } from '@nestjs/common';
import { AppService } from './app.service';

@Controller()
export class AppController {
    constructor(private readonly appService: AppService) { }

    @Get()
    getHello(): string {
        return this.appService.getHello();
    }
}

//src/app.controller.spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { AppController } from './app.controller';
import { AppService } from './app.service';

describe('AppController', () => {
    let appController: AppController;

    beforeEach(async () => {
        const app: TestingModule = await Test.createTestingModule({
            controllers: [AppController],
            providers: [AppService],
        }).compile();

        appController = app.get<AppController>(AppController);
    });

    describe('root', () => {
        it('should return "Hello World!"', () => {
            expect(appController.getHello()).toBe('Hello World!');
        });
    });
});

//test/app.e2e-spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import * as request from 'supertest';
import { PatientModule } from '../src/patient/patient.module';
import { PatientService } from '../src/patient/patient.service';

describe('PatientModule (e2e)', () => {
    let app: INestApplication;
    let patientService = {
        findAll: () => [{ id: 1, name: 'John Doe', age: 30 }],
        create: (dto: any) => ({ id: 2, ...dto }),
    };

    // Setup before tests
    beforeAll(async () => {
        const moduleFixture: TestingModule = await Test.createTestingModule({
            imports: [PatientModule],
        })
            .overrideProvider(PatientService)
            .useValue(patientService)
            .compile();

        app = moduleFixture.createNestApplication();
        await app.init();
    });

    // Integration test for GET /patients endpoint
    it('/patients (GET)', () => {
        return request(app.getHttpServer())
            .get('/patients')
            .expect(200)
            .expect([{ id: 1, name: 'John Doe', age: 30 }]);
    });

    // Integration test for POST /patients endpoint
    it('/patients (POST)', () => {
        return request(app.getHttpServer())
            .post('/patients')
            .send({ name: 'Jane Doe', age: 28 })
            .expect(201)
            .expect({ id: 2, name: 'Jane Doe', age: 28 });
    });

    // Cleanup after tests
    afterAll(async () => {
        await app.close();
    });
});