Как протестировать Модели (Пн goose) в сервисе (Гнездо JS) с шуткой

Question

У меня есть бэкэнд с Nest JS. В моем сервисе я использую две модели Mon goose. Я использую Jest для тестирования сервиса. Модели объявляются как есть и внедряются в модуль:

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'],
  },
];

Пример модуля:

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 {}

Затем в моем сервисе я внедряю модели:

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

В моих викторинах. Вид c .ts (шутка) я начал делать такие вещи. Он компилируется, но не работает:

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 не определен и тест не завершается.

Answer 1

Настройка набора тестов была в порядке, но не тест, я тестирую сервис getAllQuizes методом

Вот сервис

@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();

}

Вот тест

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'}]);

        })

Мой тест ложен, потому что ожидание утверждения (clientClassModel.find) .toHaveBeenCalled () ложно, тогда как в моем сервисе у меня первый вызов метода find пользовательской модели и второй вызов метода find класса модель

Answer 2

Наконец тесты пройдены

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

Исправлено

Вы не должны использовать await для module.get

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