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

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,23 +57,19 @@ 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,7 +9,6 @@ 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,
@@ -59,19 +58,11 @@ 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 () => {
@@ -102,9 +93,9 @@ describe('LoginUser', () => {
         },
       };
 
-      const axiosPostMock = jest
-        .spyOn(axios, 'post')
-        .mockResolvedValueOnce({ data: { loginUser: user } } as any);
+      const findOneMock = jest
+        .spyOn(UserRepository.prototype, 'findOne')
+        .mockResolvedValueOnce(user as any);
 
       const result = await LoginUser.init(
         sessionService,
@@ -112,29 +103,63 @@ describe('LoginUser', () => {
         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(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 axiosPostMock = jest
-        .spyOn(axios, 'post')
-        .mockResolvedValueOnce({ data: { loginUser: null } } as any);
+      const findOneMock = jest
+        .spyOn(UserRepository.prototype, 'findOne')
+        .mockResolvedValueOnce(null);
 
       await expect(
         LoginUser.init(sessionService, userId, dbTransaction),
       ).rejects.toThrow(Error);
 
-      expect(axiosPostMock).toHaveBeenCalledTimes(1);
+      expect(findOneMock).toHaveBeenCalledTimes(1);
+      expect(findOneMock).toHaveBeenCalledWith({
+        where: {
+          UserId: userId,
+        },
+        include: [
+          {
+            model: expect.anything(),
+          },
+        ],
+        transaction: dbTransaction,
+      });
     });
   });
 
@@ -864,19 +889,10 @@ 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 () => {
@@ -887,10 +903,19 @@ describe('LoginUser', () => {
       const loginUser = await LoginUser.init(sessionService);
       loginUser.ObjectId = '1';
 
-      const axiosPostMock = jest
-        .spyOn(axios, 'post')
-        .mockResolvedValueOnce({ data: { hasPrivilege: true } } as any);
-
+      // 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,
@@ -899,11 +924,7 @@ describe('LoginUser', () => {
 
       // Assert
       expect(hasPrivilege).toBe(true);
-      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 } },
-      );
+      expect(rus).toHaveBeenCalledWith(loginUser.ObjectId, 'test-session');
     });
 
     it('should return false if user does not have the specified privilege', async () => {
@@ -914,10 +935,19 @@ describe('LoginUser', () => {
       const loginUser = await LoginUser.init(sessionService);
       loginUser.ObjectId = '1';
 
-      const axiosPostMock = jest
-        .spyOn(axios, 'post')
-        .mockResolvedValueOnce({ data: { hasPrivilege: false } } as any);
-
+      // 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,
@@ -926,6 +956,7 @@ 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 () => {