@tomei/sso 0.65.1-test.1 → 0.66.1-test.1

package/__tests__/unit/components/group-reporting-user/group-reporting-user.spec.ts

@@ -27,12 +27,12 @@ describe('GroupReportingUser', () => {
     jest.clearAllMocks();
   });
 
-
   describe('init', () => {
     const mockDbTransaction = {};
 
     it('should initialize GroupReportingUser without GroupReportingUserId', async () => {
-      const initGroupReportingUser = await GroupReportingUser.init(mockDbTransaction);
+      const initGroupReportingUser =
+        await GroupReportingUser.init(mockDbTransaction);
       expect(initGroupReportingUser).toBeDefined();
       expect(initGroupReportingUser).toBeInstanceOf(GroupReportingUser);
     });
@@ -47,7 +47,7 @@ describe('GroupReportingUser', () => {
 
       const initGroupReportingUser = await GroupReportingUser.init(
         mockDbTransaction,
-        '1'
+        '1',
       );
       expect(initGroupReportingUser).toBeDefined();
       expect(initGroupReportingUser).toBeInstanceOf(GroupReportingUser);
@@ -57,19 +57,23 @@ describe('GroupReportingUser', () => {
     });
 
     it('should throw ClassError when GroupReportingUser is not found', async () => {
-      jest.spyOn(GroupReportingUserRepository.prototype, 'findByPk').mockResolvedValue(null);
+      jest
+        .spyOn(GroupReportingUserRepository.prototype, 'findByPk')
+        .mockResolvedValue(null);
 
       await expect(
-        GroupReportingUser.init(mockDbTransaction, '1')
+        GroupReportingUser.init(mockDbTransaction, '1'),
       ).rejects.toThrow(ClassError);
     });
 
     it('should throw ClassError when failed to initialize GroupReportingUser', async () => {
-      jest.spyOn(GroupReportingUserRepository.prototype, 'findByPk').mockRejectedValue(new Error());
+      jest
+        .spyOn(GroupReportingUserRepository.prototype, 'findByPk')
+        .mockRejectedValue(new Error());
 
       await expect(
-        GroupReportingUser.init(mockDbTransaction, '1')
+        GroupReportingUser.init(mockDbTransaction, '1'),
       ).rejects.toThrow(Error);
     });
   });
-});
+});

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

@@ -9,6 +9,7 @@ import { YN } from '../../../../src/enum/yn.enum';
 import SystemPrivilegeModel from '../../../../src/models/system-privilege.entity';
 import { GroupSystemAccessRepository } from '../../../../src/components/group-system-access/group-system-access.repository';
 import { GroupRepository } from '../../../../src/components/group/group.repository';
+import axios from 'axios';
 
 const mockUserData = {
   UserId: 1,
@@ -58,11 +59,19 @@ describe('LoginUser', () => {
     let sessionService: any;
     let userId: number;
     let dbTransaction: any;
+    const mockLoginApiEndpoint = {
+      baseUrl: 'http://sso-api',
+      getProfile: '/get-profile',
+      apiKey: 'test-api-key',
+    };
 
     beforeEach(() => {
       sessionService = {};
       userId = 1;
       dbTransaction = null;
+      jest
+        .spyOn(ComponentConfig, 'getComponentConfigValue')
+        .mockReturnValue(mockLoginApiEndpoint as any);
     });
 
     it('should initialize LoginUser with valid userId', async () => {
@@ -93,9 +102,9 @@ describe('LoginUser', () => {
         },
       };
 
-      const findOneMock = jest
-        .spyOn(UserRepository.prototype, 'findOne')
-        .mockResolvedValueOnce(user as any);
+      const axiosPostMock = jest
+        .spyOn(axios, 'post')
+        .mockResolvedValueOnce({ data: { loginUser: user } } as any);
 
       const result = await LoginUser.init(
         sessionService,
@@ -103,63 +112,29 @@ describe('LoginUser', () => {
         dbTransaction,
       );
 
-      expect(findOneMock).toHaveBeenCalledTimes(1);
-      expect(findOneMock).toHaveBeenCalledWith({
-        where: {
-          UserId: userId,
-        },
-        include: [
-          {
-            model: expect.anything(),
-          },
-        ],
-        transaction: dbTransaction,
-      });
+      expect(axiosPostMock).toHaveBeenCalledTimes(1);
+      expect(axiosPostMock).toHaveBeenCalledWith(
+        `${mockLoginApiEndpoint.baseUrl}${mockLoginApiEndpoint.getProfile}`,
+        { UserId: userId },
+        { headers: { 'Content-Type': 'application/json', 'x-api-key': mockLoginApiEndpoint.apiKey } },
+      );
       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);
+      const axiosPostMock = jest
+        .spyOn(axios, 'post')
+        .mockResolvedValueOnce({ data: { loginUser: null } } as any);
 
       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,
-      });
+      expect(axiosPostMock).toHaveBeenCalledTimes(1);
     });
   });
 
@@ -889,10 +864,19 @@ describe('LoginUser', () => {
   });
 
   describe('checkPrivileges', () => {
+    const mockLoginApiEndpoint = {
+      baseUrl: 'http://sso-api',
+      checkPrivileges: '/check-privileges',
+      apiKey: 'test-api-key',
+    };
+
     beforeEach(() => {
       jest
         .spyOn(ApplicationConfig, 'getComponentConfigValue')
         .mockReturnValue('test-session' as any);
+      jest
+        .spyOn(ComponentConfig, 'getComponentConfigValue')
+        .mockReturnValue(mockLoginApiEndpoint as any);
     });
 
     it('should return true if user has the specified privilege', async () => {
@@ -903,19 +887,10 @@ describe('LoginUser', () => {
       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],
-            },
-          ],
-        });
+      const axiosPostMock = jest
+        .spyOn(axios, 'post')
+        .mockResolvedValueOnce({ data: { hasPrivilege: true } } as any);
+
       // Act
       const hasPrivilege = await loginUser.checkPrivileges(
         systemCode,
@@ -924,7 +899,11 @@ describe('LoginUser', () => {
 
       // Assert
       expect(hasPrivilege).toBe(true);
-      expect(rus).toHaveBeenCalledWith(loginUser.ObjectId, 'test-session');
+      expect(axiosPostMock).toHaveBeenCalledWith(
+        `${mockLoginApiEndpoint.baseUrl}${mockLoginApiEndpoint.checkPrivileges}`,
+        { SystemCode: systemCode, SessionName: 'test-session', PrivilegeName: privilegeName, UserId: '1' },
+        { headers: { 'Content-Type': 'application/json', 'x-api-key': mockLoginApiEndpoint.apiKey } },
+      );
     });
 
     it('should return false if user does not have the specified privilege', async () => {
@@ -935,19 +914,10 @@ describe('LoginUser', () => {
       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: [],
-            },
-          ],
-        });
+      const axiosPostMock = jest
+        .spyOn(axios, 'post')
+        .mockResolvedValueOnce({ data: { hasPrivilege: false } } as any);
+
       // Act
       const hasPrivilege = await loginUser.checkPrivileges(
         systemCode,
@@ -956,7 +926,6 @@ describe('LoginUser', () => {
 
       // Assert
       expect(hasPrivilege).toBe(false);
-      expect(rus).toHaveBeenCalledWith(loginUser.ObjectId, 'test-session');
     });
 
     it('should throw an error if ObjectId is not set', async () => {