fix unit test

Author: vinodnextcoder

src/auth/auth.service.spec.ts

@@ -3,7 +3,7 @@ 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";
+import { UnauthorizedException, ForbiddenException } from "@nestjs/common";
 
 const mockUser = {
  email: "test@example.com",
@@ -31,6 +31,8 @@ describe("AuthService", () => {
  provide: UserService,
  useValue: {
  findOneUser: jest.fn().mockResolvedValue(mockUser),
+ findOne: jest.fn().mockResolvedValue({ ...mockUser, hashdRt: hashedPassword }),
+ updateOne: jest.fn().mockResolvedValue(true),
  },
  },
  {
@@ -52,32 +54,77 @@ describe("AuthService", () => {
  jwtService = module.get<JwtService>(JwtService);
  });
 
- it("should sign in a user and return an access token", async () => {
- const spyFindOneUser = jest
- .spyOn(userService, "findOneUser")
- .mockResolvedValue(mockUser);
+ describe("signIn", () => {
+ it("should sign in a user and return an access token", async () => {
+ const spyFindOneUser = jest
+ .spyOn(userService, "findOneUser")
+ .mockResolvedValue(mockUser);
 
- const spyCompare = jest.spyOn(bcrypt, "compare").mockReturnValue(true);
+  const spyCompare = jest.spyOn(bcrypt, "compare").mockReturnValue(true);
 
- const spySignAsync = jest
- .spyOn(jwtService, "signAsync")
- .mockResolvedValue("access_token");
+  const spySignAsync = jest
+  .spyOn(jwtService, "signAsync")
+  .mockResolvedValue("access_token");
 
- await authService.signIn("test@example.com", "password");
- expect(spyFindOneUser).toHaveBeenCalledWith("test@example.com");
- expect(spyCompare).toHaveBeenCalledWith("password", mockUser.password);
+ await authService.signIn("test@example.com", "password");
+ expect(spyFindOneUser).toHaveBeenCalledWith("test@example.com");
+ expect(spyCompare).toHaveBeenCalledWith("password", mockUser.password);
+ expect(spySignAsync).toHaveBeenCalled();
+ });
+
+ it("should throw UnauthorizedException when passwords do not match", async () => {
+ jest.spyOn(userService, "findOneUser").mockResolvedValue({
+ ...mockUser,
+ password: hashedPassword, // Use hashed password
+ });
+
+ jest.spyOn(bcrypt, "compare").mockReturnValue(false); // Passwords do not match
+
+ await expect(
+ authService.signIn("test@example.com", "wrongpassword")
+ ).rejects.toThrowError(UnauthorizedException);
+ });
  });
 
- it("should throw UnauthorizedException when passwords do not match", async () => {
- jest.spyOn(userService, "findOneUser").mockResolvedValue({
- ...mockUser,
- password: hashedPassword, // Use hashed password
+ describe("refreshTokens", () => {
+ it("should refresh tokens for a user", async () => {
+ const mockUserId = "12345";
+ const mockRefreshToken = "mockRefreshToken";
+
+ jest.spyOn(bcrypt, "compare").mockReturnValue(true); // Tokens match
+
+ jest.spyOn(authService, "getTokens").mockResolvedValue(expectedResponse);
+
+ const tokens = await authService.refreshTokens(mockUserId, mockRefreshToken);
+
+ expect(tokens).toEqual(expectedResponse);
+ expect(userService.updateOne).toHaveBeenCalledWith(
+ mockUser._id,
+ expect.objectContaining({ hashdRt: expect.any(String) })
+ );
+ });
+
+ it("should throw ForbiddenException when user or hashed refresh token is invalid", async () => {
+ jest.spyOn(userService, "findOne").mockResolvedValue(null); // Invalid user
+
+ await expect(
+ authService.refreshTokens("invalidUserId", "invalidRefreshToken")
+ ).rejects.toThrowError(new ForbiddenException('Access Denied.'));
+
+ jest.spyOn(userService, "findOne").mockResolvedValue({ ...mockUser, hashdRt: "invalidHashedRT" }); // Invalid hashed refresh token
+
+ await expect(
+ authService.refreshTokens(mockUser._id, "invalidRefreshToken")
+ ).rejects.toThrowError(new ForbiddenException('data must be a string or Buffer and salt must either be a salt string or a number of rounds'));
  });
+ });
 
- jest.spyOn(bcrypt, "compare").mockReturnValue(false); // Passwords do not match
+ describe("hashPassword", () => {
+ it("should hash password correctly", async () => {
+ const plainPassword = "password";
+ const hashed = await authService.hashPassword(plainPassword);
 
- await expect(
- authService.signIn("test@example.com", "wrongpassword")
- ).rejects.toThrowError(UnauthorizedException);
+ expect(bcrypt.compareSync(plainPassword, hashed)).toBe(true);
+ });
  });
-});
+});