Mongoose 巢罐'；t在测试期间解决UserService的依赖关系

我正试图为

UserService

编写一个单元测试，它将Mongoose模型作为一个依赖项，但当我运行测试时，它无法解决

user.module.ts

import { Module } from '@nestjs/common';
import { DatabaseModule } from '../database/database.module';
import { UserService } from './user.service';
import userProviders from './providers';

@Module({
  imports: [DatabaseModule],
  providers: [UserService, ...userProviders],
  exports: [UserService],
})
export class UserModule {}

import { Connection } from 'mongoose';

import { UserSchema } from '../schemas/user.schema';
import { USER_MODEL_PROVIDER, DB_PROVIDER } from '../../../constants/database';
import { Provider } from '@nestjs/common';
import { USER_MODEL } from '../../../constants/models';

export const userProvider: Provider = {
  provide: USER_MODEL_PROVIDER,
  useFactory: (connection: Connection) =>
    connection.model(USER_MODEL, UserSchema),
  inject: [DB_PROVIDER],
};

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

@Injectable()
export class UserService {
  constructor(
    @InjectModel(USER_MODEL)
    private readonly userModel: Model<User>,
  ) {}

  async getUsers(): Promise<User[]> {
    return this.userModel.find().exec();
  }

  async getUser(userId: any): Promise<User> {
    return this.userModel.findById(userId).exec();
  }

  async addUser(dto: CreateUserDto): Promise<User> {
    return new this.userModel(dto).save();
  }

  async updateUser(userId: any, dto: UpdateUserDto): Promise<User> {
    return this.userModel.findByIdAndUpdate(userId, dto, {
      new: true,
    });
  }
}

import { Test } from '@nestjs/testing';
import { USER_MODEL } from '../../constants/models';
import { User } from './interfaces/user.interface';
import { UserService } from './user.service';
import { getModelToken } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import userProviders from './providers';
import { DatabaseModule } from '../database/database.module';

describe('UserService', () => {
  let userService: UserService;
  let userModel: Model<User>;
  const token = getModelToken(USER_MODEL);

  beforeAll(async () => {
    const userModule = await Test.createTestingModule({
      imports: [DatabaseModule],
      providers: [UserService, ...userProviders],
    }).compile();

    userService = userModule.get<UserService>(UserService);
    userModel = userModule.get(token);
  });

  it('should get all users', async () => {
    const users = await userService.getUsers();
    expect(users).toEqual([]);
  });
});

user.provider.ts

import { Module } from '@nestjs/common';
import { DatabaseModule } from '../database/database.module';
import { UserService } from './user.service';
import userProviders from './providers';

@Module({
  imports: [DatabaseModule],
  providers: [UserService, ...userProviders],
  exports: [UserService],
})
export class UserModule {}

import { Connection } from 'mongoose';

import { UserSchema } from '../schemas/user.schema';
import { USER_MODEL_PROVIDER, DB_PROVIDER } from '../../../constants/database';
import { Provider } from '@nestjs/common';
import { USER_MODEL } from '../../../constants/models';

export const userProvider: Provider = {
  provide: USER_MODEL_PROVIDER,
  useFactory: (connection: Connection) =>
    connection.model(USER_MODEL, UserSchema),
  inject: [DB_PROVIDER],
};

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

@Injectable()
export class UserService {
  constructor(
    @InjectModel(USER_MODEL)
    private readonly userModel: Model<User>,
  ) {}

  async getUsers(): Promise<User[]> {
    return this.userModel.find().exec();
  }

  async getUser(userId: any): Promise<User> {
    return this.userModel.findById(userId).exec();
  }

  async addUser(dto: CreateUserDto): Promise<User> {
    return new this.userModel(dto).save();
  }

  async updateUser(userId: any, dto: UpdateUserDto): Promise<User> {
    return this.userModel.findByIdAndUpdate(userId, dto, {
      new: true,
    });
  }
}

import { Test } from '@nestjs/testing';
import { USER_MODEL } from '../../constants/models';
import { User } from './interfaces/user.interface';
import { UserService } from './user.service';
import { getModelToken } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import userProviders from './providers';
import { DatabaseModule } from '../database/database.module';

describe('UserService', () => {
  let userService: UserService;
  let userModel: Model<User>;
  const token = getModelToken(USER_MODEL);

  beforeAll(async () => {
    const userModule = await Test.createTestingModule({
      imports: [DatabaseModule],
      providers: [UserService, ...userProviders],
    }).compile();

    userService = userModule.get<UserService>(UserService);
    userModel = userModule.get(token);
  });

  it('should get all users', async () => {
    const users = await userService.getUsers();
    expect(users).toEqual([]);
  });
});

user.service.ts

import { Module } from '@nestjs/common';
import { DatabaseModule } from '../database/database.module';
import { UserService } from './user.service';
import userProviders from './providers';

@Module({
  imports: [DatabaseModule],
  providers: [UserService, ...userProviders],
  exports: [UserService],
})
export class UserModule {}

import { Connection } from 'mongoose';

import { UserSchema } from '../schemas/user.schema';
import { USER_MODEL_PROVIDER, DB_PROVIDER } from '../../../constants/database';
import { Provider } from '@nestjs/common';
import { USER_MODEL } from '../../../constants/models';

export const userProvider: Provider = {
  provide: USER_MODEL_PROVIDER,
  useFactory: (connection: Connection) =>
    connection.model(USER_MODEL, UserSchema),
  inject: [DB_PROVIDER],
};

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

@Injectable()
export class UserService {
  constructor(
    @InjectModel(USER_MODEL)
    private readonly userModel: Model<User>,
  ) {}

