@tomei/sso 0.64.1 → 0.65.1-test.1

package/__tests__/unit/components/api-key/api-key.spec.ts

@@ -0,0 +1,201 @@
+import { APIKey } from '../../../../src/components/api-key/api-key';
+import { APIKeyRepository } from '../../../../src/components/api-key/api-key.repository';
+import { LoginUser } from '../../../../src/components/login-user/login-user';
+import { ApplicationConfig } from '@tomei/config';
+import { Activity } from '@tomei/activity-history';
+import { ClassError } from '@tomei/general';
+import { System } from '../../../../src/components/system/system';
+import { APIKeyStatusEnum } from '../../../../src/enum/api-key.enum';
+
+describe('APIKey', () => {
+  const loginUser = new (LoginUser.prototype as any).constructor();
+  loginUser.ObjectId = '1';
+  loginUser.UserId = 1;
+
+  const apiKeyData = {
+    APIKeyId: 1,
+    ApiKey: 'abc123def456',
+    Name: 'Test Key',
+    SystemCode: 'TST',
+    Description: 'Test description',
+    Status: APIKeyStatusEnum.ACTIVE,
+    ExpirationDate: new Date('2027-01-01'),
+    RevokedById: null,
+    RevokedAt: null,
+    CreatedAt: new Date('2024-01-01'),
+    CreatedById: 1,
+    get: function (opts?: any) {
+      if (opts?.plain) return this;
+      return this;
+    },
+  };
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  beforeEach(() => {
+    jest
+      .spyOn(ApplicationConfig, 'getComponentConfigValue')
+      .mockReturnValue('TST' as any);
+    jest
+      .spyOn(Activity.prototype, 'create')
+      .mockResolvedValue(undefined as any);
+    jest
+      .spyOn(LoginUser.prototype, 'checkPrivileges')
+      .mockResolvedValue(true as any);
+  });
+
+  describe('init', () => {
+    it('should return a new APIKey instance when no ApiKeyId is provided', async () => {
+      const result = await APIKey.init();
+      expect(result).toBeInstanceOf(APIKey);
+      expect(result.APIKeyId).toBeNaN();
+    });
+
+    it('should initialize APIKey with valid ApiKeyId', async () => {
+      jest
+        .spyOn(APIKeyRepository.prototype, 'findByPk')
+        .mockResolvedValueOnce(apiKeyData as any);
+
+      const result = await APIKey.init(1);
+
+      expect(result).toBeInstanceOf(APIKey);
+      expect(result.Name).toBe('Test Key');
+    });
+
+    it('should throw ClassError when ApiKeyId is not found', async () => {
+      jest
+        .spyOn(APIKeyRepository.prototype, 'findByPk')
+        .mockResolvedValueOnce(null);
+
+      await expect(APIKey.init(999)).rejects.toThrow('APIKey not found');
+    });
+  });
+
+  describe('generate', () => {
+    it('should throw when user lacks API_KEY_CREATE privilege', async () => {
+      jest
+        .spyOn(LoginUser.prototype, 'checkPrivileges')
+        .mockResolvedValueOnce(false as any);
+
+      const apiKey = await APIKey.init();
+      apiKey.SystemCode = 'TST';
+
+      await expect(apiKey.generate(loginUser)).rejects.toThrow(
+        'User does not have privilege to generate API key.',
+      );
+    });
+
+    it('should generate an API key successfully', async () => {
+      jest
+        .spyOn(System, 'init')
+        .mockResolvedValueOnce(new (System.prototype as any).constructor() as any);
+      jest
+        .spyOn(APIKeyRepository.prototype, 'create')
+        .mockResolvedValueOnce({ ...apiKeyData, APIKeyId: 1 } as any);
+
+      const apiKey = await APIKey.init();
+      apiKey.SystemCode = 'TST';
+      apiKey.Name = 'Test Key';
+      apiKey.Status = APIKeyStatusEnum.ACTIVE;
+
+      const result = await apiKey.generate(loginUser);
+
+      expect(result).toHaveProperty('ApiKey');
+      expect(result.Name).toBe('Test Key');
+    });
+  });
+
+  describe('findAll', () => {
+    it('should throw when user lacks API_KEY_VIEW privilege', async () => {
+      jest
+        .spyOn(LoginUser.prototype, 'checkPrivileges')
+        .mockResolvedValueOnce(false as any);
+
+      await expect(
+        APIKey.findAll({ page: 1, limit: 10 }, loginUser, null, {}),
+      ).rejects.toThrow('User does not have privilege to generate API key.');
+    });
+
+    it('should return paginated API keys', async () => {
+      jest
+        .spyOn(APIKeyRepository.prototype, 'findAllWithPagination')
+        .mockResolvedValueOnce({
+          count: 1,
+          rows: [new (APIKey.prototype as any).constructor(apiKeyData)],
+        } as any);
+
+      const result = await APIKey.findAll(
+        { page: 1, limit: 10 },
+        loginUser,
+        null,
+        { SystemCode: 'TST' },
+      );
+
+      expect(result.total).toBe(1);
+      expect(result.ApiKeys).toHaveLength(1);
+      expect(result.page).toBe(1);
+      expect(result.limit).toBe(10);
+    });
+
+    it('should apply filters correctly', async () => {
+      const spy = jest
+        .spyOn(APIKeyRepository.prototype, 'findAllWithPagination')
+        .mockResolvedValueOnce({ count: 0, rows: [] } as any);
+
+      const fromDate = new Date('2024-01-01');
+      const toDate = new Date('2024-12-31');
+
+      await APIKey.findAll(
+        { page: 1, limit: 10 },
+        loginUser,
+        null,
+        {
+          Status: APIKeyStatusEnum.ACTIVE,
+          ExpirationDate: { FromDate: fromDate, ToDate: toDate },
+          CreatedById: 1,
+        },
+        { SortBy: 'CreatedAt', SortOrder: 'ASC' },
+      );
+
+      expect(spy).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('revoke', () => {
+    it('should throw when API key is not found', async () => {
+      jest
+        .spyOn(APIKeyRepository.prototype, 'findOne')
+        .mockResolvedValueOnce(null);
+
+      const apiKey = await APIKey.init();
+      await expect(
+        apiKey.revoke('nonexistent-key', loginUser, null),
+      ).rejects.toThrow('API key not found.');
+    });
+
+    it('should revoke an API key successfully', async () => {
+      const apiKeyRecord = {
+        ...apiKeyData,
+        Status: APIKeyStatusEnum.ACTIVE,
+        RevokedAt: null,
+        RevokedById: null,
+        RevokedReason: null,
+        get: (opts?: any) => ({ ...apiKeyData }),
+      };
+      jest
+        .spyOn(APIKeyRepository.prototype, 'findOne')
+        .mockResolvedValueOnce(apiKeyRecord as any);
+      jest
+        .spyOn(APIKeyRepository.prototype, 'update')
+        .mockResolvedValueOnce(undefined as any);
+
+      const apiKey = await APIKey.init();
+      const result = await apiKey.revoke('abc123def456', loginUser, null, 'No longer needed');
+
+      expect(result.Status).toBe(APIKeyStatusEnum.REVOKED);
+      expect(result.RevokedReason).toBe('No longer needed');
+    });
+  });
+});

package/__tests__/unit/components/group/group.spec.ts

@@ -1,80 +1,86 @@
-import { Group } from '../../../../src/components/group/group';
-import { GroupRepository } from '../../../../src/components/group/group.repository';
-import { ClassError } from '@tomei/general';
-import { GroupTypeEnum } from '../../../../src/enum/group-type.enum';
-
-
-describe('Group', () => {
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('should initialize a group with valid GroupCode', async () => {
-    const groupAttr = {
-      GroupCode: 'group1',
-      Name: 'Group 1',
-      Description: 'This is Group 1',
-      Type: GroupTypeEnum.ROLE,
-      ParentGroupCode: 'parentGroup1',
-      InheritParentPrivilegeYN: 'Y',
-      InheritParentSystemAccessYN: 'N',
-      Status: 'Active',
-      CreatedById: 1,
-      CreatedAt: new Date(),
-      UpdatedById: 2,
-      UpdatedAt: new Date(),
-    };
-
-    const groupRepositoryMock = jest.spyOn(GroupRepository.prototype, 'findByPk').mockResolvedValueOnce({
-      ...groupAttr,
-      get: () => groupAttr,
-    } as any);
-
-    const result = await Group.init(null, 'group1');
-
-    expect(result).toBeInstanceOf(Group);
-    expect(result.GroupCode).toBe(groupAttr.GroupCode);
-    expect(result.Name).toBe(groupAttr.Name);
-    expect(result.Description).toBe(groupAttr.Description);
-    expect(result.Type).toBe(groupAttr.Type);
-    expect(result.ParentGroupCode).toBe(groupAttr.ParentGroupCode);
-    expect(result.InheritParentPrivilegeYN).toBe(groupAttr.InheritParentPrivilegeYN);
-    expect(result.InheritParentSystemAccessYN).toBe(groupAttr.InheritParentSystemAccessYN);
-    expect(result.Status).toBe(groupAttr.Status);
-    expect(result.CreatedById).toBe(groupAttr.CreatedById);
-    expect(result.CreatedAt).toBe(groupAttr.CreatedAt);
-    expect(result.UpdatedById).toBe(groupAttr.UpdatedById);
-    expect(result.UpdatedAt).toBe(groupAttr.UpdatedAt);
-
-    expect(groupRepositoryMock).toHaveBeenCalledTimes(1);
-    expect(groupRepositoryMock).toHaveBeenCalledWith('group1', {
-      transaction: null,
-    });
-  });
-
-  it('should throw an error when initializing a group with invalid GroupCode', async () => {
-    const groupRepositoryMock = jest.spyOn(GroupRepository.prototype, 'findByPk').mockResolvedValueOnce(null);
-
-    await expect(Group.init(null, 'invalidGroupCode')).rejects.toThrow(
-      new ClassError('Group', 'GroupErrMsg01', 'Failed To Initialize Group')
-    );
-
-    expect(groupRepositoryMock).toHaveBeenCalledTimes(1);
-    expect(groupRepositoryMock).toHaveBeenCalledWith('invalidGroupCode', {
-      transaction: null,
-    });
-  });
-
-  it('should throw an error when initializing a group with an error', async () => {
-    const groupRepositoryMock = jest.spyOn(GroupRepository.prototype, 'findByPk').mockRejectedValueOnce(new Error('Database error'));
-
-    await expect(Group.init(null, 'group1')).rejects.toThrow(
-      new ClassError('Group', 'GroupErrMsg01', 'Failed To Initialize Group')
-    );
-
-    expect(groupRepositoryMock).toHaveBeenCalledTimes(1);
-    expect(groupRepositoryMock).toHaveBeenCalledWith('group1', {
-      transaction: null,
-    });
-  });
+import { Group } from '../../../../src/components/group/group';
+import { GroupRepository } from '../../../../src/components/group/group.repository';
+import { ClassError } from '@tomei/general';
+import { GroupTypeEnum } from '../../../../src/enum/group-type.enum';
+import { RedisService } from '../../../../src/redis-client/redis.service';
+
+
+describe('Group', () => {
+  beforeAll(() => {
+    process.env.REDIS_HOST = 'localhost';
+    process.env.REDIS_PORT = '6379';
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should initialize a group with valid GroupCode', async () => {
+    const groupAttr = {
+      GroupCode: 'group1',
+      Name: 'Group 1',
+      Description: 'This is Group 1',
+      Type: GroupTypeEnum.ROLE,
+      ParentGroupCode: 'parentGroup1',
+      InheritParentPrivilegeYN: 'Y',
+      InheritParentSystemAccessYN: 'N',
+      Status: 'Active',
+      CreatedById: 1,
+      CreatedAt: new Date(),
+      UpdatedById: 2,
+      UpdatedAt: new Date(),
+    };
+
+    const groupRepositoryMock = jest.spyOn(GroupRepository.prototype, 'findByPk').mockResolvedValueOnce({
+      ...groupAttr,
+      get: () => groupAttr,
+    } as any);
+
+    const result = await Group.init(null, 'group1');
+
+    expect(result).toBeInstanceOf(Group);
+    expect(result.GroupCode).toBe(groupAttr.GroupCode);
+    expect(result.Name).toBe(groupAttr.Name);
+    expect(result.Description).toBe(groupAttr.Description);
+    expect(result.Type).toBe(groupAttr.Type);
+    expect(result.ParentGroupCode).toBe(groupAttr.ParentGroupCode);
+    expect(result.InheritParentPrivilegeYN).toBe(groupAttr.InheritParentPrivilegeYN);
+    expect(result.InheritParentSystemAccessYN).toBe(groupAttr.InheritParentSystemAccessYN);
+    expect(result.Status).toBe(groupAttr.Status);
+    expect(result.CreatedById).toBe(groupAttr.CreatedById);
+    expect(result.CreatedAt).toBe(groupAttr.CreatedAt);
+    expect(result.UpdatedById).toBe(groupAttr.UpdatedById);
+    expect(result.UpdatedAt).toBe(groupAttr.UpdatedAt);
+
+    expect(groupRepositoryMock).toHaveBeenCalledTimes(1);
+    expect(groupRepositoryMock).toHaveBeenCalledWith('group1', {
+      transaction: null,
+    });
+  });
+
+  it('should throw an error when initializing a group with invalid GroupCode', async () => {
+    const groupRepositoryMock = jest.spyOn(GroupRepository.prototype, 'findByPk').mockResolvedValueOnce(null);
+
+    await expect(Group.init(null, 'invalidGroupCode')).rejects.toThrow(
+      new ClassError('Group', 'GroupErrMsg01', 'Failed To Initialize Group')
+    );
+
+    expect(groupRepositoryMock).toHaveBeenCalledTimes(1);
+    expect(groupRepositoryMock).toHaveBeenCalledWith('invalidGroupCode', {
+      transaction: null,
+    });
+  });
+
+  it('should throw an error when initializing a group with an error', async () => {
+    const groupRepositoryMock = jest.spyOn(GroupRepository.prototype, 'findByPk').mockRejectedValueOnce(new Error('Database error'));
+
+    await expect(Group.init(null, 'group1')).rejects.toThrow(
+      new ClassError('Group', 'GroupErrMsg01', 'Failed To Initialize Group')
+    );
+
+    expect(groupRepositoryMock).toHaveBeenCalledTimes(1);
+    expect(groupRepositoryMock).toHaveBeenCalledWith('group1', {
+      transaction: null,
+    });
+  });
 });

package/__tests__/unit/components/group-object-privilege/group-object-privilege.spec.ts

@@ -1,89 +1,89 @@
-import { GroupObjectPrivilegeRepository } from '../../../../src/components/group-object-privilege/group-object-privilege.repository';
-import { GroupObjectPrivilege } from '../../../../src/components/group-object-privilege/group-object-privilege';
-
-describe('GroupObjectPrivilege', () => {
-  let groupObjectPrivilege: GroupObjectPrivilege;
-
-  beforeEach(() => {
-    groupObjectPrivilege = new GroupObjectPrivilege();
-  });
-
-  it('should create an instance of GroupObjectPrivilege', () => {
-    expect(groupObjectPrivilege).toBeInstanceOf(GroupObjectPrivilege);
-  });
-
-  it('should have the correct TableName', () => {
-    expect(groupObjectPrivilege.TableName).toBe('sso_GroupObjectPrivilege');
-  });
-
-  it('should have the correct properties', () => {
-    expect(groupObjectPrivilege.ObjectName).toBeUndefined();
-    expect(groupObjectPrivilege.GroupObjectPrivilegeId).toBeUndefined();
-    expect(groupObjectPrivilege.GroupCode).toBeUndefined();
-    expect(groupObjectPrivilege.SystemPrivilegeId).toBeUndefined();
-    expect(groupObjectPrivilege.ObjectId).toBeUndefined();
-    expect(groupObjectPrivilege.ObjectType).toBeUndefined();
-    expect(groupObjectPrivilege.CreatedAt).toBeUndefined();
-    expect(groupObjectPrivilege.UpdatedAt).toBeUndefined();
-    expect(groupObjectPrivilege.CreatedById).toBeUndefined();
-    expect(groupObjectPrivilege.UpdatedById).toBeUndefined();
-  });
-
-  describe('init', () => {
-    it('should return an instance of GroupObjectPrivilege when GroupObjectPrivilegeId is provided', async () => {
-      const GroupObjectPrivilegeId = 1;
-      const mockGroupObjectPrivilegeAttr = {
-        GroupObjectPrivilegeId,
-        GroupCode: 'groupCode',
-        SystemPrivilegeId: 'SystemPrivilegeId',
-        ObjectId: 'objectId',
-        ObjectType: 'objectType',
-        CreatedAt: new Date(),
-        UpdatedAt: new Date(),
-        CreatedById: 1,
-        UpdatedById: 2,
-      };
-
-      jest.spyOn(GroupObjectPrivilegeRepository.prototype, 'findOne').mockResolvedValueOnce({
-        get: () => mockGroupObjectPrivilegeAttr,
-      } as any);
-
-      const result = await GroupObjectPrivilege.init(null, GroupObjectPrivilegeId);
-
-      expect(result).toBeInstanceOf(GroupObjectPrivilege);
-      expect(result.GroupObjectPrivilegeId).toBe(GroupObjectPrivilegeId);
-      expect(result.GroupCode).toBe(mockGroupObjectPrivilegeAttr.GroupCode);
-      expect(result.SystemPrivilegeId).toBe(mockGroupObjectPrivilegeAttr.SystemPrivilegeId);
-      expect(result.ObjectId).toBe(mockGroupObjectPrivilegeAttr.ObjectId);
-      expect(result.ObjectType).toBe(mockGroupObjectPrivilegeAttr.ObjectType);
-      expect(result.CreatedAt).toBe(mockGroupObjectPrivilegeAttr.CreatedAt);
-      expect(result.UpdatedAt).toBe(mockGroupObjectPrivilegeAttr.UpdatedAt);
-      expect(result.CreatedById).toBe(mockGroupObjectPrivilegeAttr.CreatedById);
-      expect(result.UpdatedById).toBe(mockGroupObjectPrivilegeAttr.UpdatedById);
-    });
-
-    it('should throw an error when GroupObjectPrivilegeId is provided but no GroupObjectPrivilege is found', async () => {
-      const GroupObjectPrivilegeId = 1;
-      jest.spyOn(GroupObjectPrivilegeRepository.prototype, 'findOne').mockResolvedValueOnce(null);
-
-      await expect(GroupObjectPrivilege.init(null, GroupObjectPrivilegeId)).rejects.toThrow(
-        'GroupObjectPrivilege not found',
-      );
-    });
-
-    it('should return a new instance of GroupObjectPrivilege when GroupObjectPrivilegeId is not provided', async () => {
-      const result = await GroupObjectPrivilege.init();
-
-      expect(result).toBeInstanceOf(GroupObjectPrivilege);
-      expect(result.GroupObjectPrivilegeId).toBeUndefined();
-      expect(result.GroupCode).toBeUndefined();
-      expect(result.SystemPrivilegeId).toBeUndefined();
-      expect(result.ObjectId).toBeUndefined();
-      expect(result.ObjectType).toBeUndefined();
-      expect(result.CreatedAt).toBeUndefined();
-      expect(result.UpdatedAt).toBeUndefined();
-      expect(result.CreatedById).toBeUndefined();
-      expect(result.UpdatedById).toBeUndefined();
-    });
-  });
+import { GroupObjectPrivilegeRepository } from '../../../../src/components/group-object-privilege/group-object-privilege.repository';
+import { GroupObjectPrivilege } from '../../../../src/components/group-object-privilege/group-object-privilege';
+
+describe('GroupObjectPrivilege', () => {
+  let groupObjectPrivilege: GroupObjectPrivilege;
+
+  beforeEach(() => {
+    groupObjectPrivilege = new GroupObjectPrivilege();
+  });
+
+  it('should create an instance of GroupObjectPrivilege', () => {
+    expect(groupObjectPrivilege).toBeInstanceOf(GroupObjectPrivilege);
+  });
+
+  it('should have the correct TableName', () => {
+    expect(groupObjectPrivilege.TableName).toBe('sso_GroupObjectPrivilege');
+  });
+
+  it('should have the correct properties', () => {
+    expect(groupObjectPrivilege.ObjectName).toBeUndefined();
+    expect(groupObjectPrivilege.GroupObjectPrivilegeId).toBeUndefined();
+    expect(groupObjectPrivilege.GroupCode).toBeUndefined();
+    expect(groupObjectPrivilege.SystemPrivilegeId).toBeUndefined();
+    expect(groupObjectPrivilege.ObjectId).toBeUndefined();
+    expect(groupObjectPrivilege.ObjectType).toBeUndefined();
+    expect(groupObjectPrivilege.CreatedAt).toBeUndefined();
+    expect(groupObjectPrivilege.UpdatedAt).toBeUndefined();
+    expect(groupObjectPrivilege.CreatedById).toBeUndefined();
+    expect(groupObjectPrivilege.UpdatedById).toBeUndefined();
+  });
+
+  describe('init', () => {
+    it('should return an instance of GroupObjectPrivilege when GroupObjectPrivilegeId is provided', async () => {
+      const GroupObjectPrivilegeId = 1;
+      const mockGroupObjectPrivilegeAttr = {
+        GroupObjectPrivilegeId,
+        GroupCode: 'groupCode',
+        SystemPrivilegeId: 'SystemPrivilegeId',
+        ObjectId: 'objectId',
+        ObjectType: 'objectType',
+        CreatedAt: new Date(),
+        UpdatedAt: new Date(),
+        CreatedById: 1,
+        UpdatedById: 2,
+      };
+
+      jest.spyOn(GroupObjectPrivilegeRepository.prototype, 'findOne').mockResolvedValueOnce({
+        get: () => mockGroupObjectPrivilegeAttr,
+      } as any);
+
+      const result = await GroupObjectPrivilege.init(null, GroupObjectPrivilegeId);
+
+      expect(result).toBeInstanceOf(GroupObjectPrivilege);
+      expect(result.GroupObjectPrivilegeId).toBe(GroupObjectPrivilegeId);
+      expect(result.GroupCode).toBe(mockGroupObjectPrivilegeAttr.GroupCode);
+      expect(result.SystemPrivilegeId).toBe(mockGroupObjectPrivilegeAttr.SystemPrivilegeId);
+      expect(result.ObjectId).toBe(mockGroupObjectPrivilegeAttr.ObjectId);
+      expect(result.ObjectType).toBe(mockGroupObjectPrivilegeAttr.ObjectType);
+      expect(result.CreatedAt).toBe(mockGroupObjectPrivilegeAttr.CreatedAt);
+      expect(result.UpdatedAt).toBe(mockGroupObjectPrivilegeAttr.UpdatedAt);
+      expect(result.CreatedById).toBe(mockGroupObjectPrivilegeAttr.CreatedById);
+      expect(result.UpdatedById).toBe(mockGroupObjectPrivilegeAttr.UpdatedById);
+    });
+
+    it('should throw an error when GroupObjectPrivilegeId is provided but no GroupObjectPrivilege is found', async () => {
+      const GroupObjectPrivilegeId = 1;
+      jest.spyOn(GroupObjectPrivilegeRepository.prototype, 'findOne').mockResolvedValueOnce(null);
+
+      await expect(GroupObjectPrivilege.init(null, GroupObjectPrivilegeId)).rejects.toThrow(
+        'GroupObjectPrivilege not found',
+      );
+    });
+
+    it('should return a new instance of GroupObjectPrivilege when GroupObjectPrivilegeId is not provided', async () => {
+      const result = await GroupObjectPrivilege.init();
+
+      expect(result).toBeInstanceOf(GroupObjectPrivilege);
+      expect(result.GroupObjectPrivilegeId).toBeUndefined();
+      expect(result.GroupCode).toBeUndefined();
+      expect(result.SystemPrivilegeId).toBeUndefined();
+      expect(result.ObjectId).toBeUndefined();
+      expect(result.ObjectType).toBeUndefined();
+      expect(result.CreatedAt).toBeUndefined();
+      expect(result.UpdatedAt).toBeUndefined();
+      expect(result.CreatedById).toBeUndefined();
+      expect(result.UpdatedById).toBeUndefined();
+    });
+  });
 });