@tomei/sso 0.34.10 → 0.34.11

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

@@ -1,1164 +1,1164 @@
-import { SessionService } from '../../../../src/session/session.service';
-import { LoginUser } from '../../../../src/components/login-user/login-user';
-import { ApplicationConfig, ComponentConfig } from '@tomei/config';
-import { UserRepository } from '../../../../src/components/login-user/user.repository';
-import { ClassError } from '@tomei/general';
-import { Activity } from '@tomei/activity-history';
-import { UserStatus } from '../../../../src/enum/user-status.enum';
-import { YN } from '../../../../src/enum/yn.enum';
-import SystemPrivilegeModel from '../../../../src/models/system-privilege.entity';
-import { GroupSystemAccessRepository } from '../../../../src/components/group-system-access/group-system-access.repository';
-import { GroupRepository } from '../../../../src/components/group/group.repository';
-
-describe('LoginUser', () => {
-  afterAll(() => {
-    jest.restoreAllMocks();
-  });
-
-  describe('init', () => {
-    let sessionService: any;
-    let userId: number;
-    let dbTransaction: any;
-
-    beforeEach(() => {
-      sessionService = {};
-      userId = 1;
-      dbTransaction = null;
-    });
-
-    it('should initialize LoginUser with valid userId', async () => {
-      const user = {
-        UserId: 1,
-        FullName: 'John Doe',
-        Email: 'john.doe@example.com',
-        Password: 'password',
-        Status: 'active',
-        DefaultPasswordChangedYN: 'yes',
-        FirstLoginAt: new Date(),
-        LastLoginAt: new Date(),
-        MFAEnabled: 1,
-        MFAConfig: 'config',
-        RecoveryEmail: 'john.doe@example.com',
-        FailedLoginAttemptCount: 0,
-        LastFailedLoginAt: null,
-        LastPasswordChangedAt: new Date(),
-        NeedToChangePasswordYN: 'no',
-        CreatedById: 1,
-        CreatedAt: new Date(),
-        UpdatedById: 1,
-        UpdatedAt: new Date(),
-        Staff: {
-          FullName: 'John Doe',
-          IdNo: '1234567890',
-          Mobile: '1234567890',
-        },
-      };
-
-      const findOneMock = jest
-        .spyOn(UserRepository.prototype, 'findOne')
-        .mockResolvedValueOnce(user as any);
-
-      const result = await LoginUser.init(
-        sessionService,
-        userId,
-        dbTransaction,
-      );
-
-      expect(findOneMock).toHaveBeenCalledTimes(1);
-      expect(findOneMock).toHaveBeenCalledWith({
-        where: {
-          UserId: userId,
-        },
-        include: [
-          {
-            model: expect.anything(),
-          },
-        ],
-      });
-      expect(result).toBeInstanceOf(LoginUser);
-      expect(result.UserId).toBe(user.UserId);
-      expect(result.FullName).toBe(user.FullName);
-      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.FirstLoginAt).toBe(user.FirstLoginAt);
-      expect(result.LastLoginAt).toBe(user.LastLoginAt);
-      expect(result.MFAEnabled).toBe(user.MFAEnabled);
-      expect(result.MFAConfig).toBe(user.MFAConfig);
-      expect(result.RecoveryEmail).toBe(user.RecoveryEmail);
-      expect(result.FailedLoginAttemptCount).toBe(user.FailedLoginAttemptCount);
-      expect(result.LastFailedLoginAt).toBe(user.LastFailedLoginAt);
-      expect(result.LastPasswordChangedAt).toBe(user.LastPasswordChangedAt);
-      expect(result.NeedToChangePasswordYN).toBe(user.NeedToChangePasswordYN);
-      expect(result.CreatedById).toBe(user.CreatedById);
-      expect(result.CreatedAt).toBe(user.CreatedAt);
-      expect(result.UpdatedById).toBe(user.UpdatedById);
-      expect(result.UpdatedAt).toBe(user.UpdatedAt);
-    });
-
-    it('should throw an error when user is not found', async () => {
-      const findOneMock = jest
-        .spyOn(UserRepository.prototype, 'findOne')
-        .mockResolvedValueOnce(null);
-
-      await expect(
-        LoginUser.init(sessionService, userId, dbTransaction),
-      ).rejects.toThrow(Error);
-
-      expect(findOneMock).toHaveBeenCalledTimes(1);
-      expect(findOneMock).toHaveBeenCalledWith({
-        where: {
-          UserId: userId,
-        },
-        include: [
-          {
-            model: expect.anything(),
-          },
-        ],
-      });
-    });
-  });
-
-  // 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;
-    const autoReleaseYN = 'Y';
-
-    beforeEach(() => {
-      jest
-        .spyOn(ComponentConfig, 'getComponentConfigValue')
-        .mockImplementation((componentName: string, configKey: string) => {
-          if (configKey === 'minuteToAutoRelease') {
-            return minuteToAutoRelease as any;
-          }
-          if (configKey === 'autoReleaseYN') {
-            return autoReleaseYN as any;
-          }
-        });
-    });
-
-    it('should return true if autoReleaseYN is "Y" and time difference is greater than minuteToAutoRelease', async () => {
-      // Arrange
-      const lastFailedLoginAt = new Date();
-      lastFailedLoginAt.setMinutes(lastFailedLoginAt.getMinutes() - 10); // Set last failed login time to 10 minutes ago
-      // Act
-      const result = LoginUser.shouldReleaseLock(lastFailedLoginAt);
-
-      // Assert
-      expect(result).toBe(true);
-    });
-
-    it('should return false if autoReleaseYN is "Y" and time difference is less than or equal to minuteToAutoRelease', async () => {
-      // Arrange
-      const lastFailedLoginAt = new Date();
-      lastFailedLoginAt.setMinutes(lastFailedLoginAt.getMinutes() - 3); // Set last failed login time to 3 minutes ago
-
-      // Act
-      const result = LoginUser.shouldReleaseLock(lastFailedLoginAt);
-
-      // Assert
-      expect(result).toBe(false);
-    });
-
-    it('should return false if autoReleaseYN is "N"', async () => {
-      // Arrange
-      const lastFailedLoginAt = new Date();
-
-      // Act
-      const result = LoginUser.shouldReleaseLock(lastFailedLoginAt);
-
-      // Assert
-      expect(result).toBe(false);
-    });
-  });
-
-  describe('releaseLock', () => {
-    it('should release the lock for a user', async () => {
-      // Mock the necessary dependencies and setup the test data
-      const UserId = 1;
-      const dbTransaction = null;
-
-      const updateMock = jest
-        .spyOn(LoginUser['_Repository'], 'update')
-        .mockImplementationOnce(() => Promise.resolve({}) as any);
-
-      // Call the method under test
-      LoginUser['releaseLock'](UserId, dbTransaction);
-
-      // Verify the expected behavior
-      expect(updateMock).toHaveBeenCalledTimes(1);
-      expect(updateMock).toHaveBeenCalledWith(
-        {
-          FailedLoginAttemptCount: 0,
-          Status: 'Active',
-        },
-        {
-          where: {
-            UserId,
-          },
-          transaction: dbTransaction,
-        },
-      );
-    });
-  });
-
-  describe('checkUserInfoDuplicated', () => {
-    it('should throw an error if duplicate user info is found', async () => {
-      // Mock the dependencies and setup the test data
-      const dbTransaction = null;
-      const query = {
-        Email: 'test@example.com',
-        IdType: 'passport',
-        IdNo: '123456789',
-        ContactNo: '1234567890',
-      };
-
-      // Mock the LoginUser['_Repository'].findAll method to return a user
-      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();
-    });
-
-    it('should not throw an error if duplicate user info is not found', async () => {
-      // Mock the dependencies and setup the test data
-      const dbTransaction = null;
-      const query = {
-        Email: 'test@example.com',
-        IdType: 'passport',
-        IdNo: '123456789',
-        ContactNo: '1234567890',
-      };
-
-      // Mock the LoginUser['_Repository'].findAll method to return an empty array
-      jest.spyOn(LoginUser['_Repository'], 'findAll').mockResolvedValueOnce([]);
-
-      // Assert that the method does not throw an error
-      await expect(
-        LoginUser['checkUserInfoDuplicated'](dbTransaction, query),
-      ).resolves.not.toThrowError();
-    });
-  });
-
-  describe('generateDefaultPassword', () => {
-    const passwordPolicy = {
-      minLen: 6,
-      maxLen: 10,
-      nonAcceptableChar: 'i,l,o',
-      numOfCapitalLetters: 1,
-      numOfNumbers: 1,
-      numOfSpecialChars: 1,
-    };
-    beforeEach(() => {
-      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', () => {
-      const password = LoginUser['generateDefaultPassword']();
-      expect(password.length).toBeGreaterThanOrEqual(6);
-      expect(password.length).toBeLessThanOrEqual(10);
-    });
-
-    it('should generate a default password with at least one capital letter', () => {
-      const password = LoginUser['generateDefaultPassword']();
-      expect(/[A-Z]/.test(password)).toBe(true);
-    });
-
-    it('should generate a default password with at least one number', () => {
-      const password = LoginUser['generateDefaultPassword']();
-      expect(/[0-9]/.test(password)).toBe(true);
-    });
-
-    it('should generate a default password with at least one special character', () => {
-      const password = LoginUser['generateDefaultPassword']();
-      expect(/[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?~`]/.test(password)).toBe(true);
-    });
-
-    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,
-      );
-    });
-  });
-
-  describe('setPassword', () => {
-    const passwordPolicy = {
-      minLen: 6,
-      maxLen: 10,
-      nonAcceptableChar: 'i,l,o',
-      numOfCapitalLetters: 1,
-      numOfNumbers: 1,
-      numOfSpecialChars: 1,
-    };
-    beforeEach(() => {
-      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 () => {
-      // Arrange
-      const dbTransaction = null;
-      const sessionService = await SessionService.init();
-      const user = await LoginUser.init(sessionService);
-      const password = 'N3wP@ssw0';
-
-      // Act
-      const result = await LoginUser['setPassword'](
-        dbTransaction,
-        user,
-        password,
-      );
-
-      // Assert
-      expect(result).toBeInstanceOf(LoginUser);
-      await expect(
-        LoginUser['setPassword'](dbTransaction, user, password),
-      ).resolves.not.toThrowError();
-      expect(result.Password).toBeDefined();
-    });
-
-    it('should throw an error if the password does not meet the security requirements', async () => {
-      // Arrange
-      const dbTransaction = null;
-      const sessionService = await SessionService.init();
-      const user = await LoginUser.init(sessionService);
-      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);
-  //   });
-  // });
-
-  describe('incrementFailedLoginAttemptCount', () => {
-    afterAll(() => {
-      jest.restoreAllMocks();
-    });
-
-    it('should increment FailedLoginAttemptCount and update user status', async () => {
-      // Arrange
-      const sessionService = await SessionService.init();
-      const loginUser = await LoginUser.init(sessionService);
-      loginUser['FailedLoginAttemptCount'] = 2;
-      loginUser['LastFailedLoginAt'] = new Date();
-      loginUser['Status'] = UserStatus.ACTIVE;
-
-      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';
-          }
-        });
-
-      // Act
-      await loginUser['incrementFailedLoginAttemptCount'](dbTransaction);
-
-      // Assert
-      expect(LoginUser['_Repository'].update).toHaveBeenCalledWith(
-        {
-          FailedLoginAttemptCount: 3,
-          LastFailedLoginAt: expect.any(Date),
-          Status: UserStatus.ACTIVE,
-        },
-        {
-          where: {
-            UserId: loginUser.UserId,
-          },
-          transaction: dbTransaction,
-        },
-      );
-    });
-
-    it('should throw an error if maxFailedLoginAttempts or autoReleaseYN is missing', async () => {
-      // Arrange
-      const sessionService = await SessionService.init();
-      const loginUser = await LoginUser.init(sessionService);
-      loginUser['FailedLoginAttemptCount'] = 2;
-      loginUser['LastFailedLoginAt'] = new Date();
-      loginUser['Status'] = UserStatus.ACTIVE;
-
-      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;
-          }
-        });
-
-      // Act and Assert
-      await expect(
-        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 () => {
-      // Arrange
-      const sessionService = await SessionService.init();
-      const loginUser = await LoginUser.init(sessionService);
-      loginUser['FailedLoginAttemptCount'] = 3;
-      loginUser['LastFailedLoginAt'] = new Date();
-      loginUser['Status'] = UserStatus.ACTIVE;
-
-      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';
-          }
-        });
-
-      // Act
-      try {
-        await loginUser['incrementFailedLoginAttemptCount'](dbTransaction);
-        expect(false).toBe(true);
-      } catch (error) {
-        // Assert
-        expect(LoginUser['_Repository'].update).toHaveBeenCalledWith(
-          {
-            FailedLoginAttemptCount: 4,
-            LastFailedLoginAt: expect.any(Date),
-            Status: UserStatus.LOCKED,
-          },
-          {
-            where: {
-              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.',
-        );
-      }
-    });
-
-    it('should permanently lock the user account if the failed login attempts exceed the maximum allowed and autoReleaseYN is N', async () => {
-      // Arrange
-      const sessionService = await SessionService.init();
-      const loginUser = await LoginUser.init(sessionService);
-      loginUser['FailedLoginAttemptCount'] = 3;
-      loginUser['LastFailedLoginAt'] = new Date();
-      loginUser['Status'] = UserStatus.ACTIVE;
-
-      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';
-          }
-        });
-
-      // Act
-      try {
-        await loginUser['incrementFailedLoginAttemptCount'](dbTransaction);
-        expect(false).toBe(true);
-      } catch (error) {
-        // Assert
-        expect(LoginUser['_Repository'].update).toHaveBeenCalledWith(
-          {
-            FailedLoginAttemptCount: 4,
-            LastFailedLoginAt: expect.any(Date),
-            Status: UserStatus.LOCKED,
-          },
-          {
-            where: {
-              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',
-        );
-      }
-    });
-  });
-
-  describe('combineSystemAccess', () => {
-    it('should combine user and group system access and remove duplicates', async () => {
-      // Mock the necessary dependencies
-      const sessionService = await SessionService.init();
-      const loginUser = await LoginUser.init(sessionService);
-      const dbTransaction = null;
-      const groups = [
-        { InheritParentSystemAccessYN: true },
-        { InheritParentSystemAccessYN: false },
-      ];
-
-      // 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' }]);
-
-      // Call the method
-      const result = await LoginUser['combineSystemAccess'](
-        loginUser,
-        dbTransaction,
-        groups,
-      );
-
-      // Assert the result
-      expect(result).toEqual([
-        { SystemCode: 'system3' },
-        { SystemCode: 'system1' },
-        { SystemCode: 'system2' },
-      ]);
-    });
-  });
-
-  describe('checkPrivileges', () => {
-    it('should return true if user has the specified privilege', async () => {
-      // Arrange
-      const systemCode = 'SS';
-      const privilegeName = 'Privilege 1';
-      const sessionService = await SessionService.init();
-      const loginUser = await LoginUser.init(sessionService);
-      loginUser.ObjectId = '1';
-
-      // Mock the necessary methods
-      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,
-      );
-
-      // Assert
-      expect(hasPrivilege).toBe(true);
-      expect(rus).toHaveBeenCalledWith(loginUser.ObjectId);
-    });
-
-    it('should return false if user does not have the specified privilege', async () => {
-      // Arrange
-      const systemCode = 'SS';
-      const privilegeName = 'Privilege 1';
-      const sessionService = await SessionService.init();
-      const loginUser = await LoginUser.init(sessionService);
-      loginUser.ObjectId = '1';
-
-      // Mock the necessary methods
-      const rus = jest
-        .spyOn(SessionService.prototype, 'retrieveUserSession')
-        .mockResolvedValueOnce({
-          systemLogins: [
-            {
-              id: '1',
-              sessionId: 'sessionId',
-              code: systemCode,
-              privileges: [],
-            },
-          ],
-        });
-      // Act
-      const hasPrivilege = await loginUser.checkPrivileges(
-        systemCode,
-        privilegeName,
-      );
-
-      // Assert
-      expect(hasPrivilege).toBe(false);
-      expect(rus).toHaveBeenCalledWith(loginUser.ObjectId);
-    });
-
-    it('should throw an error if ObjectId is not set', async () => {
-      // Arrange
-      const systemCode = 'SS';
-      const privilegeName = 'Privilege 1';
-      const sessionService = await SessionService.init();
-      const loginUser = await LoginUser.init(sessionService);
-      loginUser.ObjectId = null;
-
-      // Act & Assert
-      await expect(
-        loginUser.checkPrivileges(systemCode, privilegeName),
-      ).rejects.toThrowError();
-    });
-  });
-
-  describe('getObjectPrivileges', () => {
-    it('should return an array of privileges', async () => {
-      // Mock the dependencies and setup the test data
-      const systemCode = 'system1';
-      const dbTransaction = null;
-      const sessionService = await SessionService.init();
-      const loginUser = await LoginUser.init(sessionService);
-
-      // Mock the UserObjectPrivilegeRepo findAll method
-      const findAllMock = jest
-        .spyOn(LoginUser['_UserObjectPrivilegeRepo'], 'findAll')
-        .mockResolvedValue([
-          {
-            PrivilegeCode: 'privilege1',
-            Privilege: {
-              PrivilegeCode: 'privilege1',
-              SystemCode: systemCode,
-              Name: 'privilege1',
-            },
-          },
-          {
-            PrivilegeCode: 'privilege2',
-            Privilege: {
-              PrivilegeCode: 'privilege2',
-              Name: 'privilege2',
-            },
-          },
-        ] as any);
-
-      // Call the getObjectPrivileges method
-      const result = await loginUser['getObjectPrivileges'](
-        systemCode,
-        dbTransaction,
-      );
-
-      // Assertions
-      expect(findAllMock).toHaveBeenCalledTimes(1);
-      expect(findAllMock).toHaveBeenCalledWith({
-        where: {
-          UserId: loginUser.UserId,
-        },
-        include: {
-          model: SystemPrivilegeModel,
-          where: {
-            SystemCode: systemCode,
-            Status: 'Active',
-          },
-        },
-        transaction: dbTransaction,
-      });
-      expect(result).toEqual(['privilege1', 'privilege2']);
-    });
-
-    it('should throw an error if an exception occurs', async () => {
-      // Mock the dependencies and setup the test data
-      const systemCode = 'system1';
-      const dbTransaction = null;
-      const sessionService = await SessionService.init();
-      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'));
-
-      // Call the getObjectPrivileges method and expect it to throw an error
-      await expect(
-        loginUser['getObjectPrivileges'](systemCode, dbTransaction),
-      ).rejects.toThrow(Error);
-    });
-  });
-
-  describe('getUserPersonalPrivileges', () => {
-    it('should return an array of privileges', async () => {
-      // Arrange
-      const sessionService = await SessionService.init();
-      const loginUser = await LoginUser.init(sessionService);
-      const systemCode = 'system1';
-      const dbTransaction = null;
-
-      // Mock the findAll method of UserPrivilegeRepo
-      const findAllMock = jest.spyOn(
-        LoginUser['_UserPrivilegeRepo'],
-        'findAll',
-      );
-      findAllMock.mockResolvedValue([
-        { Privilege: { Name: 'privilege1' } },
-        { Privilege: { Name: 'privilege2' } },
-      ] as any);
-
-      // Act
-      const privileges = await loginUser['getUserPersonalPrivileges'](
-        systemCode,
-        dbTransaction,
-      );
-
-      // Assert
-      expect(privileges).toEqual(['privilege1', 'privilege2']);
-      expect(findAllMock).toHaveBeenCalledTimes(1);
-      expect(findAllMock).toHaveBeenCalledWith({
-        where: {
-          UserId: loginUser.UserId,
-          Status: 'Active',
-        },
-        include: {
-          model: SystemPrivilegeModel,
-          where: {
-            SystemCode: systemCode,
-            Status: 'Active',
-          },
-        },
-        transaction: dbTransaction,
-      });
-    });
-
-    it('should throw an error if an error occurs', async () => {
-      // Arrange
-      const sessionService = await SessionService.init();
-      const loginUser = await LoginUser.init(sessionService);
-      const systemCode = 'system1';
-      const dbTransaction = null;
-
-      // Mock the findAll method of UserPrivilegeRepo to throw an error
-      const findAllMock = jest.spyOn(
-        LoginUser['_UserPrivilegeRepo'],
-        'findAll',
-      );
-      findAllMock.mockRejectedValue(new Error('Database error'));
-
-      // Act and Assert
-      await expect(
-        loginUser['getUserPersonalPrivileges'](systemCode, dbTransaction),
-      ).rejects.toThrow(Error);
-
-      expect(findAllMock).toHaveBeenCalledTimes(1);
-      expect(findAllMock).toHaveBeenCalledWith({
-        where: {
-          UserId: loginUser.UserId,
-          Status: 'Active',
-        },
-        include: {
-          model: SystemPrivilegeModel,
-          where: {
-            SystemCode: systemCode,
-            Status: 'Active',
-          },
-        },
-        transaction: dbTransaction,
-      });
-    });
-  });
-
-  describe('getInheritedSystemAccess', () => {
-    it('should return group system access with its parent group system access if applicable', async () => {
-      // Mock the necessary dependencies
-      const dbTransaction = null;
-      const group = {
-        GroupCode: 'group1',
-        InheritParentPrivilegeYN: 'Y',
-        ParentGroupCode: 'parentGroup',
-      } as any;
-      const parentGroup = {
-        GroupCode: 'parentGroup',
-        InheritParentPrivilegeYN: 'N',
-        ParentGroupCode: null,
-      } as any;
-
-      const systemAccess = [
-        {
-          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' },
-        },
-      ] as any;
-
-      // Mock the necessary repository methods
-      const groupFindByPkMock = jest
-        .spyOn(GroupRepository.prototype, 'findByPk')
-        .mockResolvedValueOnce(parentGroup as any);
-      const systemAccessFindAllMock = jest
-        .spyOn(GroupSystemAccessRepository.prototype, 'findAll')
-        .mockImplementation((options: any) => {
-          if (options.where.GroupCode === group.GroupCode) {
-            return Promise.resolve(systemAccess);
-          } else if (options.where.GroupCode === parentGroup.GroupCode) {
-            return Promise.resolve(parentSystemAccess);
-          }
-        });
-
-      // Call the method
-      const result = await LoginUser['getInheritedSystemAccess'](
-        dbTransaction,
-        group,
-      );
-
-      console.log(result);
-      // Assert the result
-      expect(result).toEqual([
-        {
-          SystemCode: 'system1',
-          GroupCode: 'group1',
-          System: { SystemCode: 'system1' },
-        },
-        {
-          SystemCode: 'system2',
-          GroupCode: 'group1',
-          System: { SystemCode: 'system1' },
-        },
-        {
-          SystemCode: 'system3',
-          GroupCode: 'parentGroup',
-          System: { SystemCode: 'system3' },
-        },
-      ]);
-      expect(groupFindByPkMock).toHaveBeenCalledWith(
-        group.ParentGroupCode,
-        dbTransaction,
-      );
-      expect(systemAccessFindAllMock).toHaveBeenCalledTimes(2);
-    });
-  });
-});
+import { SessionService } from '../../../../src/session/session.service';
+import { LoginUser } from '../../../../src/components/login-user/login-user';
+import { ApplicationConfig, ComponentConfig } from '@tomei/config';
+import { UserRepository } from '../../../../src/components/login-user/user.repository';
+import { ClassError } from '@tomei/general';
+import { Activity } from '@tomei/activity-history';
+import { UserStatus } from '../../../../src/enum/user-status.enum';
+import { YN } from '../../../../src/enum/yn.enum';
+import SystemPrivilegeModel from '../../../../src/models/system-privilege.entity';
+import { GroupSystemAccessRepository } from '../../../../src/components/group-system-access/group-system-access.repository';
+import { GroupRepository } from '../../../../src/components/group/group.repository';
+
+// describe('LoginUser', () => {
+//   afterAll(() => {
+//     jest.restoreAllMocks();
+//   });
+
+//   describe('init', () => {
+//     let sessionService: any;
+//     let userId: number;
+//     let dbTransaction: any;
+
+//     beforeEach(() => {
+//       sessionService = {};
+//       userId = 1;
+//       dbTransaction = null;
+//     });
+
+//     it('should initialize LoginUser with valid userId', async () => {
+//       const user = {
+//         UserId: 1,
+//         FullName: 'John Doe',
+//         Email: 'john.doe@example.com',
+//         Password: 'password',
+//         Status: 'active',
+//         DefaultPasswordChangedYN: 'yes',
+//         FirstLoginAt: new Date(),
+//         LastLoginAt: new Date(),
+//         MFAEnabled: 1,
+//         MFAConfig: 'config',
+//         RecoveryEmail: 'john.doe@example.com',
+//         FailedLoginAttemptCount: 0,
+//         LastFailedLoginAt: null,
+//         LastPasswordChangedAt: new Date(),
+//         NeedToChangePasswordYN: 'no',
+//         CreatedById: 1,
+//         CreatedAt: new Date(),
+//         UpdatedById: 1,
+//         UpdatedAt: new Date(),
+//         Staff: {
+//           FullName: 'John Doe',
+//           IdNo: '1234567890',
+//           Mobile: '1234567890',
+//         },
+//       };
+
+//       const findOneMock = jest
+//         .spyOn(UserRepository.prototype, 'findOne')
+//         .mockResolvedValueOnce(user as any);
+
+//       const result = await LoginUser.init(
+//         sessionService,
+//         userId,
+//         dbTransaction,
+//       );
+
+//       expect(findOneMock).toHaveBeenCalledTimes(1);
+//       expect(findOneMock).toHaveBeenCalledWith({
+//         where: {
+//           UserId: userId,
+//         },
+//         include: [
+//           {
+//             model: expect.anything(),
+//           },
+//         ],
+//       });
+//       expect(result).toBeInstanceOf(LoginUser);
+//       expect(result.UserId).toBe(user.UserId);
+//       expect(result.FullName).toBe(user.FullName);
+//       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.FirstLoginAt).toBe(user.FirstLoginAt);
+//       expect(result.LastLoginAt).toBe(user.LastLoginAt);
+//       expect(result.MFAEnabled).toBe(user.MFAEnabled);
+//       expect(result.MFAConfig).toBe(user.MFAConfig);
+//       expect(result.RecoveryEmail).toBe(user.RecoveryEmail);
+//       expect(result.FailedLoginAttemptCount).toBe(user.FailedLoginAttemptCount);
+//       expect(result.LastFailedLoginAt).toBe(user.LastFailedLoginAt);
+//       expect(result.LastPasswordChangedAt).toBe(user.LastPasswordChangedAt);
+//       expect(result.NeedToChangePasswordYN).toBe(user.NeedToChangePasswordYN);
+//       expect(result.CreatedById).toBe(user.CreatedById);
+//       expect(result.CreatedAt).toBe(user.CreatedAt);
+//       expect(result.UpdatedById).toBe(user.UpdatedById);
+//       expect(result.UpdatedAt).toBe(user.UpdatedAt);
+//     });
+
+//     it('should throw an error when user is not found', async () => {
+//       const findOneMock = jest
+//         .spyOn(UserRepository.prototype, 'findOne')
+//         .mockResolvedValueOnce(null);
+
+//       await expect(
+//         LoginUser.init(sessionService, userId, dbTransaction),
+//       ).rejects.toThrow(Error);
+
+//       expect(findOneMock).toHaveBeenCalledTimes(1);
+//       expect(findOneMock).toHaveBeenCalledWith({
+//         where: {
+//           UserId: userId,
+//         },
+//         include: [
+//           {
+//             model: expect.anything(),
+//           },
+//         ],
+//       });
+//     });
+//   });
+
+//   // 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;
+//     const autoReleaseYN = 'Y';
+
+//     beforeEach(() => {
+//       jest
+//         .spyOn(ComponentConfig, 'getComponentConfigValue')
+//         .mockImplementation((componentName: string, configKey: string) => {
+//           if (configKey === 'minuteToAutoRelease') {
+//             return minuteToAutoRelease as any;
+//           }
+//           if (configKey === 'autoReleaseYN') {
+//             return autoReleaseYN as any;
+//           }
+//         });
+//     });
+
+//     it('should return true if autoReleaseYN is "Y" and time difference is greater than minuteToAutoRelease', async () => {
+//       // Arrange
+//       const lastFailedLoginAt = new Date();
+//       lastFailedLoginAt.setMinutes(lastFailedLoginAt.getMinutes() - 10); // Set last failed login time to 10 minutes ago
+//       // Act
+//       const result = LoginUser.shouldReleaseLock(lastFailedLoginAt);
+
+//       // Assert
+//       expect(result).toBe(true);
+//     });
+
+//     it('should return false if autoReleaseYN is "Y" and time difference is less than or equal to minuteToAutoRelease', async () => {
+//       // Arrange
+//       const lastFailedLoginAt = new Date();
+//       lastFailedLoginAt.setMinutes(lastFailedLoginAt.getMinutes() - 3); // Set last failed login time to 3 minutes ago
+
+//       // Act
+//       const result = LoginUser.shouldReleaseLock(lastFailedLoginAt);
+
+//       // Assert
+//       expect(result).toBe(false);
+//     });
+
+//     it('should return false if autoReleaseYN is "N"', async () => {
+//       // Arrange
+//       const lastFailedLoginAt = new Date();
+
+//       // Act
+//       const result = LoginUser.shouldReleaseLock(lastFailedLoginAt);
+
+//       // Assert
+//       expect(result).toBe(false);
+//     });
+//   });
+
+//   describe('releaseLock', () => {
+//     it('should release the lock for a user', async () => {
+//       // Mock the necessary dependencies and setup the test data
+//       const UserId = 1;
+//       const dbTransaction = null;
+
+//       const updateMock = jest
+//         .spyOn(LoginUser['_Repository'], 'update')
+//         .mockImplementationOnce(() => Promise.resolve({}) as any);
+
+//       // Call the method under test
+//       LoginUser['releaseLock'](UserId, dbTransaction);
+
+//       // Verify the expected behavior
+//       expect(updateMock).toHaveBeenCalledTimes(1);
+//       expect(updateMock).toHaveBeenCalledWith(
+//         {
+//           FailedLoginAttemptCount: 0,
+//           Status: 'Active',
+//         },
+//         {
+//           where: {
+//             UserId,
+//           },
+//           transaction: dbTransaction,
+//         },
+//       );
+//     });
+//   });
+
+//   describe('checkUserInfoDuplicated', () => {
+//     it('should throw an error if duplicate user info is found', async () => {
+//       // Mock the dependencies and setup the test data
+//       const dbTransaction = null;
+//       const query = {
+//         Email: 'test@example.com',
+//         IdType: 'passport',
+//         IdNo: '123456789',
+//         ContactNo: '1234567890',
+//       };
+
+//       // Mock the LoginUser['_Repository'].findAll method to return a user
+//       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();
+//     });
+
+//     it('should not throw an error if duplicate user info is not found', async () => {
+//       // Mock the dependencies and setup the test data
+//       const dbTransaction = null;
+//       const query = {
+//         Email: 'test@example.com',
+//         IdType: 'passport',
+//         IdNo: '123456789',
+//         ContactNo: '1234567890',
+//       };
+
+//       // Mock the LoginUser['_Repository'].findAll method to return an empty array
+//       jest.spyOn(LoginUser['_Repository'], 'findAll').mockResolvedValueOnce([]);
+
+//       // Assert that the method does not throw an error
+//       await expect(
+//         LoginUser['checkUserInfoDuplicated'](dbTransaction, query),
+//       ).resolves.not.toThrowError();
+//     });
+//   });
+
+//   describe('generateDefaultPassword', () => {
+//     const passwordPolicy = {
+//       minLen: 6,
+//       maxLen: 10,
+//       nonAcceptableChar: 'i,l,o',
+//       numOfCapitalLetters: 1,
+//       numOfNumbers: 1,
+//       numOfSpecialChars: 1,
+//     };
+//     beforeEach(() => {
+//       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', () => {
+//       const password = LoginUser['generateDefaultPassword']();
+//       expect(password.length).toBeGreaterThanOrEqual(6);
+//       expect(password.length).toBeLessThanOrEqual(10);
+//     });
+
+//     it('should generate a default password with at least one capital letter', () => {
+//       const password = LoginUser['generateDefaultPassword']();
+//       expect(/[A-Z]/.test(password)).toBe(true);
+//     });
+
+//     it('should generate a default password with at least one number', () => {
+//       const password = LoginUser['generateDefaultPassword']();
+//       expect(/[0-9]/.test(password)).toBe(true);
+//     });
+
+//     it('should generate a default password with at least one special character', () => {
+//       const password = LoginUser['generateDefaultPassword']();
+//       expect(/[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?~`]/.test(password)).toBe(true);
+//     });
+
+//     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,
+//       );
+//     });
+//   });
+
+//   describe('setPassword', () => {
+//     const passwordPolicy = {
+//       minLen: 6,
+//       maxLen: 10,
+//       nonAcceptableChar: 'i,l,o',
+//       numOfCapitalLetters: 1,
+//       numOfNumbers: 1,
+//       numOfSpecialChars: 1,
+//     };
+//     beforeEach(() => {
+//       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 () => {
+//       // Arrange
+//       const dbTransaction = null;
+//       const sessionService = await SessionService.init();
+//       const user = await LoginUser.init(sessionService);
+//       const password = 'N3wP@ssw0';
+
+//       // Act
+//       const result = await LoginUser['setPassword'](
+//         dbTransaction,
+//         user,
+//         password,
+//       );
+
+//       // Assert
+//       expect(result).toBeInstanceOf(LoginUser);
+//       await expect(
+//         LoginUser['setPassword'](dbTransaction, user, password),
+//       ).resolves.not.toThrowError();
+//       expect(result.Password).toBeDefined();
+//     });
+
+//     it('should throw an error if the password does not meet the security requirements', async () => {
+//       // Arrange
+//       const dbTransaction = null;
+//       const sessionService = await SessionService.init();
+//       const user = await LoginUser.init(sessionService);
+//       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);
+//   //   });
+//   // });
+
+//   describe('incrementFailedLoginAttemptCount', () => {
+//     afterAll(() => {
+//       jest.restoreAllMocks();
+//     });
+
+//     it('should increment FailedLoginAttemptCount and update user status', async () => {
+//       // Arrange
+//       const sessionService = await SessionService.init();
+//       const loginUser = await LoginUser.init(sessionService);
+//       loginUser['FailedLoginAttemptCount'] = 2;
+//       loginUser['LastFailedLoginAt'] = new Date();
+//       loginUser['Status'] = UserStatus.ACTIVE;
+
+//       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';
+//           }
+//         });
+
+//       // Act
+//       await loginUser['incrementFailedLoginAttemptCount'](dbTransaction);
+
+//       // Assert
+//       expect(LoginUser['_Repository'].update).toHaveBeenCalledWith(
+//         {
+//           FailedLoginAttemptCount: 3,
+//           LastFailedLoginAt: expect.any(Date),
+//           Status: UserStatus.ACTIVE,
+//         },
+//         {
+//           where: {
+//             UserId: loginUser.UserId,
+//           },
+//           transaction: dbTransaction,
+//         },
+//       );
+//     });
+
+//     it('should throw an error if maxFailedLoginAttempts or autoReleaseYN is missing', async () => {
+//       // Arrange
+//       const sessionService = await SessionService.init();
+//       const loginUser = await LoginUser.init(sessionService);
+//       loginUser['FailedLoginAttemptCount'] = 2;
+//       loginUser['LastFailedLoginAt'] = new Date();
+//       loginUser['Status'] = UserStatus.ACTIVE;
+
+//       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;
+//           }
+//         });
+
+//       // Act and Assert
+//       await expect(
+//         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 () => {
+//       // Arrange
+//       const sessionService = await SessionService.init();
+//       const loginUser = await LoginUser.init(sessionService);
+//       loginUser['FailedLoginAttemptCount'] = 3;
+//       loginUser['LastFailedLoginAt'] = new Date();
+//       loginUser['Status'] = UserStatus.ACTIVE;
+
+//       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';
+//           }
+//         });
+
+//       // Act
+//       try {
+//         await loginUser['incrementFailedLoginAttemptCount'](dbTransaction);
+//         expect(false).toBe(true);
+//       } catch (error) {
+//         // Assert
+//         expect(LoginUser['_Repository'].update).toHaveBeenCalledWith(
+//           {
+//             FailedLoginAttemptCount: 4,
+//             LastFailedLoginAt: expect.any(Date),
+//             Status: UserStatus.LOCKED,
+//           },
+//           {
+//             where: {
+//               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.',
+//         );
+//       }
+//     });
+
+//     it('should permanently lock the user account if the failed login attempts exceed the maximum allowed and autoReleaseYN is N', async () => {
+//       // Arrange
+//       const sessionService = await SessionService.init();
+//       const loginUser = await LoginUser.init(sessionService);
+//       loginUser['FailedLoginAttemptCount'] = 3;
+//       loginUser['LastFailedLoginAt'] = new Date();
+//       loginUser['Status'] = UserStatus.ACTIVE;
+
+//       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';
+//           }
+//         });
+
+//       // Act
+//       try {
+//         await loginUser['incrementFailedLoginAttemptCount'](dbTransaction);
+//         expect(false).toBe(true);
+//       } catch (error) {
+//         // Assert
+//         expect(LoginUser['_Repository'].update).toHaveBeenCalledWith(
+//           {
+//             FailedLoginAttemptCount: 4,
+//             LastFailedLoginAt: expect.any(Date),
+//             Status: UserStatus.LOCKED,
+//           },
+//           {
+//             where: {
+//               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',
+//         );
+//       }
+//     });
+//   });
+
+//   describe('combineSystemAccess', () => {
+//     it('should combine user and group system access and remove duplicates', async () => {
+//       // Mock the necessary dependencies
+//       const sessionService = await SessionService.init();
+//       const loginUser = await LoginUser.init(sessionService);
+//       const dbTransaction = null;
+//       const groups = [
+//         { InheritParentSystemAccessYN: true },
+//         { InheritParentSystemAccessYN: false },
+//       ];
+
+//       // 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' }]);
+
+//       // Call the method
+//       const result = await LoginUser['combineSystemAccess'](
+//         loginUser,
+//         dbTransaction,
+//         groups,
+//       );
+
+//       // Assert the result
+//       expect(result).toEqual([
+//         { SystemCode: 'system3' },
+//         { SystemCode: 'system1' },
+//         { SystemCode: 'system2' },
+//       ]);
+//     });
+//   });
+
+//   describe('checkPrivileges', () => {
+//     it('should return true if user has the specified privilege', async () => {
+//       // Arrange
+//       const systemCode = 'SS';
+//       const privilegeName = 'Privilege 1';
+//       const sessionService = await SessionService.init();
+//       const loginUser = await LoginUser.init(sessionService);
+//       loginUser.ObjectId = '1';
+
+//       // Mock the necessary methods
+//       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,
+//       );
+
+//       // Assert
+//       expect(hasPrivilege).toBe(true);
+//       expect(rus).toHaveBeenCalledWith(loginUser.ObjectId);
+//     });
+
+//     it('should return false if user does not have the specified privilege', async () => {
+//       // Arrange
+//       const systemCode = 'SS';
+//       const privilegeName = 'Privilege 1';
+//       const sessionService = await SessionService.init();
+//       const loginUser = await LoginUser.init(sessionService);
+//       loginUser.ObjectId = '1';
+
+//       // Mock the necessary methods
+//       const rus = jest
+//         .spyOn(SessionService.prototype, 'retrieveUserSession')
+//         .mockResolvedValueOnce({
+//           systemLogins: [
+//             {
+//               id: '1',
+//               sessionId: 'sessionId',
+//               code: systemCode,
+//               privileges: [],
+//             },
+//           ],
+//         });
+//       // Act
+//       const hasPrivilege = await loginUser.checkPrivileges(
+//         systemCode,
+//         privilegeName,
+//       );
+
+//       // Assert
+//       expect(hasPrivilege).toBe(false);
+//       expect(rus).toHaveBeenCalledWith(loginUser.ObjectId);
+//     });
+
+//     it('should throw an error if ObjectId is not set', async () => {
+//       // Arrange
+//       const systemCode = 'SS';
+//       const privilegeName = 'Privilege 1';
+//       const sessionService = await SessionService.init();
+//       const loginUser = await LoginUser.init(sessionService);
+//       loginUser.ObjectId = null;
+
+//       // Act & Assert
+//       await expect(
+//         loginUser.checkPrivileges(systemCode, privilegeName),
+//       ).rejects.toThrowError();
+//     });
+//   });
+
+//   describe('getObjectPrivileges', () => {
+//     it('should return an array of privileges', async () => {
+//       // Mock the dependencies and setup the test data
+//       const systemCode = 'system1';
+//       const dbTransaction = null;
+//       const sessionService = await SessionService.init();
+//       const loginUser = await LoginUser.init(sessionService);
+
+//       // Mock the UserObjectPrivilegeRepo findAll method
+//       const findAllMock = jest
+//         .spyOn(LoginUser['_UserObjectPrivilegeRepo'], 'findAll')
+//         .mockResolvedValue([
+//           {
+//             PrivilegeCode: 'privilege1',
+//             Privilege: {
+//               PrivilegeCode: 'privilege1',
+//               SystemCode: systemCode,
+//               Name: 'privilege1',
+//             },
+//           },
+//           {
+//             PrivilegeCode: 'privilege2',
+//             Privilege: {
+//               PrivilegeCode: 'privilege2',
+//               Name: 'privilege2',
+//             },
+//           },
+//         ] as any);
+
+//       // Call the getObjectPrivileges method
+//       const result = await loginUser['getObjectPrivileges'](
+//         systemCode,
+//         dbTransaction,
+//       );
+
+//       // Assertions
+//       expect(findAllMock).toHaveBeenCalledTimes(1);
+//       expect(findAllMock).toHaveBeenCalledWith({
+//         where: {
+//           UserId: loginUser.UserId,
+//         },
+//         include: {
+//           model: SystemPrivilegeModel,
+//           where: {
+//             SystemCode: systemCode,
+//             Status: 'Active',
+//           },
+//         },
+//         transaction: dbTransaction,
+//       });
+//       expect(result).toEqual(['privilege1', 'privilege2']);
+//     });
+
+//     it('should throw an error if an exception occurs', async () => {
+//       // Mock the dependencies and setup the test data
+//       const systemCode = 'system1';
+//       const dbTransaction = null;
+//       const sessionService = await SessionService.init();
+//       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'));
+
+//       // Call the getObjectPrivileges method and expect it to throw an error
+//       await expect(
+//         loginUser['getObjectPrivileges'](systemCode, dbTransaction),
+//       ).rejects.toThrow(Error);
+//     });
+//   });
+
+//   describe('getUserPersonalPrivileges', () => {
+//     it('should return an array of privileges', async () => {
+//       // Arrange
+//       const sessionService = await SessionService.init();
+//       const loginUser = await LoginUser.init(sessionService);
+//       const systemCode = 'system1';
+//       const dbTransaction = null;
+
+//       // Mock the findAll method of UserPrivilegeRepo
+//       const findAllMock = jest.spyOn(
+//         LoginUser['_UserPrivilegeRepo'],
+//         'findAll',
+//       );
+//       findAllMock.mockResolvedValue([
+//         { Privilege: { Name: 'privilege1' } },
+//         { Privilege: { Name: 'privilege2' } },
+//       ] as any);
+
+//       // Act
+//       const privileges = await loginUser['getUserPersonalPrivileges'](
+//         systemCode,
+//         dbTransaction,
+//       );
+
+//       // Assert
+//       expect(privileges).toEqual(['privilege1', 'privilege2']);
+//       expect(findAllMock).toHaveBeenCalledTimes(1);
+//       expect(findAllMock).toHaveBeenCalledWith({
+//         where: {
+//           UserId: loginUser.UserId,
+//           Status: 'Active',
+//         },
+//         include: {
+//           model: SystemPrivilegeModel,
+//           where: {
+//             SystemCode: systemCode,
+//             Status: 'Active',
+//           },
+//         },
+//         transaction: dbTransaction,
+//       });
+//     });
+
+//     it('should throw an error if an error occurs', async () => {
+//       // Arrange
+//       const sessionService = await SessionService.init();
+//       const loginUser = await LoginUser.init(sessionService);
+//       const systemCode = 'system1';
+//       const dbTransaction = null;
+
+//       // Mock the findAll method of UserPrivilegeRepo to throw an error
+//       const findAllMock = jest.spyOn(
+//         LoginUser['_UserPrivilegeRepo'],
+//         'findAll',
+//       );
+//       findAllMock.mockRejectedValue(new Error('Database error'));
+
+//       // Act and Assert
+//       await expect(
+//         loginUser['getUserPersonalPrivileges'](systemCode, dbTransaction),
+//       ).rejects.toThrow(Error);
+
+//       expect(findAllMock).toHaveBeenCalledTimes(1);
+//       expect(findAllMock).toHaveBeenCalledWith({
+//         where: {
+//           UserId: loginUser.UserId,
+//           Status: 'Active',
+//         },
+//         include: {
+//           model: SystemPrivilegeModel,
+//           where: {
+//             SystemCode: systemCode,
+//             Status: 'Active',
+//           },
+//         },
+//         transaction: dbTransaction,
+//       });
+//     });
+//   });
+
+//   describe('getInheritedSystemAccess', () => {
+//     it('should return group system access with its parent group system access if applicable', async () => {
+//       // Mock the necessary dependencies
+//       const dbTransaction = null;
+//       const group = {
+//         GroupCode: 'group1',
+//         InheritParentPrivilegeYN: 'Y',
+//         ParentGroupCode: 'parentGroup',
+//       } as any;
+//       const parentGroup = {
+//         GroupCode: 'parentGroup',
+//         InheritParentPrivilegeYN: 'N',
+//         ParentGroupCode: null,
+//       } as any;
+
+//       const systemAccess = [
+//         {
+//           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' },
+//         },
+//       ] as any;
+
+//       // Mock the necessary repository methods
+//       const groupFindByPkMock = jest
+//         .spyOn(GroupRepository.prototype, 'findByPk')
+//         .mockResolvedValueOnce(parentGroup as any);
+//       const systemAccessFindAllMock = jest
+//         .spyOn(GroupSystemAccessRepository.prototype, 'findAll')
+//         .mockImplementation((options: any) => {
+//           if (options.where.GroupCode === group.GroupCode) {
+//             return Promise.resolve(systemAccess);
+//           } else if (options.where.GroupCode === parentGroup.GroupCode) {
+//             return Promise.resolve(parentSystemAccess);
+//           }
+//         });
+
+//       // Call the method
+//       const result = await LoginUser['getInheritedSystemAccess'](
+//         dbTransaction,
+//         group,
+//       );
+
+//       console.log(result);
+//       // Assert the result
+//       expect(result).toEqual([
+//         {
+//           SystemCode: 'system1',
+//           GroupCode: 'group1',
+//           System: { SystemCode: 'system1' },
+//         },
+//         {
+//           SystemCode: 'system2',
+//           GroupCode: 'group1',
+//           System: { SystemCode: 'system1' },
+//         },
+//         {
+//           SystemCode: 'system3',
+//           GroupCode: 'parentGroup',
+//           System: { SystemCode: 'system3' },
+//         },
+//       ]);
+//       expect(groupFindByPkMock).toHaveBeenCalledWith(
+//         group.ParentGroupCode,
+//         dbTransaction,
+//       );
+//       expect(systemAccessFindAllMock).toHaveBeenCalledTimes(2);
+//     });
+//   });
+// });