@tomei/sso 0.65.0 → 0.65.1-test.1

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

@@ -10,12 +10,1206 @@ 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();
-//   });
+const mockUserData = {
+  UserId: 1,
+  FullName: 'John Doe',
+  Email: 'john.doe@example.com',
+  Password: 'password',
+  Status: 'Active',
+  DefaultPasswordChangedYN: 'N',
+  FirstLoginAt: new Date(),
+  LastLoginAt: new Date(),
+  MFAEnabled: 1,
+  MFAConfig: 'config',
+  RecoveryEmail: 'john.doe@example.com',
+  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',
+  },
+};
+
+const mockSessionService = {
+  setUserSession: jest.fn(),
+  retrieveUserSession: jest.fn(),
+  refreshDuration: jest.fn(),
+};
+
+describe('LoginUser', () => {
+  beforeAll(() => {
+    // Redis env vars needed for RedisService.init() — actual connection is mocked via jest-initial-setup.ts
+    process.env.REDIS_HOST = 'localhost';
+    process.env.REDIS_PORT = '6379';
+  });
+
+  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(),
+          },
+        ],
+        transaction: dbTransaction,
+      });
+      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(),
+          },
+        ],
+        transaction: dbTransaction,
+      });
+    });
+  });
+
+  // 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.toThrow();
+    });
+
+    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.toThrow();
+    });
+  });
+
+  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.toThrow();
+      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', () => {
+    beforeEach(() => {
+      jest
+        .spyOn(ApplicationConfig, 'getComponentConfigValue')
+        .mockReturnValue('test-session' as any);
+    });
+
+    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, 'test-session');
+    });
+
+    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, 'test-session');
+    });
+
+    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.toThrow();
+    });
+  });
+
+  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: { PrivilegeCode: 'privilege1' } },
+        { Privilege: { PrivilegeCode: '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',
+        InheritParentSystemAccessYN: 'Y',
+        ParentGroupCode: 'parentGroup',
+      } as any;
+      const parentGroup = {
+        GroupCode: 'parentGroup',
+        InheritParentSystemAccessYN: '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);
+    });
+  });
+});
 
-//   describe('init', () => {
 //     let sessionService: any;
 //     let userId: number;
 //     let dbTransaction: any;