@tomei/sso 0.32.0 → 0.32.2

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

@@ -1,1065 +1,1065 @@
-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);
+    })
+  });
 });