@tomei/sso 0.66.1-test.3 → 0.66.1-test.4

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

@@ -71,7 +71,11 @@ describe('LoginUser', () => {
       dbTransaction = null;
       jest
         .spyOn(ComponentConfig, 'getComponentConfigValue')
-        .mockReturnValue(mockLoginApiEndpoint as any);
+        .mockImplementation((componentName: string, configKey: string) =>
+          configKey === 'useLoginApiYN'
+            ? ('Y' as any)
+            : (mockLoginApiEndpoint as any),
+        );
     });
 
     it('should initialize LoginUser with valid userId', async () => {
@@ -136,6 +140,35 @@ describe('LoginUser', () => {
 
       expect(axiosPostMock).toHaveBeenCalledTimes(1);
     });
+
+    it('should initialize LoginUser via direct db query when useLoginApi is false', async () => {
+      jest
+        .spyOn(ComponentConfig, 'getComponentConfigValue')
+        .mockImplementation((componentName: string, configKey: string) => {
+          if (configKey === 'useLoginApiYN') return 'N' as any;
+          return mockLoginApiEndpoint as any;
+        });
+
+      const findOneMock = jest
+        .spyOn(LoginUser['_Repository'], 'findOne')
+        .mockResolvedValueOnce(mockUserData as any);
+      const axiosPostMock = jest.spyOn(axios, 'post');
+
+      const result = await LoginUser.init(
+        sessionService,
+        userId,
+        dbTransaction,
+      );
+
+      expect(findOneMock).toHaveBeenCalledWith({
+        where: { UserId: userId },
+        include: [{ model: expect.anything() }],
+        transaction: dbTransaction,
+      });
+      expect(axiosPostMock).not.toHaveBeenCalled();
+      expect(result).toBeInstanceOf(LoginUser);
+      expect(result.Email).toBe(mockUserData.Email);
+    });
   });
 
   // describe('checkSession', () => {
