How to test Nestjs - TypeORM and Postgres

Question

Coupled TypeORM, postgres and Nestjs, I'm struggling a bit to find the problem

users.controller.ts

import { Controller, Get, Param, Post, UseGuards } from '@nestjs/common';
import { UsersService } from './users.service';
import { User } from '../../entities/users.entity';
import { CreateUserDto, UpdateUserDto } from './dto/users.dto';
import { BodyDto } from '../../decorators/dto.decorators';
import { IReturnResponse } from '@/helpers/interfaces';
import { TokenGuard } from '@/providers/tokens/token.guard';

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Post('/register')
  registerUser(
    @BodyDto() createUserDto: CreateUserDto,
  ): Promise<User | IReturnResponse> {
    return this.usersService.userRegister(createUserDto);
  }
  @UseGuards(TokenGuard)
  @Post('/update')
  updateUser(
    @BodyDto() updateUserDto: Maybe<UpdateUserDto>,
  ): Promise<User | IReturnResponse> {
    console.log(updateUserDto);
    return this.usersService.updateUser(updateUserDto);
  }
}

users.service.ts

import {
  BadRequestException,
  Injectable,
  NotFoundException,
} from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import * as bcrypt from 'bcrypt';
import * as moment from 'moment';
import { CreateUserDto, UpdateUserDto } from './dto/users.dto';
import { User } from '../../entities/users.entity';
import { IReturnResponse, ITokensResponse } from '@/helpers/interfaces';
import {
  INTERNAL_ERROR,
  USER_NOT_FOUND,
} from '@/errors/httpErrorMessages.constants';

@Injectable()
export class UsersService {
  constructor(
    @InjectRepository(User) private readonly userRepository: Repository<User>,
  ) {}

  /**
   * Register Uuser
   * @param createUserDto
   * @returns promise of user
   */
  async userRegister(
    createUserDto: CreateUserDto,
  ): Promise<User | IReturnResponse> {
    console.log(createUserDto);
    try {
      const hashedPassword = await bcrypt.hash(createUserDto.password, 10);
      const createdAt = moment().format();
      const updatedAt = moment().format();
      const bodyUser = {
        ...createUserDto,
        password: hashedPassword,
        createdAt,
        updatedAt,
      };

      const userCreateResult = await this.userRepository.save(bodyUser);
      if (!userCreateResult) throw new BadRequestException(userCreateResult);

      return {
        code: 200,
        message: 'User successfully created !',
        data: userCreateResult,
      };
    } catch (error) {
      throw new BadRequestException(INTERNAL_ERROR);
    }
  }
.....

users.module.ts

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { UsersService } from './users.service';
import { UsersController } from './users.controller';
import { User } from '../../entities/users.entity';
import { TokensModule } from '@/providers/tokens/token.module';
import { ConfigService } from '@nestjs/config';

@Module({
  imports: [TypeOrmModule.forFeature([User]), TokensModule],
  controllers: [UsersController],
  providers: [UsersService, ConfigService],
})
export class UsersModule {}

users.controller.spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { UsersController } from '../../../../src/modules/users/users.controller';
import { UsersService } from '../../../../src/modules/users/users.service';

describe('UserController', () => {
  let controller: UsersController;
  let userRepository: Repository<User>;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      controllers: [UsersController],
      providers: [UsersService, userRepository],
    }).compile();

    controller = module.get<UsersController>(UsersController);
  });

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

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