API with NestJS #102. Writing unit tests with Prisma

April 3, 2023

This entry is part 102 of 168 in the API with NestJS

Covering our NestJS application with unit tests can help us create a reliable product. In this article, we introduce the idea behind unit tests and implement them in an application working with Prisma.

In this article, we continue the code developed in API with NestJS #33. Managing PostgreSQL relationships with Prisma

Introducing unit tests

A unit test ensures that an individual piece of our code works properly. With them, we can make sure that various parts of our system function correctly in isolation.

When we run npm run test, Jest looks for files with a specific naming convention. By default, it includes files ending with .spec.ts. Another popular approach is to create files ending with .test.ts. We can look it up in our package.json file.

package.json

{

// ...

"jest": {

"testRegex": ".*\\.test\\.ts$",

// ...

}

Let’s create a basic test for our AuthenticationService class.

authentication.service.test.ts

import { AuthenticationService } from './authentication.service';

import { JwtService } from '@nestjs/jwt';

import { ConfigService } from '@nestjs/config';

import { UsersService } from '../users/users.service';

import { PrismaService } from '../prisma/prisma.service';

describe('The AuthenticationService', () => {

let authenticationService: AuthenticationService;

beforeEach(() => {

authenticationService = new AuthenticationService(

new UsersService(new PrismaService()),

new JwtService({

secretOrPrivateKey: 'Secret key',

}),

new ConfigService(),

);

});

describe('when calling the getCookieForLogOut method', () => {

it('should return a correct string', () => {

const result = authenticationService.getCookieForLogOut();

expect(result).toBe('Authentication=; HttpOnly; Path=/; Max-Age=0');

});

PASS src/authentication/tests/authentication.service.spec.ts
The AuthenticationService
when creating a cookie
✓ should return a string (12ms)

In the example above, we use the constructor of the AuthenticationService manually. While that’s a possible solution, we can depend on NestJS test utilities to do it for us. To do that, we need the Test.createTestingModule method from the @nestjs/testing library.

authentication.service.test.ts

import { AuthenticationService } from './authentication.service';

import { JwtModule } from '@nestjs/jwt';

import { ConfigModule } from '@nestjs/config';

import { Test } from '@nestjs/testing';

import { UsersModule } from '../users/users.module';

import { PrismaModule } from '../prisma/prisma.module';

describe('The AuthenticationService', () => {

let authenticationService: AuthenticationService;

beforeEach(async () => {

const module = await Test.createTestingModule({

providers: [AuthenticationService],

imports: [

UsersModule,

ConfigModule.forRoot(),

JwtModule.register({

secretOrPrivateKey: 'Secret key',

}),

PrismaModule,

}).compile();

authenticationService = await module.get(AuthenticationService);

});

describe('when calling the getCookieForLogOut method', () => {

it('should return a correct string', () => {

const result = authenticationService.getCookieForLogOut();

expect(result).toBe('Authentication=; HttpOnly; Path=/; Max-Age=0');

});

Avoiding using a real database

When we take a look at our PrismaService, we can see that whenever we initialize it in our tests, we establish a connection with the database using the $connect() method.

import { Injectable, OnModuleInit, OnModuleDestroy } from '@nestjs/common';

import { PrismaClient } from '@prisma/client';

@Injectable()

export class PrismaService

extends PrismaClient

implements OnModuleInit, OnModuleDestroy

{

async onModuleInit() {

await this.$connect();

}

async onModuleDestroy() {

await this.$disconnect();

}

An essential thing about unit tests is that they should be independent. To depend on them, we need to ensure they are not affected by any possible issues with the database. The getCookieForLogOut method in our AuthenticationService does not require a database. However, a lot of other methods use the database. A good example is the getAuthenticatedUser method.

authentication.service.ts

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

import { UsersService } from '../users/users.service';

@Injectable()

export class AuthenticationService {

constructor(private readonly usersService: UsersService) {}

public async getAuthenticatedUser(email: string, plainTextPassword: string) {

try {

const user = await this.usersService.getByEmail(email);

await this.verifyPassword(plainTextPassword, user.password);

return user;

} catch (error) {

throw new BadRequestException();

}

// ...

}

To test the above logic in a unit test, we need to avoid making a request to the database.

When we look at our implementation of the AuthenticationService, we can see that it does not connect to the database directly. However, it uses the UsersService under the hood. We can provide a mocked instance of the UsersService that does not use our database.

authentication.service.test.ts

import { AuthenticationService } from './authentication.service';

import { JwtModule } from '@nestjs/jwt';

import { ConfigModule } from '@nestjs/config';

import { Test } from '@nestjs/testing';

import { UsersService } from '../users/users.service';

import { User } from '@prisma/client';

import * as bcrypt from 'bcrypt';

describe('The AuthenticationService', () => {

let userData: User;

let authenticationService: AuthenticationService;

let password: string;

beforeEach(async () => {

password = 'strongPassword123';

const hashedPassword = await bcrypt.hash(password, 10);

userData = {

id: 1,

email: 'john@smith.com',

password: hashedPassword,

addressId: null,

};

const module = await Test.createTestingModule({

providers: [

AuthenticationService,

{

provide: UsersService,

useValue: {

getByEmail: jest.fn().mockResolved(userData),

imports: [

ConfigModule.forRoot(),

JwtModule.register({

secretOrPrivateKey: 'Secret key',

}),

}).compile();

authenticationService = await module.get(AuthenticationService);

});

describe('when calling the getCookieForLogOut method', () => {

it('should return a correct string', () => {

const result = authenticationService.getCookieForLogOut();

expect(result).toBe('Authentication=; HttpOnly; Path=/; Max-Age=0');

});

describe('when the getAuthenticatedUser method is called', () => {

describe('and a valid email and password are provided', () => {

it('should return the new user', async () => {

const result = await authenticationService.getAuthenticatedUser(

userData.email,

password,

);

expect(result).toBe(userData);

});

Above, we provide a mocked version of the UsersService with the getByEmail method that always returns the data of a particular user. By doing that, we can know that our test won’t try to query users from the actual database.

Modifying our mock per test

In the above test, we assume that the getByEmail method returns a valid user. Unfortunately, that’s not always the case:

when we provide an email of a user that exists in our database, it returns the user,
if the user with that particular email does not exist, it throws the UserNotFoundException.

Let’s modify our mock before each test to cover both of the above cases.

authentication.service.test.ts

import { AuthenticationService } from './authentication.service';

import { JwtModule } from '@nestjs/jwt';

import { ConfigModule } from '@nestjs/config';

import { Test } from '@nestjs/testing';

import { UsersService } from '../users/users.service';

import { User } from '@prisma/client';

import * as bcrypt from 'bcrypt';

import { UserNotFoundException } from '../users/exceptions/userNotFound.exception';

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

describe('The AuthenticationService', () => {

let authenticationService: AuthenticationService;

let password: string;

let getByEmailMock: jest.Mock;

beforeEach(async () => {

getByEmailMock = jest.fn();

const module = await Test.createTestingModule({

providers: [

AuthenticationService,

{

provide: UsersService,

useValue: {

getByEmail: getByEmailMock,

imports: [

ConfigModule.forRoot(),

JwtModule.register({

secretOrPrivateKey: 'Secret key',

}),

}).compile();

authenticationService = await module.get(AuthenticationService);

});

describe('when calling the getCookieForLogOut method', () => {

it('should return a correct string', () => {

const result = authenticationService.getCookieForLogOut();

expect(result).toBe('Authentication=; HttpOnly; Path=/; Max-Age=0');

});

describe('when the getAuthenticatedUser method is called', () => {

describe('and a valid email and password are provided', () => {

let userData: User;

beforeEach(async () => {

password = 'strongPassword123';

const hashedPassword = await bcrypt.hash(password, 10);

userData = {

id: 1,

email: 'john@smith.com',

password: hashedPassword,

addressId: null,

};

getByEmailMock.mockResolvedValue(userData); // 👈

});

it('should return the new user', async () => {

const result = await authenticationService.getAuthenticatedUser(

userData.email,

password,

);

expect(result).toBe(userData);

});

describe('and an invalid email is provided', () => {

beforeEach(() => {

getByEmailMock.mockRejectedValue(new UserNotFoundException()); // 👈

});

it('should throw the BadRequestException', () => {

return expect(async () => {

await authenticationService.getAuthenticatedUser(

'john@smith.com',

password,

);

}).rejects.toThrow(BadRequestException);

});

The AuthenticationService
when the getAuthenticatedUser method is called
and a valid email and password are provided
✓ should return the new user (106 ms)
and an invalid email is provided
✓ should throw the BadRequestException (10 ms)

The essential thing to notice above is that we are not testing the UsersService itself. Focusing on a single class or a function is the essence of writing unit tests. We don’t check how classes work together but make sure they work as expected in isolation.

Mocking Prisma

So far, we’ve been able to avoid using our real database by mocking the UsersService. However, we should also test the UsersService class. Let’s take a quick look at the getByEmail method.

users.service.ts

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

import { PrismaService } from '../prisma/prisma.service';

import { UserNotFoundException } from './exceptions/userNotFound.exception';

@Injectable()

export class UsersService {

constructor(private readonly prismaService: PrismaService) {}

async getByEmail(email: string) {

const user = await this.prismaService.user.findUnique({

where: {

email,

});

if (!user) {

throw new UserNotFoundException();

}

return user;

}

// ...

}

There are two major cases above:

if the findUnique method returns the user, getByEmail should return it too,
if the findUnique method does not return the user, getByEmail should throw an error.

In order to test all of that, we need to mock the PrismaService.

authentication.service.test.ts

import { UsersService } from './users.service';

import { PrismaService } from '../prisma/prisma.service';

import { User } from '@prisma/client';

import { Test } from '@nestjs/testing';

import { UserNotFoundException } from './exceptions/userNotFound.exception';

describe('The UsersService', () => {

let usersService: UsersService;

let findUniqueMock: jest.Mock;

beforeEach(async () => {

findUniqueMock = jest.fn();

const module = await Test.createTestingModule({

providers: [

UsersService,

{

provide: PrismaService,

useValue: {

user: {

findUnique: findUniqueMock,

}).compile();

usersService = await module.get(UsersService);

});

describe('when the getByEmail function is called', () => {

describe('and the findUnique method returns the user', () => {

let user: User;

beforeEach(() => {

user = {

id: 1,

email: 'john@smith.com',

password: 'strongPassword123',

addressId: null,

};

findUniqueMock.mockResolvedValue(user);

});

it('should return the user', async () => {

const result = await usersService.getByEmail(user.email);

expect(result).toBe(user);

});

describe('and the findUnique method does not return the user', () => {

beforeEach(() => {

findUniqueMock.mockResolvedValue(undefined);

});

it('should throw the UserNotFoundException', async () => {

return expect(async () => {

await usersService.getByEmail('john@smith.com');

}).rejects.toThrow(UserNotFoundException);

});

Summary

In this article, we’ve learned about writing unit tests with NestJS. As an example, we’ve used services that use Prisma to connect to our database. While we don’t always have to mock Prisma to avoid connecting to the actual database, we definitely need to know how to do that. There is still more to learn when it comes to testing with Prisma and NestJS, so stay tuned!

Series Navigation<< API with NestJS #101. Managing sensitive data using the AWS Secrets ManagerAPI with NestJS #103. Integration tests with Prisma >>