@hedhog/admin 0.12.1 → 0.12.2

package/src/auth/auth.service.spec.ts

@@ -1,196 +1,196 @@
-import { MailService } from '@hedhog/mail';
-import { PrismaService } from '@hedhog/prisma';
-import { NotFoundException } from '@nestjs/common';
-import { JwtService } from '@nestjs/jwt';
-import { Test, TestingModule } from '@nestjs/testing';
-import { compare } from 'bcrypt';
-import { AuthService } from './auth.service';
-
-jest.mock('bcrypt');
-
-describe('AuthService', () => {
-  let authService: AuthService;
-  let prismaService: PrismaService;
-  let jwtService: JwtService;
-  let mailService: MailService;
-
-  beforeEach(async () => {
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [
-        AuthService,
-        {
-          provide: PrismaService,
-          useValue: {
-            user: {
-              findFirst: jest.fn(),
-              update: jest.fn(),
-              findUnique: jest.fn(),
-            },
-          },
-        },
-        {
-          provide: JwtService,
-          useValue: {
-            sign: jest.fn(),
-            verifyAsync: jest.fn(),
-            decode: jest.fn(),
-          },
-        },
-        {
-          provide: MailService,
-          useValue: {
-            send: jest.fn(),
-          },
-        },
-      ],
-    }).compile();
-
-    authService = module.get<AuthService>(AuthService);
-    prismaService = module.get<PrismaService>(PrismaService);
-    jwtService = module.get<JwtService>(JwtService);
-    mailService = module.get<MailService>(MailService);
-  });
-
-  it('should be defined', () => {
-    expect(authService).toBeDefined();
-  });
-
-  describe('loginWithEmailAndPassword', () => {
-    it('should throw NotFoundException if user is not found', async () => {
-      jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(null);
-
-      await expect(
-        authService.loginWithEmailAndPassword('test@example.com', 'password'),
-      ).rejects.toThrow(NotFoundException);
-    });
-
-    it('should throw NotFoundException if password is invalid', async () => {
-      const mockUser = {
-        id: 1,
-        name: 'Test User',
-        email: 'test@example.com',
-        password: 'hashedpassword',
-        multifactor_id: null,
-        code: null,
-        created_at: new Date(),
-        updated_at: new Date(),
-      };
-      jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(mockUser);
-      (compare as jest.Mock).mockResolvedValue(false);
-
-      await expect(
-        authService.loginWithEmailAndPassword('test@example.com', 'password'),
-      ).rejects.toThrow(NotFoundException);
-    });
-
-    it('should return a token if login is successful', async () => {
-      const mockUser = {
-        id: 1,
-        name: 'Test User',
-        email: 'test@example.com',
-        password: 'hashedpassword',
-        multifactor_id: null,
-        code: null,
-        created_at: new Date(),
-        updated_at: new Date(),
-      };
-      jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(mockUser);
-      (compare as jest.Mock).mockResolvedValue(true);
-      jest.spyOn(jwtService, 'sign').mockReturnValue('token');
-
-      const result = await authService.loginWithEmailAndPassword(
-        'test@example.com',
-        'password',
-      );
-
-      expect(result).toEqual({ token: 'token' });
-    });
-  });
-
-  describe('forget', () => {
-    it('should throw NotFoundException if user is not found', async () => {
-      jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(null);
-
-      await expect(
-        authService.forget({ email: 'test@example.com' }),
-      ).rejects.toThrow(NotFoundException);
-    });
-
-    it('should update user with reset code and send email', async () => {
-      const mockUser = {
-        id: 1,
-        name: 'Test User',
-        email: 'test@example.com',
-        password: 'hashedpassword',
-        multifactor_id: null,
-        code: null,
-        created_at: new Date(),
-        updated_at: new Date(),
-      };
-      jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(mockUser);
-      jest.spyOn(prismaService.user, 'update').mockResolvedValue(mockUser);
-      jest
-        .spyOn(authService, 'generateRandomString')
-        .mockReturnValue('resetCode');
-
-      const result = await authService.forget({ email: 'test@example.com' });
-
-      expect(prismaService.user.update).toHaveBeenCalledWith({
-        where: { id: 1 },
-        data: { code: 'resetCode' },
-      });
-      expect(mailService.send).toHaveBeenCalledWith({
-        to: 'test@example.com',
-        subject: 'Reset password',
-        body: `Reset your password by clicking <a href="${process.env.FRONTEND_URL}/reset-password/resetCode">here</a>`,
-      });
-      expect(result).toEqual(true);
-    });
-  });
-
-  describe('otp', () => {
-    it('should throw NotFoundException if user with code is not found', async () => {
-      jest.spyOn(jwtService, 'decode').mockReturnValue({ id: 1 });
-      jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(null);
-
-      await expect(
-        authService.otp({ token: 'token', code: 123456 }),
-      ).rejects.toThrow(NotFoundException);
-    });
-
-    it('should return a token if otp is valid', async () => {
-      const mockUser = {
-        id: 1,
-        name: 'Test User',
-        email: 'test@example.com',
-        password: 'hashedpassword',
-        multifactor_id: null,
-        code: null,
-        created_at: new Date(),
-        updated_at: new Date(),
-      };
-      jest.spyOn(jwtService, 'decode').mockReturnValue({ id: 1 });
-      jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(mockUser);
-      jest.spyOn(prismaService.user, 'update').mockResolvedValue(mockUser);
-      jest.spyOn(jwtService, 'sign').mockReturnValue('newToken');
-
-      const result = await authService.otp({ token: 'token', code: 123456 });
-
-      expect(prismaService.user.update).toHaveBeenCalledWith({
-        where: { id: 1 },
-        data: { code: null },
-      });
-      expect(result).toEqual({ token: 'newToken' });
-    });
-  });
-
-  describe('verifyToken', () => {
-    it('should verify and return token data', async () => {
-      jest.spyOn(jwtService, 'verifyAsync').mockResolvedValue({ id: 1 });
-
-      const result = await authService.verifyToken('token');
-
-      expect(result).toEqual({ id: 1 });
-    });
-  });
-});
+import { MailService } from '@hedhog/mail';
+import { PrismaService } from '@hedhog/prisma';
+import { NotFoundException } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import { Test, TestingModule } from '@nestjs/testing';
+import { compare } from 'bcrypt';
+import { AuthService } from './auth.service';
+
+jest.mock('bcrypt');
+
+describe('AuthService', () => {
+  let authService: AuthService;
+  let prismaService: PrismaService;
+  let jwtService: JwtService;
+  let mailService: MailService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        AuthService,
+        {
+          provide: PrismaService,
+          useValue: {
+            user: {
+              findFirst: jest.fn(),
+              update: jest.fn(),
+              findUnique: jest.fn(),
+            },
+          },
+        },
+        {
+          provide: JwtService,
+          useValue: {
+            sign: jest.fn(),
+            verifyAsync: jest.fn(),
+            decode: jest.fn(),
+          },
+        },
+        {
+          provide: MailService,
+          useValue: {
+            send: jest.fn(),
+          },
+        },
+      ],
+    }).compile();
+
+    authService = module.get<AuthService>(AuthService);
+    prismaService = module.get<PrismaService>(PrismaService);
+    jwtService = module.get<JwtService>(JwtService);
+    mailService = module.get<MailService>(MailService);
+  });
+
+  it('should be defined', () => {
+    expect(authService).toBeDefined();
+  });
+
+  describe('loginWithEmailAndPassword', () => {
+    it('should throw NotFoundException if user is not found', async () => {
+      jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(null);
+
+      await expect(
+        authService.loginWithEmailAndPassword('test@example.com', 'password'),
+      ).rejects.toThrow(NotFoundException);
+    });
+
+    it('should throw NotFoundException if password is invalid', async () => {
+      const mockUser = {
+        id: 1,
+        name: 'Test User',
+        email: 'test@example.com',
+        password: 'hashedpassword',
+        multifactor_id: null,
+        code: null,
+        created_at: new Date(),
+        updated_at: new Date(),
+      };
+      jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(mockUser);
+      (compare as jest.Mock).mockResolvedValue(false);
+
+      await expect(
+        authService.loginWithEmailAndPassword('test@example.com', 'password'),
+      ).rejects.toThrow(NotFoundException);
+    });
+
+    it('should return a token if login is successful', async () => {
+      const mockUser = {
+        id: 1,
+        name: 'Test User',
+        email: 'test@example.com',
+        password: 'hashedpassword',
+        multifactor_id: null,
+        code: null,
+        created_at: new Date(),
+        updated_at: new Date(),
+      };
+      jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(mockUser);
+      (compare as jest.Mock).mockResolvedValue(true);
+      jest.spyOn(jwtService, 'sign').mockReturnValue('token');
+
+      const result = await authService.loginWithEmailAndPassword(
+        'test@example.com',
+        'password',
+      );
+
+      expect(result).toEqual({ token: 'token' });
+    });
+  });
+
+  describe('forget', () => {
+    it('should throw NotFoundException if user is not found', async () => {
+      jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(null);
+
+      await expect(
+        authService.forget({ email: 'test@example.com' }),
+      ).rejects.toThrow(NotFoundException);
+    });
+
+    it('should update user with reset code and send email', async () => {
+      const mockUser = {
+        id: 1,
+        name: 'Test User',
+        email: 'test@example.com',
+        password: 'hashedpassword',
+        multifactor_id: null,
+        code: null,
+        created_at: new Date(),
+        updated_at: new Date(),
+      };
+      jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(mockUser);
+      jest.spyOn(prismaService.user, 'update').mockResolvedValue(mockUser);
+      jest
+        .spyOn(authService, 'generateRandomString')
+        .mockReturnValue('resetCode');
+
+      const result = await authService.forget({ email: 'test@example.com' });
+
+      expect(prismaService.user.update).toHaveBeenCalledWith({
+        where: { id: 1 },
+        data: { code: 'resetCode' },
+      });
+      expect(mailService.send).toHaveBeenCalledWith({
+        to: 'test@example.com',
+        subject: 'Reset password',
+        body: `Reset your password by clicking <a href="${process.env.FRONTEND_URL}/reset-password/resetCode">here</a>`,
+      });
+      expect(result).toEqual(true);
+    });
+  });
+
+  describe('otp', () => {
+    it('should throw NotFoundException if user with code is not found', async () => {
+      jest.spyOn(jwtService, 'decode').mockReturnValue({ id: 1 });
+      jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(null);
+
+      await expect(
+        authService.otp({ token: 'token', code: 123456 }),
+      ).rejects.toThrow(NotFoundException);
+    });
+
+    it('should return a token if otp is valid', async () => {
+      const mockUser = {
+        id: 1,
+        name: 'Test User',
+        email: 'test@example.com',
+        password: 'hashedpassword',
+        multifactor_id: null,
+        code: null,
+        created_at: new Date(),
+        updated_at: new Date(),
+      };
+      jest.spyOn(jwtService, 'decode').mockReturnValue({ id: 1 });
+      jest.spyOn(prismaService.user, 'findFirst').mockResolvedValue(mockUser);
+      jest.spyOn(prismaService.user, 'update').mockResolvedValue(mockUser);
+      jest.spyOn(jwtService, 'sign').mockReturnValue('newToken');
+
+      const result = await authService.otp({ token: 'token', code: 123456 });
+
+      expect(prismaService.user.update).toHaveBeenCalledWith({
+        where: { id: 1 },
+        data: { code: null },
+      });
+      expect(result).toEqual({ token: 'newToken' });
+    });
+  });
+
+  describe('verifyToken', () => {
+    it('should verify and return token data', async () => {
+      jest.spyOn(jwtService, 'verifyAsync').mockResolvedValue({ id: 1 });
+
+      const result = await authService.verifyToken('token');
+
+      expect(result).toEqual({ id: 1 });
+    });
+  });
+});