@tomei/sso 0.34.2 → 0.34.6

package/__tests__/unit/components/login-user/login.spec.ts

@@ -58,7 +58,11 @@ describe('LoginUser', () => {
         .spyOn(UserRepository.prototype, 'findOne')
         .mockResolvedValueOnce(user as any);
 
-      const result = await LoginUser.init(sessionService, userId, dbTransaction);
+      const result = await LoginUser.init(
+        sessionService,
+        userId,
+        dbTransaction,
+      );
 
       expect(findOneMock).toHaveBeenCalledTimes(1);
       expect(findOneMock).toHaveBeenCalledWith({
@@ -77,7 +81,9 @@ describe('LoginUser', () => {
       expect(result.Email).toBe(user.Email);
       expect(result.Password).toBe(user.Password);
       expect(result.Status).toBe(user.Status);
-      expect(result.DefaultPasswordChangedYN).toBe(user.DefaultPasswordChangedYN);
+      expect(result.DefaultPasswordChangedYN).toBe(
+        user.DefaultPasswordChangedYN,
+      );
       expect(result.FirstLoginAt).toBe(user.FirstLoginAt);
       expect(result.LastLoginAt).toBe(user.LastLoginAt);
       expect(result.MFAEnabled).toBe(user.MFAEnabled);
@@ -98,7 +104,9 @@ describe('LoginUser', () => {
         .spyOn(UserRepository.prototype, 'findOne')
         .mockResolvedValueOnce(null);
 
-      await expect(LoginUser.init(sessionService, userId, dbTransaction)).rejects.toThrow(Error);
+      await expect(
+        LoginUser.init(sessionService, userId, dbTransaction),
+      ).rejects.toThrow(Error);
 
       expect(findOneMock).toHaveBeenCalledTimes(1);
       expect(findOneMock).toHaveBeenCalledWith({
@@ -114,57 +122,71 @@ describe('LoginUser', () => {
     });
   });
 
-  describe('checkSession', () => {
-    it('should throw an error if session expired', async () => {
-      // Arrange
-      const systemCode = 'EZC';
-      const sessionId = 'ckymxuh8t000137t011w89zgk';
-      const userId = '755';
-      const sessionService = await SessionService.init();
-      const loginUser = await LoginUser.init(sessionService);
-
-      // Act
-      const checkSessionPromise = loginUser.checkSession(systemCode, sessionId, userId);
-
-      // Assert
-      await expect(checkSessionPromise).rejects.toThrow('Session expired.');
-    });
-
-    it('should refresh the session duration if session is valid', async () => {
-      // Arrange
-      const systemCode = 'EZC';
-      const sessionId = 'ckymxuh8t000137t011w89zgk';
-      const userId = '755';
-      const sessionService = await SessionService.init();
-      const loginUser = await LoginUser.init(sessionService);
-
-      // Mock the _SessionService.retrieveUserSession method
-      loginUser['_SessionService'].retrieveUserSession = jest.fn().mockResolvedValue({
-        systemLogins: [
-          {
-            code: systemCode,
-            sessionId: sessionId,
-            privileges: [],
-          },
-        ],
-      });
-
-      // Mock the _SessionService.refreshDuration method
-      loginUser['_SessionService'].refreshDuration = jest.fn();
-
-      // Act
-      const systemLogin = await loginUser.checkSession(systemCode, sessionId, userId);
-
-      // Assert
-      expect(loginUser['_SessionService'].retrieveUserSession).toHaveBeenCalledWith(userId);
-      expect(loginUser['_SessionService'].refreshDuration).toHaveBeenCalledWith(userId);
-      expect(systemLogin).toEqual({
-        code: systemCode,
-        sessionId: sessionId,
-        privileges: [],
-      });
-    });
-  });
+  // describe('checkSession', () => {
+  //   it('should throw an error if session expired', async () => {
+  //     // Arrange
+  //     const systemCode = 'EZC';
+  //     const sessionId = 'ckymxuh8t000137t011w89zgk';
+  //     const userId = '755';
+  //     const sessionService = await SessionService.init();
+  //     const loginUser = await LoginUser.init(sessionService);
+
+  //     // Act
+  //     const checkSessionPromise = loginUser.checkSession(
+  //       systemCode,
+  //       sessionId,
+  //       userId,
+  //     );
+
+  //     // Assert
+  //     await expect(checkSessionPromise).rejects.toThrow('Session expired.');
+  //   });
+
+  //   it('should refresh the session duration if session is valid', async () => {
+  //     // Arrange
+  //     const systemCode = 'EZC';
+  //     const sessionId = 'ckymxuh8t000137t011w89zgk';
+  //     const userId = '755';
+  //     const sessionService = await SessionService.init();
+  //     const loginUser = await LoginUser.init(sessionService);
+
+  //     // Mock the _SessionService.retrieveUserSession method
+  //     loginUser['_SessionService'].retrieveUserSession = jest
+  //       .fn()
+  //       .mockResolvedValue({
+  //         systemLogins: [
+  //           {
+  //             code: systemCode,
+  //             sessionId: sessionId,
+  //             privileges: [],
+  //           },
+  //         ],
+  //       });
+
+  //     // Mock the _SessionService.refreshDuration method
+  //     loginUser['_SessionService'].refreshDuration = jest.fn();
+
+  //     // Act
+  //     const systemLogin = await loginUser.checkSession(
+  //       systemCode,
+  //       sessionId,
+  //       userId,
+  //     );
+
+  //     // Assert
+  //     expect(
+  //       loginUser['_SessionService'].retrieveUserSession,
+  //     ).toHaveBeenCalledWith(userId);
+  //     expect(loginUser['_SessionService'].refreshDuration).toHaveBeenCalledWith(
+  //       userId,
+  //     );
+  //     expect(systemLogin).toEqual({
+  //       code: systemCode,
+  //       sessionId: sessionId,
+  //       privileges: [],
+  //     });
+  //   });
+  // });
 
   describe('shouldReleaseLock', () => {
     const minuteToAutoRelease = 5;
@@ -224,7 +246,9 @@ describe('LoginUser', () => {
       const UserId = 1;
       const dbTransaction = null;
 
-      const updateMock = jest.spyOn(LoginUser['_Repository'], 'update').mockImplementationOnce(() => Promise.resolve({}) as any);
+      const updateMock = jest
+        .spyOn(LoginUser['_Repository'], 'update')
+        .mockImplementationOnce(() => Promise.resolve({}) as any);
 
       // Call the method under test
       LoginUser['releaseLock'](UserId, dbTransaction);
@@ -241,7 +265,7 @@ describe('LoginUser', () => {
             UserId,
           },
           transaction: dbTransaction,
-        }
+        },
       );
     });
   });
@@ -258,10 +282,14 @@ describe('LoginUser', () => {
       };
 
       // Mock the LoginUser['_Repository'].findAll method to return a user
-      jest.spyOn(LoginUser['_Repository'], 'findAll').mockResolvedValueOnce([{ id: 1 }] as any);
+      jest
+        .spyOn(LoginUser['_Repository'], 'findAll')
+        .mockResolvedValueOnce([{ id: 1 }] as any);
 
       // Assert that the method throws an error
-      await expect(LoginUser['checkUserInfoDuplicated'](dbTransaction, query)).rejects.toThrowError();
+      await expect(
+        LoginUser['checkUserInfoDuplicated'](dbTransaction, query),
+      ).rejects.toThrowError();
     });
 
     it('should not throw an error if duplicate user info is not found', async () => {
@@ -278,7 +306,9 @@ describe('LoginUser', () => {
       jest.spyOn(LoginUser['_Repository'], 'findAll').mockResolvedValueOnce([]);
 
       // Assert that the method does not throw an error
-      await expect(LoginUser['checkUserInfoDuplicated'](dbTransaction, query)).resolves.not.toThrowError();
+      await expect(
+        LoginUser['checkUserInfoDuplicated'](dbTransaction, query),
+      ).resolves.not.toThrowError();
     });
   });
 
@@ -292,11 +322,13 @@ describe('LoginUser', () => {
       numOfSpecialChars: 1,
     };
     beforeEach(() => {
-      jest.spyOn(ComponentConfig, 'getComponentConfigValue').mockImplementation((componentName: string, configKey: string) => {
-        if (configKey === 'passwordPolicy') {
-          return passwordPolicy as any;
-        }
-      });
+      jest
+        .spyOn(ComponentConfig, 'getComponentConfigValue')
+        .mockImplementation((componentName: string, configKey: string) => {
+          if (configKey === 'passwordPolicy') {
+            return passwordPolicy as any;
+          }
+        });
     });
 
     it('should generate a default password with the specified length', () => {
@@ -323,7 +355,9 @@ describe('LoginUser', () => {
     it('should generate a default password without any non-acceptable characters', () => {
       const password = LoginUser['generateDefaultPassword']();
       const nonAcceptableChars = ['i', 'l', 'o'];
-      expect(nonAcceptableChars.some(char => password.includes(char))).toBe(false);
+      expect(nonAcceptableChars.some((char) => password.includes(char))).toBe(
+        false,
+      );
     });
   });
 
@@ -337,11 +371,13 @@ describe('LoginUser', () => {
       numOfSpecialChars: 1,
     };
     beforeEach(() => {
-      jest.spyOn(ComponentConfig, 'getComponentConfigValue').mockImplementation((componentName: string, configKey: string) => {
-        if (configKey === 'passwordPolicy') {
-          return passwordPolicy as any;
-        }
-      });
+      jest
+        .spyOn(ComponentConfig, 'getComponentConfigValue')
+        .mockImplementation((componentName: string, configKey: string) => {
+          if (configKey === 'passwordPolicy') {
+            return passwordPolicy as any;
+          }
+        });
     });
 
     it('should set the password for the user', async () => {
@@ -352,11 +388,17 @@ describe('LoginUser', () => {
       const password = 'N3wP@ssw0';
 
       // Act
-      const result = await LoginUser['setPassword'](dbTransaction, user, password);
+      const result = await LoginUser['setPassword'](
+        dbTransaction,
+        user,
+        password,
+      );
 
       // Assert
       expect(result).toBeInstanceOf(LoginUser);
-      await expect(LoginUser['setPassword'](dbTransaction, user, password)).resolves.not.toThrowError();
+      await expect(
+        LoginUser['setPassword'](dbTransaction, user, password),
+      ).resolves.not.toThrowError();
       expect(result.Password).toBeDefined();
     });
 
@@ -368,217 +410,212 @@ describe('LoginUser', () => {
       const password = 'weakpassword';
 
       // Act & Assert
-      await expect(LoginUser['setPassword'](dbTransaction, user, password)).rejects.toThrow();
-    });
-  });
-
-  describe('create', () => {
-    let loginUser: LoginUser;
-    let dbTransaction: any;
-    let user: LoginUser;
-    let newUser: any;
-
-    beforeEach(async () => {
-      const sessionService = await SessionService.init();
-      loginUser = await LoginUser.init(sessionService);
-      dbTransaction = null;
-      newUser = {
-        UserId: 1,
-        FullName: 'John Doe',
-        Email: 'john.doe@example.com',
-        Password: 'password',
-        Status: 'Active',
-        DefaultPasswordChangedYN: 'N',
-        FirstLoginAt: null,
-        LastLoginAt: null,
-        MFAEnabled: null,
-        MFAConfig: null,
-        RecoveryEmail: null,
-        FailedLoginAttemptCount: 0,
-        LastFailedLoginAt: null,
-        LastPasswordChangedAt: new Date(),
-        NeedToChangePasswordYN: 'N',
-        CreatedById: 1,
-        CreatedAt: new Date(),
-        UpdatedById: 1,
-        UpdatedAt: new Date(),
-        Staff: {
-          FullName: 'John Doe',
-          IdNo: '1234567890',
-          Mobile: '1234567890',
-        },
-      };
-      user = new (LoginUser as any)(sessionService, null, newUser);
-    });
-
-    afterEach(() => {
-      jest.clearAllMocks();
-    });
-
-    it('should create a new user record', async () => {
-      const checkPrivilegesMock = jest
-        .spyOn(loginUser, 'checkPrivileges')
-        .mockResolvedValueOnce(true);
-
-      const checkUserInfoDuplicatedMock = jest
-        .spyOn((LoginUser as any), 'checkUserInfoDuplicated')
-        .mockResolvedValueOnce(undefined);
-
-      const generateDefaultPasswordMock = jest
-        .spyOn((LoginUser as any), 'generateDefaultPassword')
-        .mockReturnValueOnce('defaultPassword');
-
-      const setPasswordMock = jest
-        .spyOn((LoginUser as any), 'setPassword')
-        .mockResolvedValueOnce(user);
-
-      const createMock = jest
-        .spyOn((LoginUser as any)['_Repository'], 'create')
-        .mockResolvedValueOnce({
-          ...newUser,
-          get: () => newUser,
-        });
-
-      const activityCreateMock = jest
-        .spyOn((Activity as any).prototype, 'create')
-        .mockResolvedValueOnce(undefined);
-
-
-      jest.spyOn(ApplicationConfig, 'getComponentConfigValue').mockImplementation((configKey: string) => {
-        if (configKey === 'system-code') {
-          return 'SC';
-        }
-      });
-
-
-      const result = await LoginUser.create(loginUser, dbTransaction, user);
-
-      expect(checkPrivilegesMock).toHaveBeenCalledTimes(1);
-      expect(checkPrivilegesMock).toHaveBeenCalledWith(
-        ApplicationConfig.getComponentConfigValue('system-code'),
-        'User - Create'
-      );
-
-      expect(checkUserInfoDuplicatedMock).toHaveBeenCalledTimes(1);
-      expect(checkUserInfoDuplicatedMock).toHaveBeenCalledWith(
-        dbTransaction,
-        {
-          Email: user.Email,
-          IdType: user.IDType,
-          IdNo: user.IDNo,
-          ContactNo: user.ContactNo,
-        }
-      );
-
-      expect(generateDefaultPasswordMock).toHaveBeenCalledTimes(1);
-
-      expect(setPasswordMock).toHaveBeenCalledTimes(1);
-      expect(setPasswordMock).toHaveBeenCalledWith(
-        dbTransaction,
-        user,
-        'defaultPassword'
-      );
-
-      expect(createMock).toHaveBeenCalledTimes(1);
-
-      const userInfo = {
-        FullName: user.FullName,
-        IDNo: user.IDNo,
-        Email: user.Email,
-        ContactNo: user.ContactNo,
-        Password: user.Password,
-        Status: UserStatus.ACTIVE,
-        FirstLoginAt: null,
-        LastLoginAt: null,
-        MFAEnabled: null,
-        MFAConfig: null,
-        RecoveryEmail: null,
-        FailedLoginAttemptCount: 0,
-        LastFailedLoginAt: null,
-        LastPasswordChangedAt: null,
-        DefaultPasswordChangedYN: YN.No,
-        NeedToChangePasswordYN: YN.Yes,
-        CreatedById: loginUser.UserId,
-        CreatedAt: new Date(),
-        UpdatedById: loginUser.UserId,
-        UpdatedAt: new Date(),
-        UserId: null,
-      };
-
-      expect(createMock).toHaveBeenCalledWith(
-        {
-          Email: userInfo.Email,
-          Password: userInfo.Password,
-          Status: userInfo.Status,
-          DefaultPasswordChangedYN: userInfo.DefaultPasswordChangedYN,
-          FirstLoginAt: userInfo.FirstLoginAt,
-          LastLoginAt: userInfo.LastLoginAt,
-          MFAEnabled: userInfo.MFAEnabled,
-          MFAConfig: userInfo.MFAConfig,
-          RecoveryEmail: userInfo.RecoveryEmail,
-          FailedLoginAttemptCount: userInfo.FailedLoginAttemptCount,
-          LastFailedLoginAt: userInfo.LastFailedLoginAt,
-          LastPasswordChangedAt: userInfo.LastPasswordChangedAt,
-          NeedToChangePasswordYN: userInfo.NeedToChangePasswordYN,
-          CreatedById: userInfo.CreatedById,
-          CreatedAt: expect.any(Date),
-          UpdatedById: userInfo.UpdatedById,
-          UpdatedAt: expect.any(Date),
-        },
-        {
-          transaction: dbTransaction,
-        }
-      );
-
-      expect(activityCreateMock).toHaveBeenCalledTimes(1);
-
-      expect(result).toBeInstanceOf(LoginUser);
-      expect(result.Email).toBe(userInfo.Email);
-      expect(result.Password).toBe(userInfo.Password);
-      expect(result.Status).toBe(userInfo.Status);
-      expect(result.DefaultPasswordChangedYN).toBe(
-        userInfo.DefaultPasswordChangedYN
-      );
-      expect(result.FirstLoginAt).toBe(null);
-      expect(result.LastLoginAt).toBe(null);
-      expect(result.MFAEnabled).toBe(userInfo.MFAEnabled);
-      expect(result.MFAConfig).toBe(userInfo.MFAConfig);
-      expect(result.RecoveryEmail).toBe(userInfo.RecoveryEmail);
-      expect(result.FailedLoginAttemptCount).toBe(
-        userInfo.FailedLoginAttemptCount
-      );
-      expect(result.LastFailedLoginAt).toBe(userInfo.LastFailedLoginAt);
-      expect(result.LastPasswordChangedAt).toBe(userInfo.LastPasswordChangedAt);
-      expect(result.NeedToChangePasswordYN).toBe(
-        userInfo.NeedToChangePasswordYN
-      );
-      expect(result.CreatedById).toBe(userInfo.CreatedById);
-      expect(result.UpdatedById).toBe(userInfo.UpdatedById);
-    });
-
-    it('should throw an error if user dont have the privilege to create new user', async () => {
-      jest
-        .spyOn(loginUser, 'checkPrivileges')
-        .mockResolvedValueOnce(false);
-
       await expect(
-        LoginUser.create(loginUser, dbTransaction, user)
-      ).rejects.toThrow(ClassError);
-    });
-
-    it('should throw an error if user email is missing', async () => {
-      user.Email = undefined;
-
-      jest
-        .spyOn(loginUser, 'checkPrivileges')
-        .mockResolvedValueOnce(true);
-
-      await expect(
-        LoginUser.create(loginUser, dbTransaction, user)
-      ).rejects.toThrow(ClassError);
+        LoginUser['setPassword'](dbTransaction, user, password),
+      ).rejects.toThrow();
     });
   });
 
+  // describe('create', () => {
+  //   let loginUser: LoginUser;
+  //   let dbTransaction: any;
+  //   let user: LoginUser;
+  //   let newUser: any;
+
+  //   beforeEach(async () => {
+  //     const sessionService = await SessionService.init();
+  //     loginUser = await LoginUser.init(sessionService);
+  //     dbTransaction = null;
+  //     newUser = {
+  //       UserId: 1,
+  //       FullName: 'John Doe',
+  //       Email: 'john.doe@example.com',
+  //       Password: 'password',
+  //       Status: 'Active',
+  //       DefaultPasswordChangedYN: 'N',
+  //       FirstLoginAt: null,
+  //       LastLoginAt: null,
+  //       MFAEnabled: null,
+  //       MFAConfig: null,
+  //       RecoveryEmail: null,
+  //       FailedLoginAttemptCount: 0,
+  //       LastFailedLoginAt: null,
+  //       LastPasswordChangedAt: new Date(),
+  //       NeedToChangePasswordYN: 'N',
+  //       CreatedById: 1,
+  //       CreatedAt: new Date(),
+  //       UpdatedById: 1,
+  //       UpdatedAt: new Date(),
+  //       Staff: {
+  //         FullName: 'John Doe',
+  //         IdNo: '1234567890',
+  //         Mobile: '1234567890',
+  //       },
+  //     };
+  //     user = new (LoginUser as any)(sessionService, null, newUser);
+  //   });
+
+  //   afterEach(() => {
+  //     jest.clearAllMocks();
+  //   });
+
+  //   it('should create a new user record', async () => {
+  //     const checkPrivilegesMock = jest
+  //       .spyOn(loginUser, 'checkPrivileges')
+  //       .mockResolvedValueOnce(true);
+
+  //     const checkUserInfoDuplicatedMock = jest
+  //       .spyOn(LoginUser as any, 'checkUserInfoDuplicated')
+  //       .mockResolvedValueOnce(undefined);
+
+  //     const generateDefaultPasswordMock = jest
+  //       .spyOn(LoginUser as any, 'generateDefaultPassword')
+  //       .mockReturnValueOnce('defaultPassword');
+
+  //     const setPasswordMock = jest
+  //       .spyOn(LoginUser as any, 'setPassword')
+  //       .mockResolvedValueOnce(user);
+
+  //     const createMock = jest
+  //       .spyOn((LoginUser as any)['_Repository'], 'create')
+  //       .mockResolvedValueOnce({
+  //         ...newUser,
+  //         get: () => newUser,
+  //       });
+
+  //     const activityCreateMock = jest
+  //       .spyOn((Activity as any).prototype, 'create')
+  //       .mockResolvedValueOnce(undefined);
+
+  //     jest
+  //       .spyOn(ApplicationConfig, 'getComponentConfigValue')
+  //       .mockImplementation((configKey: string) => {
+  //         if (configKey === 'system-code') {
+  //           return 'SC';
+  //         }
+  //       });
+
+  //     const result = await LoginUser.create(loginUser, dbTransaction, user);
+
+  //     expect(checkPrivilegesMock).toHaveBeenCalledTimes(1);
+  //     expect(checkPrivilegesMock).toHaveBeenCalledWith(
+  //       ApplicationConfig.getComponentConfigValue('system-code'),
+  //       'User - Create',
+  //     );
+
+  //     expect(checkUserInfoDuplicatedMock).toHaveBeenCalledTimes(1);
+  //     expect(checkUserInfoDuplicatedMock).toHaveBeenCalledWith(dbTransaction, {
+  //       Email: user.Email,
+  //       IdType: user.IDType,
+  //       IdNo: user.IDNo,
+  //       ContactNo: user.ContactNo,
+  //     });
+
+  //     expect(generateDefaultPasswordMock).toHaveBeenCalledTimes(1);
+
+  //     expect(setPasswordMock).toHaveBeenCalledTimes(1);
+  //     expect(setPasswordMock).toHaveBeenCalledWith(
+  //       dbTransaction,
+  //       user,
+  //       'defaultPassword',
+  //     );
+
+  //     expect(createMock).toHaveBeenCalledTimes(1);
+
+  //     const userInfo = {
+  //       FullName: user.FullName,
+  //       IDNo: user.IDNo,
+  //       Email: user.Email,
+  //       ContactNo: user.ContactNo,
+  //       Password: user.Password,
+  //       Status: UserStatus.ACTIVE,
+  //       FirstLoginAt: null,
+  //       LastLoginAt: null,
+  //       MFAEnabled: null,
+  //       MFAConfig: null,
+  //       RecoveryEmail: null,
+  //       FailedLoginAttemptCount: 0,
+  //       LastFailedLoginAt: null,
+  //       LastPasswordChangedAt: null,
+  //       DefaultPasswordChangedYN: YN.No,
+  //       NeedToChangePasswordYN: YN.Yes,
+  //       CreatedById: loginUser.UserId,
+  //       CreatedAt: new Date(),
+  //       UpdatedById: loginUser.UserId,
+  //       UpdatedAt: new Date(),
+  //       UserId: null,
+  //     };
+
+  //     expect(createMock).toHaveBeenCalledWith(
+  //       {
+  //         Email: userInfo.Email,
+  //         Password: userInfo.Password,
+  //         Status: userInfo.Status,
+  //         DefaultPasswordChangedYN: userInfo.DefaultPasswordChangedYN,
+  //         FirstLoginAt: userInfo.FirstLoginAt,
+  //         LastLoginAt: userInfo.LastLoginAt,
+  //         MFAEnabled: userInfo.MFAEnabled,
+  //         MFAConfig: userInfo.MFAConfig,
+  //         RecoveryEmail: userInfo.RecoveryEmail,
+  //         FailedLoginAttemptCount: userInfo.FailedLoginAttemptCount,
+  //         LastFailedLoginAt: userInfo.LastFailedLoginAt,
+  //         LastPasswordChangedAt: userInfo.LastPasswordChangedAt,
+  //         NeedToChangePasswordYN: userInfo.NeedToChangePasswordYN,
+  //         CreatedById: userInfo.CreatedById,
+  //         CreatedAt: expect.any(Date),
+  //         UpdatedById: userInfo.UpdatedById,
+  //         UpdatedAt: expect.any(Date),
+  //       },
+  //       {
+  //         transaction: dbTransaction,
+  //       },
+  //     );
+
+  //     expect(activityCreateMock).toHaveBeenCalledTimes(1);
+
+  //     expect(result).toBeInstanceOf(LoginUser);
+  //     expect(result.Email).toBe(userInfo.Email);
+  //     expect(result.Password).toBe(userInfo.Password);
+  //     expect(result.Status).toBe(userInfo.Status);
+  //     expect(result.DefaultPasswordChangedYN).toBe(
+  //       userInfo.DefaultPasswordChangedYN,
+  //     );
+  //     expect(result.FirstLoginAt).toBe(null);
+  //     expect(result.LastLoginAt).toBe(null);
+  //     expect(result.MFAEnabled).toBe(userInfo.MFAEnabled);
+  //     expect(result.MFAConfig).toBe(userInfo.MFAConfig);
+  //     expect(result.RecoveryEmail).toBe(userInfo.RecoveryEmail);
+  //     expect(result.FailedLoginAttemptCount).toBe(
+  //       userInfo.FailedLoginAttemptCount,
+  //     );
+  //     expect(result.LastFailedLoginAt).toBe(userInfo.LastFailedLoginAt);
+  //     expect(result.LastPasswordChangedAt).toBe(userInfo.LastPasswordChangedAt);
+  //     expect(result.NeedToChangePasswordYN).toBe(
+  //       userInfo.NeedToChangePasswordYN,
+  //     );
+  //     expect(result.CreatedById).toBe(userInfo.CreatedById);
+  //     expect(result.UpdatedById).toBe(userInfo.UpdatedById);
+  //   });
+
+  //   it('should throw an error if user dont have the privilege to create new user', async () => {
+  //     jest.spyOn(loginUser, 'checkPrivileges').mockResolvedValueOnce(false);
+
+  //     await expect(
+  //       LoginUser.create(loginUser, dbTransaction, user),
+  //     ).rejects.toThrow(ClassError);
+  //   });
+
+  //   it('should throw an error if user email is missing', async () => {
+  //     user.Email = undefined;
+
+  //     jest.spyOn(loginUser, 'checkPrivileges').mockResolvedValueOnce(true);
+
+  //     await expect(
+  //       LoginUser.create(loginUser, dbTransaction, user),
+  //     ).rejects.toThrow(ClassError);
+  //   });
+  // });
+
   describe('incrementFailedLoginAttemptCount', () => {
     afterAll(() => {
       jest.restoreAllMocks();
@@ -595,17 +632,20 @@ describe('LoginUser', () => {
       const dbTransaction = null;
 
       // Mock the static methods and properties
-      jest.spyOn((LoginUser as any)['_Repository'], 'update').mockReturnValueOnce(null);
-
-      jest.spyOn(ComponentConfig, 'getComponentConfigValue').mockImplementation((componentName: string, configKey: string) => {
-        if (configKey === 'maxFailedLoginAttempts') {
-          return 3;
-        }
-        if (configKey === 'autoReleaseYN') {
-          return 'Y';
-        }
-      });
+      jest
+        .spyOn((LoginUser as any)['_Repository'], 'update')
+        .mockReturnValueOnce(null);
 
+      jest
+        .spyOn(ComponentConfig, 'getComponentConfigValue')
+        .mockImplementation((componentName: string, configKey: string) => {
+          if (configKey === 'maxFailedLoginAttempts') {
+            return 3;
+          }
+          if (configKey === 'autoReleaseYN') {
+            return 'Y';
+          }
+        });
 
       // Act
       await loginUser['incrementFailedLoginAttemptCount'](dbTransaction);
@@ -622,7 +662,7 @@ describe('LoginUser', () => {
             UserId: loginUser.UserId,
           },
           transaction: dbTransaction,
-        }
+        },
       );
     });
 
@@ -637,26 +677,31 @@ describe('LoginUser', () => {
       const dbTransaction = null;
 
       // Mock the static methods and properties
-      jest.spyOn((LoginUser as any)['_Repository'], 'update').mockReturnValueOnce(null);
-
-      jest.spyOn(ComponentConfig, 'getComponentConfigValue').mockImplementationOnce((componentName: string, configKey: string) => {
-        if (configKey === 'maxFailedLoginAttempts') {
-          return undefined;
-        }
-        if (configKey === 'autoReleaseYN') {
-          return undefined;
-        }
-      });
+      jest
+        .spyOn((LoginUser as any)['_Repository'], 'update')
+        .mockReturnValueOnce(null);
+
+      jest
+        .spyOn(ComponentConfig, 'getComponentConfigValue')
+        .mockImplementationOnce((componentName: string, configKey: string) => {
+          if (configKey === 'maxFailedLoginAttempts') {
+            return undefined;
+          }
+          if (configKey === 'autoReleaseYN') {
+            return undefined;
+          }
+        });
 
       // Act and Assert
       await expect(
-        loginUser['incrementFailedLoginAttemptCount'](dbTransaction)
+        loginUser['incrementFailedLoginAttemptCount'](dbTransaction),
       ).rejects.toThrow(
         new ClassError(
           'LoginUser',
           'LoginUserErrMsg0X',
           'Missing maxFailedLoginAttempts and or autoReleaseYN. Please set in config file.',
-        ));
+        ),
+      );
     });
 
     it('should lock the user account if the failed login attempts exceed the maximum allowed', async () => {
@@ -670,16 +715,20 @@ describe('LoginUser', () => {
       const dbTransaction = null;
 
       // Mock the static methods and properties
-      jest.spyOn((LoginUser as any)['_Repository'], 'update').mockReturnValueOnce(null);
-
-      jest.spyOn(ComponentConfig, 'getComponentConfigValue').mockImplementation((componentName: string, configKey: string) => {
-        if (configKey === 'maxFailedLoginAttempts') {
-          return 3;
-        }
-        if (configKey === 'autoReleaseYN') {
-          return 'Y';
-        }
-      });
+      jest
+        .spyOn((LoginUser as any)['_Repository'], 'update')
+        .mockReturnValueOnce(null);
+
+      jest
+        .spyOn(ComponentConfig, 'getComponentConfigValue')
+        .mockImplementation((componentName: string, configKey: string) => {
+          if (configKey === 'maxFailedLoginAttempts') {
+            return 3;
+          }
+          if (configKey === 'autoReleaseYN') {
+            return 'Y';
+          }
+        });
 
       // Act
       try {
@@ -698,10 +747,12 @@ describe('LoginUser', () => {
               UserId: loginUser.UserId,
             },
             transaction: dbTransaction,
-          }
+          },
         );
         expect(error).toBeInstanceOf(ClassError);
-        expect(error.message).toBe('Your account has been temporarily locked due to too many failed login attempts, please try again later.');
+        expect(error.message).toBe(
+          'Your account has been temporarily locked due to too many failed login attempts, please try again later.',
+        );
       }
     });
 
@@ -716,16 +767,20 @@ describe('LoginUser', () => {
       const dbTransaction = null;
 
       // Mock the static methods and properties
-      jest.spyOn((LoginUser as any)['_Repository'], 'update').mockReturnValueOnce(null);
-
-      jest.spyOn(ComponentConfig, 'getComponentConfigValue').mockImplementation((componentName: string, configKey: string) => {
-        if (configKey === 'maxFailedLoginAttempts') {
-          return 3;
-        }
-        if (configKey === 'autoReleaseYN') {
-          return 'N';
-        }
-      });
+      jest
+        .spyOn((LoginUser as any)['_Repository'], 'update')
+        .mockReturnValueOnce(null);
+
+      jest
+        .spyOn(ComponentConfig, 'getComponentConfigValue')
+        .mockImplementation((componentName: string, configKey: string) => {
+          if (configKey === 'maxFailedLoginAttempts') {
+            return 3;
+          }
+          if (configKey === 'autoReleaseYN') {
+            return 'N';
+          }
+        });
 
       // Act
       try {
@@ -744,10 +799,12 @@ describe('LoginUser', () => {
               UserId: loginUser.UserId,
             },
             transaction: dbTransaction,
-          }
+          },
         );
         expect(error).toBeInstanceOf(ClassError);
-        expect(error.message).toBe('Your account has been locked due to too many failed login attempts, please contact IT Support for instructions on how to unlock your account');
+        expect(error.message).toBe(
+          'Your account has been locked due to too many failed login attempts, please contact IT Support for instructions on how to unlock your account',
+        );
       }
     });
   });
@@ -764,19 +821,21 @@ describe('LoginUser', () => {
       ];
 
       // Mock the necessary repository methods
-      jest.spyOn((LoginUser as any), 'getInheritedSystemAccess').mockResolvedValueOnce([
-        { SystemCode: 'system1' },
-        { SystemCode: 'system2' },
-      ]);
-      jest.spyOn((LoginUser as any)['_UserSystemAccessRepo'], 'findAll').mockResolvedValueOnce([
-        { SystemCode: 'system3' },
-      ]);
+      jest
+        .spyOn(LoginUser as any, 'getInheritedSystemAccess')
+        .mockResolvedValueOnce([
+          { SystemCode: 'system1' },
+          { SystemCode: 'system2' },
+        ]);
+      jest
+        .spyOn((LoginUser as any)['_UserSystemAccessRepo'], 'findAll')
+        .mockResolvedValueOnce([{ SystemCode: 'system3' }]);
 
       // Call the method
       const result = await LoginUser['combineSystemAccess'](
         loginUser,
         dbTransaction,
-        groups
+        groups,
       );
 
       // Assert the result
@@ -798,18 +857,23 @@ describe('LoginUser', () => {
       loginUser.ObjectId = '1';
 
       // Mock the necessary methods
-      const rus = jest.spyOn(SessionService.prototype, 'retrieveUserSession').mockResolvedValueOnce({
-        systemLogins: [
-          {
-            id: '1',
-            sessionId: 'sessionId',
-            code: systemCode,
-            privileges: [privilegeName],
-          },
-        ],
-      });
+      const rus = jest
+        .spyOn(SessionService.prototype, 'retrieveUserSession')
+        .mockResolvedValueOnce({
+          systemLogins: [
+            {
+              id: '1',
+              sessionId: 'sessionId',
+              code: systemCode,
+              privileges: [privilegeName],
+            },
+          ],
+        });
       // Act
-      const hasPrivilege = await loginUser.checkPrivileges(systemCode, privilegeName);
+      const hasPrivilege = await loginUser.checkPrivileges(
+        systemCode,
+        privilegeName,
+      );
 
       // Assert
       expect(hasPrivilege).toBe(true);
@@ -825,18 +889,23 @@ describe('LoginUser', () => {
       loginUser.ObjectId = '1';
 
       // Mock the necessary methods
-      const rus = jest.spyOn(SessionService.prototype, 'retrieveUserSession').mockResolvedValueOnce({
-        systemLogins: [
-          {
-            id: '1',
-            sessionId: 'sessionId',
-            code: systemCode,
-            privileges: [],
-          },
-        ],
-      });
+      const rus = jest
+        .spyOn(SessionService.prototype, 'retrieveUserSession')
+        .mockResolvedValueOnce({
+          systemLogins: [
+            {
+              id: '1',
+              sessionId: 'sessionId',
+              code: systemCode,
+              privileges: [],
+            },
+          ],
+        });
       // Act
-      const hasPrivilege = await loginUser.checkPrivileges(systemCode, privilegeName);
+      const hasPrivilege = await loginUser.checkPrivileges(
+        systemCode,
+        privilegeName,
+      );
 
       // Assert
       expect(hasPrivilege).toBe(false);
@@ -852,7 +921,9 @@ describe('LoginUser', () => {
       loginUser.ObjectId = null;
 
       // Act & Assert
-      await expect(loginUser.checkPrivileges(systemCode, privilegeName)).rejects.toThrowError();
+      await expect(
+        loginUser.checkPrivileges(systemCode, privilegeName),
+      ).rejects.toThrowError();
     });
   });
 
@@ -886,7 +957,10 @@ describe('LoginUser', () => {
         ] as any);
 
       // Call the getObjectPrivileges method
-      const result = await loginUser['getObjectPrivileges'](systemCode, dbTransaction);
+      const result = await loginUser['getObjectPrivileges'](
+        systemCode,
+        dbTransaction,
+      );
 
       // Assertions
       expect(findAllMock).toHaveBeenCalledTimes(1);
@@ -914,10 +988,14 @@ describe('LoginUser', () => {
       const loginUser = await LoginUser.init(sessionService);
 
       // Mock the UserObjectPrivilegeRepo findAll method to throw an error
-      jest.spyOn(LoginUser['_UserObjectPrivilegeRepo'], 'findAll').mockRejectedValue(new Error('Database error'));
+      jest
+        .spyOn(LoginUser['_UserObjectPrivilegeRepo'], 'findAll')
+        .mockRejectedValue(new Error('Database error'));
 
       // Call the getObjectPrivileges method and expect it to throw an error
-      await expect(loginUser['getObjectPrivileges'](systemCode, dbTransaction)).rejects.toThrow(Error);
+      await expect(
+        loginUser['getObjectPrivileges'](systemCode, dbTransaction),
+      ).rejects.toThrow(Error);
     });
   });
 
@@ -930,7 +1008,10 @@ describe('LoginUser', () => {
       const dbTransaction = null;
 
       // Mock the findAll method of UserPrivilegeRepo
-      const findAllMock = jest.spyOn(LoginUser['_UserPrivilegeRepo'], 'findAll');
+      const findAllMock = jest.spyOn(
+        LoginUser['_UserPrivilegeRepo'],
+        'findAll',
+      );
       findAllMock.mockResolvedValue([
         { Privilege: { Name: 'privilege1' } },
         { Privilege: { Name: 'privilege2' } },
@@ -939,7 +1020,7 @@ describe('LoginUser', () => {
       // Act
       const privileges = await loginUser['getUserPersonalPrivileges'](
         systemCode,
-        dbTransaction
+        dbTransaction,
       );
 
       // Assert
@@ -969,12 +1050,15 @@ describe('LoginUser', () => {
       const dbTransaction = null;
 
       // Mock the findAll method of UserPrivilegeRepo to throw an error
-      const findAllMock = jest.spyOn(LoginUser['_UserPrivilegeRepo'], 'findAll');
+      const findAllMock = jest.spyOn(
+        LoginUser['_UserPrivilegeRepo'],
+        'findAll',
+      );
       findAllMock.mockRejectedValue(new Error('Database error'));
 
       // Act and Assert
       await expect(
-        loginUser['getUserPersonalPrivileges'](systemCode, dbTransaction)
+        loginUser['getUserPersonalPrivileges'](systemCode, dbTransaction),
       ).rejects.toThrow(Error);
 
       expect(findAllMock).toHaveBeenCalledTimes(1);
@@ -1011,12 +1095,24 @@ describe('LoginUser', () => {
       } as any;
 
       const systemAccess = [
-        { SystemCode: 'system1', GroupCode: 'group1', System: { SystemCode: 'system1' } },
-        { SystemCode: 'system2', GroupCode: 'group1', System: { SystemCode: 'system1' } },
+        {
+          SystemCode: 'system1',
+          GroupCode: 'group1',
+          System: { SystemCode: 'system1' },
+        },
+        {
+          SystemCode: 'system2',
+          GroupCode: 'group1',
+          System: { SystemCode: 'system1' },
+        },
       ] as any;
 
       const parentSystemAccess = [
-        { SystemCode: 'system3', GroupCode: 'parentGroup', System: { SystemCode: 'system3' } },
+        {
+          SystemCode: 'system3',
+          GroupCode: 'parentGroup',
+          System: { SystemCode: 'system3' },
+        },
       ] as any;
 
       // Mock the necessary repository methods
@@ -1036,7 +1132,7 @@ describe('LoginUser', () => {
       // Call the method
       const result = await LoginUser['getInheritedSystemAccess'](
         dbTransaction,
-        group
+        group,
       );
 
       console.log(result);
@@ -1045,21 +1141,24 @@ describe('LoginUser', () => {
         {
           SystemCode: 'system1',
           GroupCode: 'group1',
-          System: { SystemCode: 'system1' }
+          System: { SystemCode: 'system1' },
         },
         {
           SystemCode: 'system2',
           GroupCode: 'group1',
-          System: { SystemCode: 'system1' }
+          System: { SystemCode: 'system1' },
         },
         {
           SystemCode: 'system3',
           GroupCode: 'parentGroup',
-          System: { SystemCode: 'system3' }
-        }
+          System: { SystemCode: 'system3' },
+        },
       ]);
-      expect(groupFindByPkMock).toHaveBeenCalledWith(group.ParentGroupCode, dbTransaction);
+      expect(groupFindByPkMock).toHaveBeenCalledWith(
+        group.ParentGroupCode,
+        dbTransaction,
+      );
       expect(systemAccessFindAllMock).toHaveBeenCalledTimes(2);
-    })
+    });
   });
-});
+});