@@ -876,7 +909,11 @@ describe('LoginUser', () => {
         .mockReturnValue('test-session' as any);
       jest
         .spyOn(ComponentConfig, 'getComponentConfigValue')
-        .mockReturnValue(mockLoginApiEndpoint as any);
+        .mockImplementation((componentName: string, configKey: string) =>
+          configKey === 'useLoginApiYN'
+            ? ('Y' as any)
+            : (mockLoginApiEndpoint as any),
+        );
     });
 
     it('should return true if user has the specified privilege', async () => {
@@ -941,6 +978,238 @@ describe('LoginUser', () => {
         loginUser.checkPrivileges(systemCode, privilegeName),
       ).rejects.toThrow();
     });
+
+    it('should check the session privileges directly when useLoginApi is false', async () => {
+      const systemCode = 'SS';
+      const privilegeName = 'Privilege 1';
+      jest
+        .spyOn(ComponentConfig, 'getComponentConfigValue')
+        .mockImplementation((componentName: string, configKey: string) => {
+          if (configKey === 'useLoginApiYN') return 'N' as any;
+          return mockLoginApiEndpoint as any;
+        });
+
+      const sessionService = await SessionService.init();
+      const loginUser = await LoginUser.init(sessionService);
+      loginUser.ObjectId = '1';
+      loginUser['_SessionService'].retrieveUserSession = jest
+        .fn()
+        .mockResolvedValue({
+          systemLogins: [{ code: systemCode, privileges: [privilegeName] }],
+        });
+
+      const axiosPostMock = jest.spyOn(axios, 'post');
+
+      const hasPrivilege = await loginUser.checkPrivileges(
+        systemCode,
+        privilegeName,
+      );
+
+      expect(hasPrivilege).toBe(true);
+      expect(axiosPostMock).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('checkSession', () => {
+    const mockLoginApiEndpoint = {
+      baseUrl: 'http://sso-api',
+      checkSession: '/check-session',
+      apiKey: 'test-api-key',
+    };
+
+    beforeEach(() => {
+      jest
+        .spyOn(ApplicationConfig, 'getComponentConfigValue')
+        .mockReturnValue('test-session' as any);
+    });
+
+    it('should call the login-api endpoint when useLoginApi is true', async () => {
+      jest
+        .spyOn(ComponentConfig, 'getComponentConfigValue')
+        .mockImplementation((componentName: string, configKey: string) =>
+          configKey === 'useLoginApiYN'
+            ? ('Y' as any)
+            : (mockLoginApiEndpoint as any),
+        );
+
+      const systemCode = 'SS';
+      const sessionId = 'session-1';
+      const userId = '1';
+      const sessionService = await SessionService.init();
+      const loginUser = await LoginUser.init(sessionService);
+
+      const mockSystemLogin = { code: systemCode, sessionId };
+      const axiosPostMock = jest
+        .spyOn(axios, 'post')
+        .mockResolvedValueOnce({
+          data: { systemLogin: mockSystemLogin },
+        } as any);
+
+      const systemLogin = await loginUser.checkSession(
+        systemCode,
+        sessionId,
+        userId,
+      );
+
+      expect(systemLogin).toEqual(mockSystemLogin);
+      expect(axiosPostMock).toHaveBeenCalledWith(
+        `${mockLoginApiEndpoint.baseUrl}${mockLoginApiEndpoint.checkSession}`,
+        {
+          SystemCode: systemCode,
+          SessionName: 'test-session',
+          SessionId: sessionId,
+          UserId: userId,
+        },
+        {
+          headers: {
+            'Content-Type': 'application/json',
+            'x-api-key': mockLoginApiEndpoint.apiKey,
+          },
+        },
+      );
+    });
+
+    it('should validate the session directly against redis when useLoginApi is false', async () => {
+      jest
+        .spyOn(ComponentConfig, 'getComponentConfigValue')
+        .mockImplementation((componentName: string, configKey: string) => {
+          if (configKey === 'useLoginApiYN') return 'N' as any;
+          return mockLoginApiEndpoint as any;
+        });
+
+      const systemCode = 'SS';
+      const sessionId = 'session-1';
+      const userId = '1';
+      const sessionService = await SessionService.init();
+      const loginUser = await LoginUser.init(sessionService);
+
+      const mockSystemLogin = { code: systemCode, sessionId };
+      loginUser['_SessionService'].retrieveUserSession = jest
+        .fn()
+        .mockResolvedValue({ systemLogins: [mockSystemLogin] });
+      loginUser['_SessionService'].refreshDuration = jest.fn();
+
+      const axiosPostMock = jest.spyOn(axios, 'post');
+
+      const systemLogin = await loginUser.checkSession(
+        systemCode,
+        sessionId,
+        userId,
+      );
+
+      expect(systemLogin).toEqual(mockSystemLogin);
+      expect(
+        loginUser['_SessionService'].refreshDuration,
+      ).toHaveBeenCalledWith(userId, 'test-session');
+      expect(axiosPostMock).not.toHaveBeenCalled();
+    });
+
+    it('should throw "Session expired." when useLoginApi is false and the session is stale', async () => {
+      jest
+        .spyOn(ComponentConfig, 'getComponentConfigValue')
+        .mockImplementation((componentName: string, configKey: string) => {
+          if (configKey === 'useLoginApiYN') return 'N' as any;
+          return mockLoginApiEndpoint as any;
+        });
+
+      const sessionService = await SessionService.init();
+      const loginUser = await LoginUser.init(sessionService);
+      loginUser['_SessionService'].retrieveUserSession = jest
+        .fn()
+        .mockResolvedValue({ systemLogins: [] });
+
+      await expect(
+        loginUser.checkSession('SS', 'session-1', '1'),
+      ).rejects.toThrow('Session expired.');
+    });
+  });
+
+  describe('setSession', () => {
+    const mockLoginApiEndpoint = {
+      baseUrl: 'http://sso-api',
+      setSession: '/set-session',
+      apiKey: 'test-api-key',
+    };
+
+    beforeEach(() => {
+      jest
+        .spyOn(ApplicationConfig, 'getComponentConfigValue')
+        .mockReturnValue('test-session' as any);
+    });
+
+    it('should call the login-api endpoint when useLoginApi is true', async () => {
+      jest
+        .spyOn(ComponentConfig, 'getComponentConfigValue')
+        .mockImplementation((componentName: string, configKey: string) =>
+          configKey === 'useLoginApiYN'
+            ? ('Y' as any)
+            : (mockLoginApiEndpoint as any),
+        );
+
+      const systemCode = 'SS';
+      const sessionId = 'session-1';
+      const sessionService = await SessionService.init();
+      const loginUser = await LoginUser.init(sessionService);
+      loginUser.ObjectId = '1';
+
+      const axiosPostMock = jest
+        .spyOn(axios, 'post')
+        .mockResolvedValueOnce({ data: {} } as any);
+
+      await loginUser.setSession(systemCode, sessionId, null);
+
+      expect(axiosPostMock).toHaveBeenCalledWith(
+        `${mockLoginApiEndpoint.baseUrl}${mockLoginApiEndpoint.setSession}`,
+        {
+          SystemCode: systemCode,
+          SessionName: 'test-session',
+          SessionId: sessionId,
+          UserId: '1',
+        },
+        {
+          headers: {
+            'Content-Type': 'application/json',
+            'x-api-key': mockLoginApiEndpoint.apiKey,
+          },
+        },
+      );
+    });
+
+    it('should persist the session directly to redis when useLoginApi is false', async () => {
+      jest
+        .spyOn(ComponentConfig, 'getComponentConfigValue')
+        .mockImplementation((componentName: string, configKey: string) => {
+          if (configKey === 'useLoginApiYN') return 'N' as any;
+          return mockLoginApiEndpoint as any;
+        });
+
+      const systemCode = 'SS';
+      const sessionId = 'session-1';
+      const sessionService = await SessionService.init();
+      const loginUser = await LoginUser.init(sessionService);
+      loginUser.ObjectId = '1';
+
+      jest.spyOn(loginUser, 'getPrivileges').mockResolvedValue(['privilege1']);
+      loginUser['_SessionService'].retrieveUserSession = jest
+        .fn()
+        .mockResolvedValue({ systemLogins: [] });
+      loginUser['_SessionService'].setUserSession = jest.fn();
+
+      const axiosPostMock = jest.spyOn(axios, 'post');
+
+      await loginUser.setSession(systemCode, sessionId, null);
+
+      expect(axiosPostMock).not.toHaveBeenCalled();
+      expect(loginUser['_SessionService'].setUserSession).toHaveBeenCalledWith(
+        '1',
+        {
+          systemLogins: [
+            { id: systemCode, code: systemCode, sessionId, privileges: ['privilege1'] },
+          ],
+        },
+        'test-session',
+      );
+    });
   });
 
   describe('getObjectPrivileges', () => {

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

@@ -0,0 +1,87 @@
+import { User } from '../../../../src/components/login-user/user';
+import { UserPasswordHistory } from '../../../../src/components/user-password-history/user-password-history';
+import { YN } from '../../../../src/enum/yn.enum';
+
+// User and LoginUser import each other; this test exercises only User's expiry policy.
+jest.mock('../../../../src/components/login-user/login-user', () => ({
+  LoginUser: class {},
+}));
+
+describe('User.getPasswordExpiryStatus', () => {
+  const originalExpiryMonths = process.env.PASSWORD_EXPIRY_MONTHS;
+  const originalWarningDays = process.env.PASSWORD_EXPIRY_WARNING_DAYS;
+
+  const user = (password: string | null) =>
+    Object.assign(Object.create(User.prototype), {
+      ObjectId: '123',
+      _Password: password,
+      _NeedToChangePasswordYN: YN.No,
+    }) as User;
+
+  beforeEach(() => {
+    process.env.PASSWORD_EXPIRY_MONTHS = '1';
+    process.env.PASSWORD_EXPIRY_WARNING_DAYS = '14';
+    jest.useFakeTimers().setSystemTime(new Date('2026-02-20T12:00:00Z'));
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+    jest.useRealTimers();
+    if (originalExpiryMonths === undefined)
+      delete process.env.PASSWORD_EXPIRY_MONTHS;
+    else process.env.PASSWORD_EXPIRY_MONTHS = originalExpiryMonths;
+    if (originalWarningDays === undefined)
+      delete process.env.PASSWORD_EXPIRY_WARNING_DAYS;
+    else process.env.PASSWORD_EXPIRY_WARNING_DAYS = originalWarningDays;
+  });
+
+  it('disables expiry when the period is zero', async () => {
+    process.env.PASSWORD_EXPIRY_MONTHS = '0';
+    const lookup = jest.spyOn(UserPasswordHistory, 'getLatestByUserId');
+
+    expect(await user('hash').getPasswordExpiryStatus()).toEqual({
+      expired: false,
+      expiringSoon: false,
+      expiresInDays: null,
+    });
+    expect(lookup).not.toHaveBeenCalled();
+  });
+
+  it('skips an account without a local password', async () => {
+    const lookup = jest.spyOn(UserPasswordHistory, 'getLatestByUserId');
+
+    expect(await user(null).getPasswordExpiryStatus()).toEqual({
+      expired: false,
+      expiringSoon: false,
+      expiresInDays: null,
+    });
+    expect(lookup).not.toHaveBeenCalled();
+  });
+
+  it('expires an account without password history', async () => {
+    jest
+      .spyOn(UserPasswordHistory, 'getLatestByUserId')
+      .mockResolvedValue(null);
+
+    expect(await user('hash').getPasswordExpiryStatus()).toEqual({
+      expired: true,
+      expiringSoon: false,
+      expiresInDays: null,
+    });
+  });
+
+  it('warns before expiry and clamps month-end dates', async () => {
+    jest.spyOn(UserPasswordHistory, 'getLatestByUserId').mockResolvedValue({
+      CreatedAt: new Date('2026-01-31T12:00:00Z'),
+    } as UserPasswordHistory);
+
+    expect(await user('hash').getPasswordExpiryStatus()).toEqual({
+      expired: false,
+      expiringSoon: true,
+      expiresInDays: 8,
+    });
+
+    jest.setSystemTime(new Date('2026-02-28T12:00:00Z'));
+    expect((await user('hash').getPasswordExpiryStatus()).expired).toBe(true);
+  });
+});

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

@@ -72,7 +72,9 @@ describe('LoginUser', () => {
             dbTransaction = null;
             jest
                 .spyOn(config_1.ComponentConfig, 'getComponentConfigValue')
-                .mockReturnValue(mockLoginApiEndpoint);
+                .mockImplementation((componentName, configKey) => configKey === 'useLoginApiYN'
+                ? 'Y'
+                : mockLoginApiEndpoint);
         });
         it('should initialize LoginUser with valid userId', () => __awaiter(void 0, void 0, void 0, function* () {
             const user = {
@@ -120,6 +122,28 @@ describe('LoginUser', () => {
             yield expect(login_user_1.LoginUser.init(sessionService, userId, dbTransaction)).rejects.toThrow(Error);
             expect(axiosPostMock).toHaveBeenCalledTimes(1);
         }));
+        it('should initialize LoginUser via direct db query when useLoginApi is false', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest
+                .spyOn(config_1.ComponentConfig, 'getComponentConfigValue')
+                .mockImplementation((componentName, configKey) => {
+                if (configKey === 'useLoginApiYN')
+                    return 'N';
+                return mockLoginApiEndpoint;
+            });
+            const findOneMock = jest
+                .spyOn(login_user_1.LoginUser['_Repository'], 'findOne')
+                .mockResolvedValueOnce(mockUserData);
+            const axiosPostMock = jest.spyOn(axios_1.default, 'post');
+            const result = yield login_user_1.LoginUser.init(sessionService, userId, dbTransaction);
+            expect(findOneMock).toHaveBeenCalledWith({
+                where: { UserId: userId },
+                include: [{ model: expect.anything() }],
+                transaction: dbTransaction,
+            });
+            expect(axiosPostMock).not.toHaveBeenCalled();
+            expect(result).toBeInstanceOf(login_user_1.LoginUser);
+            expect(result.Email).toBe(mockUserData.Email);
+        }));
     });
     describe('shouldReleaseLock', () => {
         const minuteToAutoRelease = 5;
@@ -452,7 +476,9 @@ describe('LoginUser', () => {
                 .mockReturnValue('test-session');
             jest
                 .spyOn(config_1.ComponentConfig, 'getComponentConfigValue')
-                .mockReturnValue(mockLoginApiEndpoint);
+                .mockImplementation((componentName, configKey) => configKey === 'useLoginApiYN'
+                ? 'Y'
+                : mockLoginApiEndpoint);
         });
         it('should return true if user has the specified privilege', () => __awaiter(void 0, void 0, void 0, function* () {
             const systemCode = 'SS';
@@ -487,6 +513,177 @@ describe('LoginUser', () => {
             loginUser.ObjectId = null;
             yield expect(loginUser.checkPrivileges(systemCode, privilegeName)).rejects.toThrow();
         }));
+        it('should check the session privileges directly when useLoginApi is false', () => __awaiter(void 0, void 0, void 0, function* () {
+            const systemCode = 'SS';
+            const privilegeName = 'Privilege 1';
+            jest
+                .spyOn(config_1.ComponentConfig, 'getComponentConfigValue')
+                .mockImplementation((componentName, configKey) => {
+                if (configKey === 'useLoginApiYN')
+                    return 'N';
+                return mockLoginApiEndpoint;
+            });
+            const sessionService = yield session_service_1.SessionService.init();
+            const loginUser = yield login_user_1.LoginUser.init(sessionService);
+            loginUser.ObjectId = '1';
+            loginUser['_SessionService'].retrieveUserSession = jest
+                .fn()
+                .mockResolvedValue({
+                systemLogins: [{ code: systemCode, privileges: [privilegeName] }],
+            });
+            const axiosPostMock = jest.spyOn(axios_1.default, 'post');
+            const hasPrivilege = yield loginUser.checkPrivileges(systemCode, privilegeName);
+            expect(hasPrivilege).toBe(true);
+            expect(axiosPostMock).not.toHaveBeenCalled();
+        }));
+    });
+    describe('checkSession', () => {
+        const mockLoginApiEndpoint = {
+            baseUrl: 'http://sso-api',
+            checkSession: '/check-session',
+            apiKey: 'test-api-key',
+        };
+        beforeEach(() => {
+            jest
+                .spyOn(config_1.ApplicationConfig, 'getComponentConfigValue')
+                .mockReturnValue('test-session');
+        });
+        it('should call the login-api endpoint when useLoginApi is true', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest
+                .spyOn(config_1.ComponentConfig, 'getComponentConfigValue')
+                .mockImplementation((componentName, configKey) => configKey === 'useLoginApiYN'
+                ? 'Y'
+                : mockLoginApiEndpoint);
+            const systemCode = 'SS';
+            const sessionId = 'session-1';
+            const userId = '1';
+            const sessionService = yield session_service_1.SessionService.init();
+            const loginUser = yield login_user_1.LoginUser.init(sessionService);
+            const mockSystemLogin = { code: systemCode, sessionId };
+            const axiosPostMock = jest
+                .spyOn(axios_1.default, 'post')
+                .mockResolvedValueOnce({
+                data: { systemLogin: mockSystemLogin },
+            });
+            const systemLogin = yield loginUser.checkSession(systemCode, sessionId, userId);
+            expect(systemLogin).toEqual(mockSystemLogin);
+            expect(axiosPostMock).toHaveBeenCalledWith(`${mockLoginApiEndpoint.baseUrl}${mockLoginApiEndpoint.checkSession}`, {
+                SystemCode: systemCode,
+                SessionName: 'test-session',
+                SessionId: sessionId,
+                UserId: userId,
+            }, {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': mockLoginApiEndpoint.apiKey,
+                },
+            });
+        }));
+        it('should validate the session directly against redis when useLoginApi is false', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest
+                .spyOn(config_1.ComponentConfig, 'getComponentConfigValue')
+                .mockImplementation((componentName, configKey) => {
+                if (configKey === 'useLoginApiYN')
+                    return 'N';
+                return mockLoginApiEndpoint;
+            });
+            const systemCode = 'SS';
+            const sessionId = 'session-1';
+            const userId = '1';
+            const sessionService = yield session_service_1.SessionService.init();
+            const loginUser = yield login_user_1.LoginUser.init(sessionService);
+            const mockSystemLogin = { code: systemCode, sessionId };
+            loginUser['_SessionService'].retrieveUserSession = jest
+                .fn()
+                .mockResolvedValue({ systemLogins: [mockSystemLogin] });
+            loginUser['_SessionService'].refreshDuration = jest.fn();
+            const axiosPostMock = jest.spyOn(axios_1.default, 'post');
+            const systemLogin = yield loginUser.checkSession(systemCode, sessionId, userId);
+            expect(systemLogin).toEqual(mockSystemLogin);
+            expect(loginUser['_SessionService'].refreshDuration).toHaveBeenCalledWith(userId, 'test-session');
+            expect(axiosPostMock).not.toHaveBeenCalled();
+        }));
+        it('should throw "Session expired." when useLoginApi is false and the session is stale', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest
+                .spyOn(config_1.ComponentConfig, 'getComponentConfigValue')
+                .mockImplementation((componentName, configKey) => {
+                if (configKey === 'useLoginApiYN')
+                    return 'N';
+                return mockLoginApiEndpoint;
+            });
+            const sessionService = yield session_service_1.SessionService.init();
+            const loginUser = yield login_user_1.LoginUser.init(sessionService);
+            loginUser['_SessionService'].retrieveUserSession = jest
+                .fn()
+                .mockResolvedValue({ systemLogins: [] });
+            yield expect(loginUser.checkSession('SS', 'session-1', '1')).rejects.toThrow('Session expired.');
+        }));
+    });
+    describe('setSession', () => {
+        const mockLoginApiEndpoint = {
+            baseUrl: 'http://sso-api',
+            setSession: '/set-session',
+            apiKey: 'test-api-key',
+        };
+        beforeEach(() => {
+            jest
+                .spyOn(config_1.ApplicationConfig, 'getComponentConfigValue')
+                .mockReturnValue('test-session');
+        });
+        it('should call the login-api endpoint when useLoginApi is true', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest
+                .spyOn(config_1.ComponentConfig, 'getComponentConfigValue')
+                .mockImplementation((componentName, configKey) => configKey === 'useLoginApiYN'
+                ? 'Y'
+                : mockLoginApiEndpoint);
+            const systemCode = 'SS';
+            const sessionId = 'session-1';
+            const sessionService = yield session_service_1.SessionService.init();
+            const loginUser = yield login_user_1.LoginUser.init(sessionService);
+            loginUser.ObjectId = '1';
+            const axiosPostMock = jest
+                .spyOn(axios_1.default, 'post')
+                .mockResolvedValueOnce({ data: {} });
+            yield loginUser.setSession(systemCode, sessionId, null);
+            expect(axiosPostMock).toHaveBeenCalledWith(`${mockLoginApiEndpoint.baseUrl}${mockLoginApiEndpoint.setSession}`, {
+                SystemCode: systemCode,
+                SessionName: 'test-session',
+                SessionId: sessionId,
+                UserId: '1',
+            }, {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': mockLoginApiEndpoint.apiKey,
+                },
+            });
+        }));
+        it('should persist the session directly to redis when useLoginApi is false', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest
+                .spyOn(config_1.ComponentConfig, 'getComponentConfigValue')
+                .mockImplementation((componentName, configKey) => {
+                if (configKey === 'useLoginApiYN')
+                    return 'N';
+                return mockLoginApiEndpoint;
+            });
+            const systemCode = 'SS';
+            const sessionId = 'session-1';
+            const sessionService = yield session_service_1.SessionService.init();
+            const loginUser = yield login_user_1.LoginUser.init(sessionService);
+            loginUser.ObjectId = '1';
+            jest.spyOn(loginUser, 'getPrivileges').mockResolvedValue(['privilege1']);
+            loginUser['_SessionService'].retrieveUserSession = jest
+                .fn()
+                .mockResolvedValue({ systemLogins: [] });
+            loginUser['_SessionService'].setUserSession = jest.fn();
+            const axiosPostMock = jest.spyOn(axios_1.default, 'post');
+            yield loginUser.setSession(systemCode, sessionId, null);
+            expect(axiosPostMock).not.toHaveBeenCalled();
+            expect(loginUser['_SessionService'].setUserSession).toHaveBeenCalledWith('1', {
+                systemLogins: [
+                    { id: systemCode, code: systemCode, sessionId, privileges: ['privilege1'] },
+                ],
+            }, 'test-session');
+        }));
     });
     describe('getObjectPrivileges', () => {
         it('should return an array of privileges', () => __awaiter(void 0, void 0, void 0, function* () {