fix unit testuser service

Author: vinodnextcoder

src/auth/auth.controller.spec.ts

@@ -0,0 +1,45 @@
+import { Test, TestingModule } from "@nestjs/testing";
+import { AuthController } from "./auth.controller";
+import { AuthService } from "./auth.service";
+
+
+describe("User Controller", () => {
+ let controller: AuthController;
+ let service: AuthService;
+ const mockUserRequest = {
+ password: "Sairam1@",
+ email: "te@test.com"
+ };
+ 
+
+ beforeEach(async () => {
+ const module: TestingModule = await Test.createTestingModule({
+ controllers: [AuthController],
+ providers: [
+ {
+ provide: AuthService,
+ useValue: {
+ signIn: jest.fn().mockResolvedValue(true)
+ },
+ },
+ ],
+ }).compile();
+
+ controller = module.get<AuthController>(AuthController);
+ service = module.get<AuthService>(AuthService);
+ });
+
+
+ describe("auth controller ()", () => {
+
+ it("should create access token", async () => {
+ let response = { access_token: "s" };
+ const createSpy = jest
+ .spyOn(service, "signIn")
+ .mockResolvedValueOnce(response);
+ await controller.signIn(mockUserRequest);
+ expect(createSpy).toHaveBeenCalled();
+ });
+
+ });
+});

src/auth/auth.controller.ts

@@ -18,12 +18,6 @@ export class AuthController {
  @HttpCode(HttpStatus.OK)
  @Post('login')
  signIn(@Body() signInDto: Record<string, any>) {
- 
  return this.authService.signIn(signInDto.email, signInDto.password);
  }
-
- @Get('profile')
- getProfile(@Request() req) {
- return req.user;
- }
 }

src/auth/auth.module.ts

@@ -14,7 +14,7 @@ import { AuthService } from './auth.service';
  JwtModule.register({
  global: true,
  secret: jwtConstants.secret,
- signOptions: { expiresIn: '60s' },
+ signOptions: { expiresIn: '60s' }
  }),
  ],
  providers: [

src/auth/auth.service.spec.ts

@@ -0,0 +1,78 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AuthService } from './auth.service';
+import { UserService } from '../users/users.service';
+import { JwtService } from '@nestjs/jwt';
+import * as bcrypt from 'bcrypt';
+import { UnauthorizedException } from '@nestjs/common/exceptions';
+
+
+const mockUser = {
+ email: 'test@example.com',
+ _id: '12345',
+ password: 'mockAccessToken', // Hashing the password
+};
+const authServiceResult = {
+ access_token: 'mockAccessToken', // Hashing the password
+};
+
+describe('AuthService', () => {
+ let authService: AuthService;
+ let userService: UserService;
+ let jwtService: JwtService;
+
+ beforeEach(async () => {
+ const module: TestingModule = await Test.createTestingModule({
+ providers: [
+ AuthService,
+ {
+ provide: AuthService,
+ useValue: {
+ signIn: jest.fn().mockResolvedValueOnce(authServiceResult)
+ .mockRejectedValueOnce( new UnauthorizedException()), // Error scenario
+ }
+ },
+ {
+ provide: UserService,
+ useValue: {
+ findOneUser: jest.fn().mockResolvedValue(authServiceResult)
+ }
+ },
+ {
+ provide: JwtService,
+ useValue: {
+ compare: jest.fn().mockRejectedValue(false),
+ signAsync: jest.fn().mockResolvedValue(true)
+ }
+ }
+ 
+ ],
+ }).compile();
+
+ authService = module.get<AuthService>(AuthService);
+ userService = module.get<UserService>(UserService);
+ jwtService = module.get<JwtService>(JwtService);
+ });
+
+ it('should sign in a user and return an access token', async () => {
+ 
+ jest.spyOn(userService, 'findOneUser').mockResolvedValue(mockUser);
+ jest.spyOn(bcrypt, 'compare').mockResolvedValue(true);
+ jest.spyOn(jwtService, 'signAsync').mockResolvedValue('access_token');
+
+ const result = await authService.signIn('test@example.com', 'password');
+
+ expect(result).toBeDefined();
+ });
+
+ it('should throw UnauthorizedException when passwords do not match', async () => {
+ const hashedPassword = await bcrypt.hash('password', 10);
+ const mockUser = {
+ email: 'test@example.com',
+ _id: '12345',
+ password: hashedPassword,
+ };
+ 
+ jest.spyOn(userService, 'findOneUser').mockResolvedValue(mockUser);
+ jest.spyOn(bcrypt, 'compare').mockResolvedValue(false); // Passwords do not match
+ });
+});

src/auth/auth.service.ts

@@ -8,20 +8,20 @@ import * as bcrypt from 'bcrypt';
 export class AuthService {
  constructor(
  private usersService: UserService,
- private jwtService: JwtService,
+ private jwtService: JwtService
  ) {}
 
  async signIn(email: string, pass: string) {
  const user = await this.usersService.findOneUser(email);
  const match = await bcrypt.compare(pass, user?.password);
- 
- if(match){
+
+ if (match) {
  const payload = { email: user.email, userId: user._id };
+ const access_token = await this.jwtService.signAsync(payload);
  return {
- access_token: await this.jwtService.signAsync(payload),
+ access_token
  };
  }
  throw new UnauthorizedException();
- 
  }
 }