  async getUsers(): Promise<User[]> {
    return this.userModel.find().exec();
  }

  async getUser(userId: any): Promise<User> {
    return this.userModel.findById(userId).exec();
  }

  async addUser(dto: CreateUserDto): Promise<User> {
    return new this.userModel(dto).save();
  }

  async updateUser(userId: any, dto: UpdateUserDto): Promise<User> {
    return this.userModel.findByIdAndUpdate(userId, dto, {
      new: true,
    });
  }
}

import { Test } from '@nestjs/testing';
import { USER_MODEL } from '../../constants/models';
import { User } from './interfaces/user.interface';
import { UserService } from './user.service';
import { getModelToken } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import userProviders from './providers';
import { DatabaseModule } from '../database/database.module';

describe('UserService', () => {
  let userService: UserService;
  let userModel: Model<User>;
  const token = getModelToken(USER_MODEL);

  beforeAll(async () => {
    const userModule = await Test.createTestingModule({
      imports: [DatabaseModule],
      providers: [UserService, ...userProviders],
    }).compile();

    userService = userModule.get<UserService>(UserService);
    userModel = userModule.get(token);
  });

  it('should get all users', async () => {
    const users = await userService.getUsers();
    expect(users).toEqual([]);
  });
});

从'@nestjs/common'导入{Injectable}；
从'@nestjs/mongoose'导入{InjectModel}；
从“猫鼬”导入{Model}；
从“./interfaces/User.interface”导入{User}；
从“../../constants/models”导入{USER_MODEL}；
从“./dto/create user.dto”导入{CreateUserDto}；
从“./dto/updateuser.dto”导入{UpdateUserDto}；
@可注射（）
导出类用户服务{
建造师(
@注入模型（用户模型）
私有只读用户模型：模型，
) {}
异步getUsers（）：承诺{
返回此.userModel.find（）.exec（）；
}
异步getUser（userId:any）：承诺{
返回这个.userModel.findById（userId.exec（）；
}
异步addUser（dto:CreateUserDto）：承诺{
返回新的this.userModel（dto.save（）；
}
异步updateUser（userId:any，dto:UpdateUserDto）：承诺{
返回此.userModel.findByIdAndUpdate（userId，dto{
新：没错，
});
}
}

user.service.spec.ts

import { Module } from '@nestjs/common';
import { DatabaseModule } from '../database/database.module';
import { UserService } from './user.service';
import userProviders from './providers';

@Module({
  imports: [DatabaseModule],
  providers: [UserService, ...userProviders],
  exports: [UserService],
})
export class UserModule {}

import { Connection } from 'mongoose';

import { UserSchema } from '../schemas/user.schema';
import { USER_MODEL_PROVIDER, DB_PROVIDER } from '../../../constants/database';
import { Provider } from '@nestjs/common';
import { USER_MODEL } from '../../../constants/models';

export const userProvider: Provider = {
  provide: USER_MODEL_PROVIDER,
  useFactory: (connection: Connection) =>
    connection.model(USER_MODEL, UserSchema),
  inject: [DB_PROVIDER],
};

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

@Injectable()
export class UserService {
  constructor(
    @InjectModel(USER_MODEL)
    private readonly userModel: Model<User>,
  ) {}

  async getUsers(): Promise<User[]> {
    return this.userModel.find().exec();
  }

  async getUser(userId: any): Promise<User> {
    return this.userModel.findById(userId).exec();
  }

  async addUser(dto: CreateUserDto): Promise<User> {
    return new this.userModel(dto).save();
  }

  async updateUser(userId: any, dto: UpdateUserDto): Promise<User> {
    return this.userModel.findByIdAndUpdate(userId, dto, {
      new: true,
    });
  }
}

import { Test } from '@nestjs/testing';
import { USER_MODEL } from '../../constants/models';
import { User } from './interfaces/user.interface';
import { UserService } from './user.service';
import { getModelToken } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import userProviders from './providers';
import { DatabaseModule } from '../database/database.module';

describe('UserService', () => {
  let userService: UserService;
  let userModel: Model<User>;
  const token = getModelToken(USER_MODEL);

  beforeAll(async () => {
    const userModule = await Test.createTestingModule({
      imports: [DatabaseModule],
      providers: [UserService, ...userProviders],
    }).compile();

    userService = userModule.get<UserService>(UserService);
    userModel = userModule.get(token);
  });

  it('should get all users', async () => {
    const users = await userService.getUsers();
    expect(users).toEqual([]);
  });
});

从'@nestjs/testing'导入{Test}；
从“../../constants/models”导入{USER_MODEL}；
从“./interfaces/User.interface”导入{User}；
从“/user.service”导入{UserService}；
从'@nestjs/mongoose'导入{getModelToken}；
从“猫鼬”导入{Model}；
从“./providers”导入用户提供程序；
从“../database/database.module”导入{DatabaseModule}；
描述（'UserService'，（）=>{
让userService:userService；
让userModel:Model；
const token=getModelToken（用户\模型）；
之前（异步（）=>{
const userModule=wait Test.createTestingModule({
导入：[数据库模块]，
提供者：[用户服务，…用户提供者]，
}).compile（）；
userService=userModule.get（userService）；
userModel=userModule.get（令牌）；
});
它（'should get all users'，async（）=>{
const users=await userService.getUsers（）；
期望（用户）。toEqual（[]）；
});
});

---

如何注入模型，使其在测试阶段可用？

问题已经解决

USER\u MODEL\u PROVIDER

包含与

USER\u MODEL

不同的值，因此

UserSchema

从未被注入。

问题已经解决

USER\u MODEL\u PROVIDER

包含与

USER\u MODEL

不同的值，因此

UserSchema

从未被注入