无法在 NestJs 服务上创建 Jest 测试模块。 获取 Nest 无法解析 UsersService (?, ConfigService) 的依赖关系

Question

it's my first time making questions on stackoverflow:).

So I'm developing a test / learning application to learn how to use NestJS and Vue. I am was currently trying to implement several server-side unit tests (using Jest). When trying to create a testingmodule from my UsersService I get the error below on running "npm test users.service.spec"

Nest can't resolve dependencies of the UsersService (?, ConfigService). Please make sure that the argument at index [0] is available in the _RootTestModule context.

at Injector.lookupComponentInExports (../node_modules/@nestjs/core/injector/injector.js:183:19)

I am not sure if I am incorrectly instantiating the test model, or misconceived the injection of config.service, the code itself works, but may be implemented incorrectly. Does anyone have any ideas how to solve this problem?

Git link: https://github.com/Lindul/FuelTracker_NestJs_MySql_Vue.git

users.service.spec.ts

import { Test } from '@nestjs/testing';
import { UsersService } from './users.service';
import { UserDto } from './dto/user.dto';
import { UserLoginRegRequestDto } from './dto/user-login-reg-request.dto';
import { ConfigService } from '../shared/config/config.service';
describe('User Service Tests', () => {

    let loginTeste: UserLoginRegRequestDto = {
        login: 'LoginJestTeste',
        password: 'PassJestTeste',
    }

    const userMock: UserDto = {
        id: 1,
        login: 'hugombsantos',
        password: 'wefewkfnwekfnwekjnf',
        isActive: true,
        needChangePass: false,
        userType: 0,

    };

    const dataFindAllMock: UserDto[] = [{
        id: 1,
        login: 'hugombsantos',
        password: 'wefewkfnwekfnwekjnf',
        isActive: true,
        needChangePass: false,
        userType: 0,

    }, {
        id: 2,
        login: 'user2',
        password: 'sdgsdgdsgsdgsgsdg',
        isActive: true,
        needChangePass: false,
        userType: 0,
    }];

    let service: UsersService;
    beforeEach(async () => {

        const module = await Test.createTestingModule({
            providers: [
                ConfigService,
                UsersService,
            ],
        }).compile();

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


    it('UsersService está defenido', () => {
        expect(service).toBeDefined();
    });   

});

user.service.ts

import { Injectable, Inject, HttpException, HttpStatus } from '@nestjs/common';
import { Users } from '../models/users.schema';
import { UserDto } from './dto/user.dto';
import { UserLoginRegRequestDto } from './dto/user-login-reg-request.dto';
import { UserLoginResponseDto } from './dto/user-login-response.dto';
import { sign } from 'jsonwebtoken';
import { ConfigService } from '../shared/config/config.service';
import { JwtPayload } from './auth/jwt-payload.model';
import { ErroMessageDto } from '../shared/config/dto/erro-message.dto';
import { UpdateUserDto } from './dto/update-user.dto';
import bcrypt = require('bcrypt-nodejs');
const SALT_FACTOR = 8;

@Injectable()
export class UsersService {

    constructor(
        @Inject('UsersRepository') private usersRepository: typeof Users,
        private readonly configService: ConfigService,
    ) { }

    /* istanbul ignore next */
    async findAll(): Promise<UserDto[]> {
        const users = await this.usersRepository.findAll<Users>();
        return users.map(user => {
            return new UserDto(user);
        });
    }
    /* istanbul ignore next */
    async findUser(id: number): Promise<Users> {
        const user = await this.usersRepository.findOne<Users>({
            where: { id },
        });
        return user;
    }
    /* istanbul ignore next */
    async findUserformLogin(login: string): Promise<UserDto> {
        return await this.usersRepository.findOne<Users>({
            where: { login },
        });
    }
    /* istanbul ignore next */
    async findUserforLogin(id: number, login: string): Promise<Users> {
        return await this.usersRepository.findOne<Users>({
            where: { id, login },
        });
    }
    /* istanbul ignore next */
    async creatUserOnDb(createUser: UserLoginRegRequestDto): Promise<Users> {
        try {
            const user = new Users();
            user.login = createUser.login;
            user.password = await this.hashPass(createUser.password);
            return await user.save();
        } catch (err) {
            if (err.original.code === 'ER_DUP_ENTRY') {
                throw new HttpException(
                    new ErroMessageDto(
                        HttpStatus.CONFLICT,
                        `Login '${err.errors[0].value}' already exists`),
                    HttpStatus.CONFLICT,
                );
            }
            throw new HttpException(
                new ErroMessageDto(
                    HttpStatus.INTERNAL_SERVER_ERROR,
                    err),
                HttpStatus.INTERNAL_SERVER_ERROR,
            );
        }
    }
    /* istanbul ignore next */
    async updateUserOnDb(user: Users): Promise<Users> {
        try {
            return await user.save();
        } catch (err) {
            if (err.original.code === 'ER_DUP_ENTRY') {
                throw new HttpException(
                    new ErroMessageDto(
                        HttpStatus.CONFLICT,
                        `Login '${err.errors[0].value}' already exists`),
                    HttpStatus.CONFLICT,
                );
            }
            throw new HttpException(
                new ErroMessageDto(
                    HttpStatus.INTERNAL_SERVER_ERROR,
                    err),
                HttpStatus.INTERNAL_SERVER_ERROR,
            );
        }
    }

    /* istanbul ignore next */
    async delete(id: number): Promise<UserDto> {
        const user = await this.findUser(+id);
        await user.destroy();
        return new UserDto(user);
    }

    async login(
        userLoginRequestDto: UserLoginRegRequestDto,
    ): Promise<UserLoginResponseDto> {

        const login = userLoginRequestDto.login;
        const password = userLoginRequestDto.password;
        const user = await this.findUserformLogin(login);

        if (!user) {
            throw new HttpException(
                new ErroMessageDto(
                    HttpStatus.UNAUTHORIZED,
                    'Invalid login or password.'),
                HttpStatus.UNAUTHORIZED,
            );
        }

        const isMatch = await this.comparePass(password, user.password);

        if (!isMatch) {
            throw new HttpException(
                new ErroMessageDto(
                    HttpStatus.UNAUTHORIZED,
                    'Invalid login or password.'),
                HttpStatus.UNAUTHORIZED,
            );
        }

        const token = await this.signToken(user);

        return new UserLoginResponseDto(token);
    }

    async create(createUser: UserLoginRegRequestDto): Promise<UserLoginResponseDto> {

        const userData = await this.creatUserOnDb(createUser);

        // when registering then log user in automatically by returning a token
        const token = await this.signToken(userData);

        return new UserLoginResponseDto(token);

    }

    async updateUser(id: number | string, updateUserDto: UpdateUserDto): Promise<UserLoginResponseDto> {

        const user = await this.findUser(+id);

        if (!user) {
            throw new HttpException(
                new ErroMessageDto(
                    HttpStatus.NOT_FOUND,
                    'User not found.'),
                HttpStatus.NOT_FOUND,
            );
        }

        user.login = updateUserDto.login || user.login;
        user.userType = updateUserDto.userType || user.userType;
        user.needChangePass = false;

        const isMatch = await this.comparePass(updateUserDto.password, user.password);
        if (updateUserDto.password && !isMatch) {
            user.password = await this.hashPass(updateUserDto.password);
        } else {
            user.password = user.password;
        }

        const userData = await this.updateUserOnDb(user);
        const token = await this.signToken(userData);

        return new UserLoginResponseDto(token);

    }

    async signToken(user: UserDto): Promise<string> {

        const payload: JwtPayload = {
            id: user.id,
            login: user.login,
        };
        const token = sign(payload, this.configService.jwtConfig.jwtPrivateKey,
            {
                expiresIn: this.configService.jwtConfig.valideTime,
            });
        return token;
    }

    async hashPass(passToHash: string): Promise<string> {
        const saltValue = await bcrypt.genSaltSync(SALT_FACTOR);
        return await bcrypt.hashSync(passToHash, saltValue);
    }

    async comparePass(passToCheck: string, correntPass: string) {
        return await bcrypt.compareSync(passToCheck, correntPass);
    }
}

users.modules.ts

import { Module } from '@nestjs/common';
import { UsersService } from './users.service';
import { UsersController } from './users.controller';
import {userProviders} from './users.providers';
import { DatabaseModule } from '../database/database.module';
import { JwtStrategy } from './auth/jwt-strategy';
import { ConfigService } from '../shared/config/config.service';

@Module({
  imports: [DatabaseModule, ConfigService],
  controllers: [UsersController],
  providers: [UsersService,
    ...userProviders, JwtStrategy],
  exports: [UsersService],

})

export class UsersModule {}

config.service.ts

import { Injectable } from '@nestjs/common';
import { JwtConfig } from './interfaces/jwt-config.interface';
import { config } from '../../../config/config.JwT';
import { config as dbConfigData } from '../../../config/config.db';
import { SequelizeOrmConfig } from './interfaces/sequelize-orm-config.interface';

@Injectable()
export class ConfigService {
    get sequelizeOrmConfig(): SequelizeOrmConfig {
        return dbConfigData.databaseOpt;
    }

    get jwtConfig(): JwtConfig {
        return {
            jwtPrivateKey: config.jwtPrivateKey,
            valideTime: config.valideTime,
        };
    }
}

Answer 1

You need to provide some value for Nest to inject for your UserRepository . It looks like you are using the TypeORM @InjectRepository() decorator, so in your testing module you'll need to add something like this under your providers

{
  provide: getRepositoryToken('UsersRepository'),
  useValue: MyMockUserRepo,
}

So that Nest can know what value to inject for that string. MyMockUserRepo would be your mock repository functionality, so that you aren't making actual database calls to your backend