@tomei/sso 0.64.1 → 0.65.1-test.1

package/dist/__tests__/unit/components/login-user/login.spec.js

@@ -1,3 +1,706 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+const session_service_1 = require("../../../../src/session/session.service");
+const login_user_1 = require("../../../../src/components/login-user/login-user");
+const config_1 = require("@tomei/config");
+const user_repository_1 = require("../../../../src/components/login-user/user.repository");
+const general_1 = require("@tomei/general");
+const user_status_enum_1 = require("../../../../src/enum/user-status.enum");
+const system_privilege_entity_1 = require("../../../../src/models/system-privilege.entity");
+const group_system_access_repository_1 = require("../../../../src/components/group-system-access/group-system-access.repository");
+const group_repository_1 = require("../../../../src/components/group/group.repository");
+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(() => {
+        process.env.REDIS_HOST = 'localhost';
+        process.env.REDIS_PORT = '6379';
+    });
+    afterAll(() => {
+        jest.restoreAllMocks();
+    });
+    describe('init', () => {
+        let sessionService;
+        let userId;
+        let dbTransaction;
+        beforeEach(() => {
+            sessionService = {};
+            userId = 1;
+            dbTransaction = null;
+        });
+        it('should initialize LoginUser with valid userId', () => __awaiter(void 0, void 0, void 0, function* () {
+            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(user_repository_1.UserRepository.prototype, 'findOne')
+                .mockResolvedValueOnce(user);
+            const result = yield login_user_1.LoginUser.init(sessionService, userId, dbTransaction);
+            expect(findOneMock).toHaveBeenCalledTimes(1);
+            expect(findOneMock).toHaveBeenCalledWith({
+                where: {
+                    UserId: userId,
+                },
+                include: [
+                    {
+                        model: expect.anything(),
+                    },
+                ],
+                transaction: dbTransaction,
+            });
+            expect(result).toBeInstanceOf(login_user_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+            const findOneMock = jest
+                .spyOn(user_repository_1.UserRepository.prototype, 'findOne')
+                .mockResolvedValueOnce(null);
+            yield expect(login_user_1.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('shouldReleaseLock', () => {
+        const minuteToAutoRelease = 5;
+        const autoReleaseYN = 'Y';
+        beforeEach(() => {
+            jest
+                .spyOn(config_1.ComponentConfig, 'getComponentConfigValue')
+                .mockImplementation((componentName, configKey) => {
+                if (configKey === 'minuteToAutoRelease') {
+                    return minuteToAutoRelease;
+                }
+                if (configKey === 'autoReleaseYN') {
+                    return autoReleaseYN;
+                }
+            });
+        });
+        it('should return true if autoReleaseYN is "Y" and time difference is greater than minuteToAutoRelease', () => __awaiter(void 0, void 0, void 0, function* () {
+            const lastFailedLoginAt = new Date();
+            lastFailedLoginAt.setMinutes(lastFailedLoginAt.getMinutes() - 10);
+            const result = login_user_1.LoginUser.shouldReleaseLock(lastFailedLoginAt);
+            expect(result).toBe(true);
+        }));
+        it('should return false if autoReleaseYN is "Y" and time difference is less than or equal to minuteToAutoRelease', () => __awaiter(void 0, void 0, void 0, function* () {
+            const lastFailedLoginAt = new Date();
+            lastFailedLoginAt.setMinutes(lastFailedLoginAt.getMinutes() - 3);
+            const result = login_user_1.LoginUser.shouldReleaseLock(lastFailedLoginAt);
+            expect(result).toBe(false);
+        }));
+        it('should return false if autoReleaseYN is "N"', () => __awaiter(void 0, void 0, void 0, function* () {
+            const lastFailedLoginAt = new Date();
+            const result = login_user_1.LoginUser.shouldReleaseLock(lastFailedLoginAt);
+            expect(result).toBe(false);
+        }));
+    });
+    describe('releaseLock', () => {
+        it('should release the lock for a user', () => __awaiter(void 0, void 0, void 0, function* () {
+            const UserId = 1;
+            const dbTransaction = null;
+            const updateMock = jest
+                .spyOn(login_user_1.LoginUser['_Repository'], 'update')
+                .mockImplementationOnce(() => Promise.resolve({}));
+            login_user_1.LoginUser['releaseLock'](UserId, dbTransaction);
+            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', () => __awaiter(void 0, void 0, void 0, function* () {
+            const dbTransaction = null;
+            const query = {
+                Email: 'test@example.com',
+                IdType: 'passport',
+                IdNo: '123456789',
+                ContactNo: '1234567890',
+            };
+            jest
+                .spyOn(login_user_1.LoginUser['_Repository'], 'findAll')
+                .mockResolvedValueOnce([{ id: 1 }]);
+            yield expect(login_user_1.LoginUser['checkUserInfoDuplicated'](dbTransaction, query)).rejects.toThrow();
+        }));
+        it('should not throw an error if duplicate user info is not found', () => __awaiter(void 0, void 0, void 0, function* () {
+            const dbTransaction = null;
+            const query = {
+                Email: 'test@example.com',
+                IdType: 'passport',
+                IdNo: '123456789',
+                ContactNo: '1234567890',
+            };
+            jest.spyOn(login_user_1.LoginUser['_Repository'], 'findAll').mockResolvedValueOnce([]);
+            yield expect(login_user_1.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(config_1.ComponentConfig, 'getComponentConfigValue')
+                .mockImplementation((componentName, configKey) => {
+                if (configKey === 'passwordPolicy') {
+                    return passwordPolicy;
+                }
+            });
+        });
+        it('should generate a default password with the specified length', () => {
+            const password = login_user_1.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 = login_user_1.LoginUser['generateDefaultPassword']();
+            expect(/[A-Z]/.test(password)).toBe(true);
+        });
+        it('should generate a default password with at least one number', () => {
+            const password = login_user_1.LoginUser['generateDefaultPassword']();
+            expect(/[0-9]/.test(password)).toBe(true);
+        });
+        it('should generate a default password with at least one special character', () => {
+            const password = login_user_1.LoginUser['generateDefaultPassword']();
+            expect(/[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?~`]/.test(password)).toBe(true);
+        });
+        it('should generate a default password without any non-acceptable characters', () => {
+            const password = login_user_1.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(config_1.ComponentConfig, 'getComponentConfigValue')
+                .mockImplementation((componentName, configKey) => {
+                if (configKey === 'passwordPolicy') {
+                    return passwordPolicy;
+                }
+            });
+        });
+        it('should set the password for the user', () => __awaiter(void 0, void 0, void 0, function* () {
+            const dbTransaction = null;
+            const sessionService = yield session_service_1.SessionService.init();
+            const user = yield login_user_1.LoginUser.init(sessionService);
+            const password = 'N3wP@ssw0';
+            const result = yield login_user_1.LoginUser['setPassword'](dbTransaction, user, password);
+            expect(result).toBeInstanceOf(login_user_1.LoginUser);
+            yield expect(login_user_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+            const dbTransaction = null;
+            const sessionService = yield session_service_1.SessionService.init();
+            const user = yield login_user_1.LoginUser.init(sessionService);
+            const password = 'weakpassword';
+            yield expect(login_user_1.LoginUser['setPassword'](dbTransaction, user, password)).rejects.toThrow();
+        }));
+    });
+    describe('incrementFailedLoginAttemptCount', () => {
+        afterAll(() => {
+            jest.restoreAllMocks();
+        });
+        it('should increment FailedLoginAttemptCount and update user status', () => __awaiter(void 0, void 0, void 0, function* () {
+            const sessionService = yield session_service_1.SessionService.init();
+            const loginUser = yield login_user_1.LoginUser.init(sessionService);
+            loginUser['FailedLoginAttemptCount'] = 2;
+            loginUser['LastFailedLoginAt'] = new Date();
+            loginUser['Status'] = user_status_enum_1.UserStatus.ACTIVE;
+            const dbTransaction = null;
+            jest
+                .spyOn(login_user_1.LoginUser['_Repository'], 'update')
+                .mockReturnValueOnce(null);
+            jest
+                .spyOn(config_1.ComponentConfig, 'getComponentConfigValue')
+                .mockImplementation((componentName, configKey) => {
+                if (configKey === 'maxFailedLoginAttempts') {
+                    return 3;
+                }
+                if (configKey === 'autoReleaseYN') {
+                    return 'Y';
+                }
+            });
+            yield loginUser['incrementFailedLoginAttemptCount'](dbTransaction);
+            expect(login_user_1.LoginUser['_Repository'].update).toHaveBeenCalledWith({
+                FailedLoginAttemptCount: 3,
+                LastFailedLoginAt: expect.any(Date),
+                Status: user_status_enum_1.UserStatus.ACTIVE,
+            }, {
+                where: {
+                    UserId: loginUser.UserId,
+                },
+                transaction: dbTransaction,
+            });
+        }));
+        it('should throw an error if maxFailedLoginAttempts or autoReleaseYN is missing', () => __awaiter(void 0, void 0, void 0, function* () {
+            const sessionService = yield session_service_1.SessionService.init();
+            const loginUser = yield login_user_1.LoginUser.init(sessionService);
+            loginUser['FailedLoginAttemptCount'] = 2;
+            loginUser['LastFailedLoginAt'] = new Date();
+            loginUser['Status'] = user_status_enum_1.UserStatus.ACTIVE;
+            const dbTransaction = null;
+            jest
+                .spyOn(login_user_1.LoginUser['_Repository'], 'update')
+                .mockReturnValueOnce(null);
+            jest
+                .spyOn(config_1.ComponentConfig, 'getComponentConfigValue')
+                .mockImplementationOnce((componentName, configKey) => {
+                if (configKey === 'maxFailedLoginAttempts') {
+                    return undefined;
+                }
+                if (configKey === 'autoReleaseYN') {
+                    return undefined;
+                }
+            });
+            yield expect(loginUser['incrementFailedLoginAttemptCount'](dbTransaction)).rejects.toThrow(new general_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+            const sessionService = yield session_service_1.SessionService.init();
+            const loginUser = yield login_user_1.LoginUser.init(sessionService);
+            loginUser['FailedLoginAttemptCount'] = 3;
+            loginUser['LastFailedLoginAt'] = new Date();
+            loginUser['Status'] = user_status_enum_1.UserStatus.ACTIVE;
+            const dbTransaction = null;
+            jest
+                .spyOn(login_user_1.LoginUser['_Repository'], 'update')
+                .mockReturnValueOnce(null);
+            jest
+                .spyOn(config_1.ComponentConfig, 'getComponentConfigValue')
+                .mockImplementation((componentName, configKey) => {
+                if (configKey === 'maxFailedLoginAttempts') {
+                    return 3;
+                }
+                if (configKey === 'autoReleaseYN') {
+                    return 'Y';
+                }
+            });
+            try {
+                yield loginUser['incrementFailedLoginAttemptCount'](dbTransaction);
+                expect(false).toBe(true);
+            }
+            catch (error) {
+                expect(login_user_1.LoginUser['_Repository'].update).toHaveBeenCalledWith({
+                    FailedLoginAttemptCount: 4,
+                    LastFailedLoginAt: expect.any(Date),
+                    Status: user_status_enum_1.UserStatus.LOCKED,
+                }, {
+                    where: {
+                        UserId: loginUser.UserId,
+                    },
+                    transaction: dbTransaction,
+                });
+                expect(error).toBeInstanceOf(general_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+            const sessionService = yield session_service_1.SessionService.init();
+            const loginUser = yield login_user_1.LoginUser.init(sessionService);
+            loginUser['FailedLoginAttemptCount'] = 3;
+            loginUser['LastFailedLoginAt'] = new Date();
+            loginUser['Status'] = user_status_enum_1.UserStatus.ACTIVE;
+            const dbTransaction = null;
+            jest
+                .spyOn(login_user_1.LoginUser['_Repository'], 'update')
+                .mockReturnValueOnce(null);
+            jest
+                .spyOn(config_1.ComponentConfig, 'getComponentConfigValue')
+                .mockImplementation((componentName, configKey) => {
+                if (configKey === 'maxFailedLoginAttempts') {
+                    return 3;
+                }
+                if (configKey === 'autoReleaseYN') {
+                    return 'N';
+                }
+            });
+            try {
+                yield loginUser['incrementFailedLoginAttemptCount'](dbTransaction);
+                expect(false).toBe(true);
+            }
+            catch (error) {
+                expect(login_user_1.LoginUser['_Repository'].update).toHaveBeenCalledWith({
+                    FailedLoginAttemptCount: 4,
+                    LastFailedLoginAt: expect.any(Date),
+                    Status: user_status_enum_1.UserStatus.LOCKED,
+                }, {
+                    where: {
+                        UserId: loginUser.UserId,
+                    },
+                    transaction: dbTransaction,
+                });
+                expect(error).toBeInstanceOf(general_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+            const sessionService = yield session_service_1.SessionService.init();
+            const loginUser = yield login_user_1.LoginUser.init(sessionService);
+            const dbTransaction = null;
+            const groups = [
+                { InheritParentSystemAccessYN: true },
+                { InheritParentSystemAccessYN: false },
+            ];
+            jest
+                .spyOn(login_user_1.LoginUser, 'getInheritedSystemAccess')
+                .mockResolvedValueOnce([
+                { SystemCode: 'system1' },
+                { SystemCode: 'system2' },
+            ]);
+            jest
+                .spyOn(login_user_1.LoginUser['_UserSystemAccessRepo'], 'findAll')
+                .mockResolvedValueOnce([{ SystemCode: 'system3' }]);
+            const result = yield login_user_1.LoginUser['combineSystemAccess'](loginUser, dbTransaction, groups);
+            expect(result).toEqual([
+                { SystemCode: 'system3' },
+                { SystemCode: 'system1' },
+                { SystemCode: 'system2' },
+            ]);
+        }));
+    });
+    describe('checkPrivileges', () => {
+        beforeEach(() => {
+            jest
+                .spyOn(config_1.ApplicationConfig, 'getComponentConfigValue')
+                .mockReturnValue('test-session');
+        });
+        it('should return true if user has the specified privilege', () => __awaiter(void 0, void 0, void 0, function* () {
+            const systemCode = 'SS';
+            const privilegeName = 'Privilege 1';
+            const sessionService = yield session_service_1.SessionService.init();
+            const loginUser = yield login_user_1.LoginUser.init(sessionService);
+            loginUser.ObjectId = '1';
+            const rus = jest
+                .spyOn(session_service_1.SessionService.prototype, 'retrieveUserSession')
+                .mockResolvedValueOnce({
+                systemLogins: [
+                    {
+                        id: '1',
+                        sessionId: 'sessionId',
+                        code: systemCode,
+                        privileges: [privilegeName],
+                    },
+                ],
+            });
+            const hasPrivilege = yield loginUser.checkPrivileges(systemCode, privilegeName);
+            expect(hasPrivilege).toBe(true);
+            expect(rus).toHaveBeenCalledWith(loginUser.ObjectId, 'test-session');
+        }));
+        it('should return false if user does not have the specified privilege', () => __awaiter(void 0, void 0, void 0, function* () {
+            const systemCode = 'SS';
+            const privilegeName = 'Privilege 1';
+            const sessionService = yield session_service_1.SessionService.init();
+            const loginUser = yield login_user_1.LoginUser.init(sessionService);
+            loginUser.ObjectId = '1';
+            const rus = jest
+                .spyOn(session_service_1.SessionService.prototype, 'retrieveUserSession')
+                .mockResolvedValueOnce({
+                systemLogins: [
+                    {
+                        id: '1',
+                        sessionId: 'sessionId',
+                        code: systemCode,
+                        privileges: [],
+                    },
+                ],
+            });
+            const hasPrivilege = yield loginUser.checkPrivileges(systemCode, privilegeName);
+            expect(hasPrivilege).toBe(false);
+            expect(rus).toHaveBeenCalledWith(loginUser.ObjectId, 'test-session');
+        }));
+        it('should throw an error if ObjectId is not set', () => __awaiter(void 0, void 0, void 0, function* () {
+            const systemCode = 'SS';
+            const privilegeName = 'Privilege 1';
+            const sessionService = yield session_service_1.SessionService.init();
+            const loginUser = yield login_user_1.LoginUser.init(sessionService);
+            loginUser.ObjectId = null;
+            yield expect(loginUser.checkPrivileges(systemCode, privilegeName)).rejects.toThrow();
+        }));
+    });
+    describe('getObjectPrivileges', () => {
+        it('should return an array of privileges', () => __awaiter(void 0, void 0, void 0, function* () {
+            const systemCode = 'system1';
+            const dbTransaction = null;
+            const sessionService = yield session_service_1.SessionService.init();
+            const loginUser = yield login_user_1.LoginUser.init(sessionService);
+            const findAllMock = jest
+                .spyOn(login_user_1.LoginUser['_UserObjectPrivilegeRepo'], 'findAll')
+                .mockResolvedValue([
+                {
+                    PrivilegeCode: 'privilege1',
+                    Privilege: {
+                        PrivilegeCode: 'privilege1',
+                        SystemCode: systemCode,
+                        Name: 'privilege1',
+                    },
+                },
+                {
+                    PrivilegeCode: 'privilege2',
+                    Privilege: {
+                        PrivilegeCode: 'privilege2',
+                        Name: 'privilege2',
+                    },
+                },
+            ]);
+            const result = yield loginUser['getObjectPrivileges'](systemCode, dbTransaction);
+            expect(findAllMock).toHaveBeenCalledTimes(1);
+            expect(findAllMock).toHaveBeenCalledWith({
+                where: {
+                    UserId: loginUser.UserId,
+                },
+                include: {
+                    model: system_privilege_entity_1.default,
+                    where: {
+                        SystemCode: systemCode,
+                        Status: 'Active',
+                    },
+                },
+                transaction: dbTransaction,
+            });
+            expect(result).toEqual(['privilege1', 'privilege2']);
+        }));
+        it('should throw an error if an exception occurs', () => __awaiter(void 0, void 0, void 0, function* () {
+            const systemCode = 'system1';
+            const dbTransaction = null;
+            const sessionService = yield session_service_1.SessionService.init();
+            const loginUser = yield login_user_1.LoginUser.init(sessionService);
+            jest
+                .spyOn(login_user_1.LoginUser['_UserObjectPrivilegeRepo'], 'findAll')
+                .mockRejectedValue(new Error('Database error'));
+            yield expect(loginUser['getObjectPrivileges'](systemCode, dbTransaction)).rejects.toThrow(Error);
+        }));
+    });
+    describe('getUserPersonalPrivileges', () => {
+        it('should return an array of privileges', () => __awaiter(void 0, void 0, void 0, function* () {
+            const sessionService = yield session_service_1.SessionService.init();
+            const loginUser = yield login_user_1.LoginUser.init(sessionService);
+            const systemCode = 'system1';
+            const dbTransaction = null;
+            const findAllMock = jest.spyOn(login_user_1.LoginUser['_UserPrivilegeRepo'], 'findAll');
+            findAllMock.mockResolvedValue([
+                { Privilege: { PrivilegeCode: 'privilege1' } },
+                { Privilege: { PrivilegeCode: 'privilege2' } },
+            ]);
+            const privileges = yield loginUser['getUserPersonalPrivileges'](systemCode, dbTransaction);
+            expect(privileges).toEqual(['privilege1', 'privilege2']);
+            expect(findAllMock).toHaveBeenCalledTimes(1);
+            expect(findAllMock).toHaveBeenCalledWith({
+                where: {
+                    UserId: loginUser.UserId,
+                    Status: 'Active',
+                },
+                include: {
+                    model: system_privilege_entity_1.default,
+                    where: {
+                        SystemCode: systemCode,
+                        Status: 'Active',
+                    },
+                },
+                transaction: dbTransaction,
+            });
+        }));
+        it('should throw an error if an error occurs', () => __awaiter(void 0, void 0, void 0, function* () {
+            const sessionService = yield session_service_1.SessionService.init();
+            const loginUser = yield login_user_1.LoginUser.init(sessionService);
+            const systemCode = 'system1';
+            const dbTransaction = null;
+            const findAllMock = jest.spyOn(login_user_1.LoginUser['_UserPrivilegeRepo'], 'findAll');
+            findAllMock.mockRejectedValue(new Error('Database error'));
+            yield expect(loginUser['getUserPersonalPrivileges'](systemCode, dbTransaction)).rejects.toThrow(Error);
+            expect(findAllMock).toHaveBeenCalledTimes(1);
+            expect(findAllMock).toHaveBeenCalledWith({
+                where: {
+                    UserId: loginUser.UserId,
+                    Status: 'Active',
+                },
+                include: {
+                    model: system_privilege_entity_1.default,
+                    where: {
+                        SystemCode: systemCode,
+                        Status: 'Active',
+                    },
+                },
+                transaction: dbTransaction,
+            });
+        }));
+    });
+    describe('getInheritedSystemAccess', () => {
+        it('should return group system access with its parent group system access if applicable', () => __awaiter(void 0, void 0, void 0, function* () {
+            const dbTransaction = null;
+            const group = {
+                GroupCode: 'group1',
+                InheritParentSystemAccessYN: 'Y',
+                ParentGroupCode: 'parentGroup',
+            };
+            const parentGroup = {
+                GroupCode: 'parentGroup',
+                InheritParentSystemAccessYN: 'N',
+                ParentGroupCode: null,
+            };
+            const systemAccess = [
+                {
+                    SystemCode: 'system1',
+                    GroupCode: 'group1',
+                    System: { SystemCode: 'system1' },
+                },
+                {
+                    SystemCode: 'system2',
+                    GroupCode: 'group1',
+                    System: { SystemCode: 'system1' },
+                },
+            ];
+            const parentSystemAccess = [
+                {
+                    SystemCode: 'system3',
+                    GroupCode: 'parentGroup',
+                    System: { SystemCode: 'system3' },
+                },
+            ];
+            const groupFindByPkMock = jest
+                .spyOn(group_repository_1.GroupRepository.prototype, 'findByPk')
+                .mockResolvedValueOnce(parentGroup);
+            const systemAccessFindAllMock = jest
+                .spyOn(group_system_access_repository_1.GroupSystemAccessRepository.prototype, 'findAll')
+                .mockImplementation((options) => {
+                if (options.where.GroupCode === group.GroupCode) {
+                    return Promise.resolve(systemAccess);
+                }
+                else if (options.where.GroupCode === parentGroup.GroupCode) {
+                    return Promise.resolve(parentSystemAccess);
+                }
+            });
+            const result = yield login_user_1.LoginUser['getInheritedSystemAccess'](dbTransaction, group);
+            console.log(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);
+        }));
+    });
+});
 //# sourceMappingURL=login.spec.js.map