Nest 无法解析 UsersService 的依赖关系

Question

I am trying to set up Authorisation in NestJs using Mongoose via a User Service. I'm getting the following errors when trying to Unit Test:

I understand that the UserModel is injected into the UsersService and needs to be resolved when using the UsersModule but I can't work out how to do this when creating the TestingModule. Please can someone shed some light on this for me?

Code is below, thanks:

USER MODULE

## users.module.ts

import { Module } from '@nestjs/common';
import { UsersService } from './users.service';

@Module({
  providers: [UsersService],
  exports: [UsersService],
})
export class UsersModule {}

## users.service.ts

import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { User } from './interfaces/user.interface';
import { CreateUserDto } from './dto/create-user.dto';

@Injectable()
export class UsersService {
  constructor(@InjectModel('User') private readonly userModel: Model<User>) {}  

  async store(userData: CreateUserDto): Promise<User> {
    const newUser = new this.userModel(userData);
    return newUser.save();
  }

  async find(data: Record<string, any> = {}) {
    return this.userModel
        .findOne(data)
        .exec();
  }

  async findById(id: string): Promise<User> {
    return this.userModel
        .findById(id)
        .exec();
  } 

  async findByIdOrFail(id: string): Promise<User> {
    return this.userModel
        .findById(id)
        .orFail()
        .exec();
  }

  async update(id: string, data: Record<string, any> = {}): Promise<User> {
    return this.userModel
        .findByIdAndUpdate(id, data, {
            runValidators: true,
            useFindAndModify: false,
            new: true,
        })
        .orFail()
        .exec();
  }

  async destroy(id: string): Promise<User> {
    return this.userModel
        .findByIdAndRemove(id, {
           useFindAndModify: false,
        })
        .orFail()
        .exec();        
  }     
}

AUTH MODULE

## auth.module.ts

import { Module } from '@nestjs/common';
import { AuthService } from './auth.service';
import { UsersModule } from '../users/users.module';

@Module({
  imports: [UsersModule],
  providers: [AuthService]
})
export class AuthModule {}

## auth.service.ts

import { Injectable } from '@nestjs/common';
import { UsersService } from '../users/users.service';

@Injectable()
export class AuthService {
    constructor(private usersService: UsersService) {}  
}

AUTH SERVICE TEST

## auth.service.spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { MongooseModule } from '@nestjs/mongoose';
import { MongoMemoryServer } from 'mongodb-memory-server';
import { AuthService } from './auth.service';
import { UsersModule } from '../users/users.module';
import { UserSchema } from '../users/schemas/user.schema';

const mongod = new MongoMemoryServer();

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

  beforeEach(async () => {
    const uri = await mongod.getUri();

    const module: TestingModule = await Test.createTestingModule({
      imports: [
        MongooseModule.forRoot(uri, {
          useNewUrlParser: true,
          useUnifiedTopology: true,
        }),
        MongooseModule.forFeature([{ name: 'User', schema: UserSchema }]), 
        UsersModule,        
      ],
      providers: [
        AuthService
      ],
    }).compile();

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

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

Answer 1

In unit tests, you should mock all necessary dependencies for AuthService. It's not e2e test, you shouldn't initialize MongooseModule here. Your beforeEach should look like that:

 beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        AuthService,
        { provide: UsersService, useValue: createSpyObj(UsersService) }
      ]
    }).compile();

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

Answer 2

Combining Maciej's suggestion above and this blog: https://medium.com/@davguij/mocking-typescript-classes-with-jest-8ef992170d1 , I arrived at the following solution:

## /auth/auth.service.spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { AuthService } from './auth.service';
import { UsersModule } from '../users/users.module';

jest.mock('../users/users.service');

describe.only('AuthService', () => {
  let service: AuthService;

  beforeEach(async () => {

    const module: TestingModule = await Test.createTestingModule({
      imports: [
        UsersModule,
      ],
      providers: [
        AuthService,
      ],
    }).compile();

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

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

  it('should validate user ok', async () => {
    const res = await service.validateUser('username');
    expect(res).toBeDefined();
  });
});

I also had to create a mock class, under mocks as suggested in the above article:

## /users/__mocks__/users.service.ts

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

@Injectable()
export class UsersService {

    async find(data: Record<string, any> = {}) {
        return {
            "firstname": "firstname",
            "lastname": "lastname"
        }
    }   
}

which mocks the below class (same as above, but reduced for the sake of this explanation):

## /users/users.service.ts

import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { User } from './interfaces/user.interface';

@Injectable()
export class UsersService {
  constructor(@InjectModel('User') private readonly userModel: Model<User>) {}  

  async find(data: Record<string, any> = {}) {
    return this.userModel
        .findOne(data)
        .exec();
  }     
}