How to test Models (Mongoose) in a service (NestJS) with jest

Question

I have a backend done with NestJS. In my service I inject two Mongoose Models. I use Jest to test the service. Models are declared as is and injected into the module:

quizes.providers.ts
import { Connection } from 'mongoose';
import { QuizSchema } from './schemas/quiz.schema';

export const quizesProviders = [
  {
    provide: 'CLASS_MODEL',
    useFactory: (connection: Connection) => connection.model('Quiz', QuizSchema),
    inject: ['DATABASE_CONNECTION'],
  },
];

users.providers.ts
import { Connection } from 'mongoose';
import { UserSchema } from './schemas/user.schema';

export const usersProviders = [
  {
    provide: 'USER_MODEL',
    useFactory: (connection: Connection) => connection.model('User', UserSchema),
    inject: ['DATABASE_CONNECTION'],
  },
];

Example of module:

quizes.module.ts
import { Module } from '@nestjs/common';
import { QuizesController } from './quizes.controller';
import { QuizesService } from './quizes.service';

import { quizesProviders } from './quizes.providers';

import { usersProviders } from '../auth/users.providers';

import { DatabaseModule } from 'src/database.module';
import { AuthModule } from 'src/auth/auth.module';

@Module({
  imports: [DatabaseModule, AuthModule],
  controllers: [QuizesController],
  providers: [QuizesService,
  ...quizesProviders, ...usersProviders]
})
export class QuizesModule {}

Then in my service, I inject models:

quizes.service.ts
@Injectable()
export class QuizesService {
    constructor(
        @Inject('CLASS_MODEL')
        private classModel: Model<Quiz>,
        @Inject('USER_MODEL')
        private userModel: Model<User>
      ) {}

In my quizes.spec.ts (jest) I began to do things like that. It compiles but doesn't work:

import { Test } from '@nestjs/testing';
import * as mongoose from 'mongoose';
import { User } from 'src/auth/user.interface';
import { Quiz } from './quiz.interface';
import { databaseProviders } from '../database.providers';

const USER_MODEL:mongoose.Model<User> =  mongoose.model('User', UserSchema);

const CLASS_MODEL:mongoose.Model<Quiz> =  mongoose.model('Quiz', QuizSchema);

const mockingQuizModel = () => {
  find: jest.fn()
}

const mockingUserModel = () => {
 find: jest.fn()
}

const mockUser = {
  username: 'Test user'
}

describe('QuizesService', () => {
    let quizesService;
    let userModel , classModel;


    beforeEach(async () => {
        const module = await Test.createTestingModule({

            providers: [QuizesService, ...usersProviders, ...quizesProviders,...databaseProviders,
            {provide: USER_MODEL, useFactory: mockingUserModel},
            {provide: CLASS_MODEL, useFactory: mockingQuizModel},
        ],
        }).compile();

        quizesService = await module.get<QuizesService>(QuizesService);
        classModel = await module.get<mongoose.Model<Quiz>>(CLASS_MODEL)
        userModel = await module.get<mongoose.Model<User>>(USER_MODEL)

    })

    describe('getAllQuizes', ()=> {

        it('get all quizes', () => {
           expect(userModel.find).not.toHaveBeenCalled();
        })

    })
})

userModel is undefined and the test does not exit.

Answer 1

Use the getModelToken function as defined in NestJS official: https://docs.nestjs.com/v6/ Techniques -> Mongo (Scroll down to Testing section)

Then your code should look a bit like this:

import { getModelToken } from '@nestjs/mongoose';

const mockRepository = {
    find() {
      return {};
    }
  };

const module = await Test.createTestingModule({    
    providers: [ ...,
    {provide: getModelToken('CLASS_MODEL'), useValue: mockRepository,},
    {provide: getModelToken('USER_MODEL'), useValue: mockRepository,},
],
...

Answer 2

Finally tests pass

describe("getAllQuizes", () => {
  it("get all quizes, user not found", async () => {
    clientUserModel.find.mockRejectedValue("user not found");
    clientClassModel.find.mockResolvedValue([
      { title: "test", description: "test" },
    ]);

    expect(clientUserModel.find).not.toHaveBeenCalled();
    expect(clientClassModel.find).not.toHaveBeenCalled();
    const result = quizesService.getAllQuizes(mockUser).catch((err) => {
      expect(err.message).toEqual("user not found");
    });
    expect(clientUserModel.find).toHaveBeenCalled();
  });

  it("get all quizes, find quizzes", async () => {
    clientUserModel.find.mockReturnValue({
      _id: "1234",
      username: "Test user",
    });
    clientClassModel.find.mockResolvedValue([
      { title: "test", description: "test" },
    ]);

    expect(clientUserModel.find).not.toHaveBeenCalled();
    expect(clientClassModel.find).not.toHaveBeenCalled();
    const result = quizesService.getAllQuizes(mockUser).then((state) => {
      expect(clientUserModel.find).toHaveBeenCalled();
      expect(clientClassModel.find).toHaveBeenCalled();
      expect(state).toEqual([{ title: "test", description: "test" }]);
    });

    //
  });
});

Answer 3

The setup of the test suite was ok but not the test I test the service getAllQuizes method

Here is the service

@Injectable()
export class QuizesService {
    constructor(
        @InjectModel('CLASS_MODEL')
        private classModel: Model<Quiz>,
        @InjectModel('USER_MODEL')
        private userModel: Model<User>
      ) {}

async getAllQuizes(user: User) : Promise<Quiz[]> {
  // console.log(user);
    let userId;
    try {
    const userEntity = await this.userModel.find({username: user.username}).exec();
    userId = userEntity[0]._id;
    } catch (error) {
      throw new NotFoundException('user not found');

    }
    return await this.classModel.find({user: userId}).exec();

}

Here is the test

it('get all quizes', async () => {
            clientUserModel.find.mockResolvedValue('user1');

            clientClassModel.find.mockResolvedValue([{title: 'test', description: 'test'}])

           expect(clientUserModel.find).not.toHaveBeenCalled();
           expect(clientClassModel.find).not.toHaveBeenCalled();
           const result = quizesService.getAllQuizes(mockUser);
           expect(clientUserModel.find).toHaveBeenCalled();
           expect(clientClassModel.find).toHaveBeenCalled();
           expect(result).toEqual([{title: 'test', description: 'test'}]);

        })

My test is false because the assertion expect(clientClassModel.find).toHaveBeenCalled() is false Whereas in my service I have a first call on find method of the user model, and a second call on the find method of the class model

Answer 4

Fixed

You should not use await for module.get

quizesService = module.get<QuizesService>(QuizesService);
clientClassModel = module.get(getModelToken('CLASS_MODEL'))
clientUserModel =  module.get(getModelToken('USER_MODEL'))