@tomei/sso 0.41.1 → 0.42.2

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.toThrowError(
-        '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.toThrowError(
+        '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();
+    });
+  });
 });

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

@@ -1,69 +1,69 @@
-import { GroupPrivilege } from '../../../../src/components/group-privilege/group-privilege';
-import { GroupPrivilegeRepository } from '../../../../src/components/group-privilege/group-privilege.repository';
-import { ClassError } from '@tomei/general';
-
-describe('GroupPrivilege', () => {
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  it('should initialize with GroupPrivilegeAttr', async () => {
-    const mockGroupPrivilegeAttr = {
-      GroupPrivilegeId: 1,
-      GroupCode: 'group1',
-      SystemPrivilegeId: 'privilege1',
-      Status: 'active',
-      CreatedAt: new Date(),
-      UpdatedAt: new Date(),
-      CreatedById: 1,
-      UpdatedById: 1,
-    };
-
-    const findOneMock = jest
-      .spyOn(GroupPrivilegeRepository.prototype, 'findOne')
-      .mockResolvedValueOnce({ get: jest.fn().mockReturnValue(mockGroupPrivilegeAttr) } as any);
-
-    const groupPrivilege = await GroupPrivilege.init(null, 1);
-
-    expect(findOneMock).toBeCalledWith({
-      where: { GroupPrivilegeId: 1 },
-      transaction: null,
-    });
-    expect(groupPrivilege).toBeInstanceOf(GroupPrivilege);
-    expect(groupPrivilege.GroupPrivilegeId).toEqual(mockGroupPrivilegeAttr.GroupPrivilegeId);
-    expect(groupPrivilege.GroupCode).toEqual(mockGroupPrivilegeAttr.GroupCode);
-    expect(groupPrivilege.SystemPrivilegeId).toEqual(mockGroupPrivilegeAttr.SystemPrivilegeId);
-    expect(groupPrivilege.Status).toEqual(mockGroupPrivilegeAttr.Status);
-    expect(groupPrivilege.CreatedAt).toEqual(mockGroupPrivilegeAttr.CreatedAt);
-    expect(groupPrivilege.UpdatedAt).toEqual(mockGroupPrivilegeAttr.UpdatedAt);
-    expect(groupPrivilege.CreatedById).toEqual(mockGroupPrivilegeAttr.CreatedById);
-    expect(groupPrivilege.UpdatedById).toEqual(mockGroupPrivilegeAttr.UpdatedById);
-  });
-
-  it('should throw ClassError when GroupPrivilegeAttr is not found', async () => {
-    const findOneMock = jest
-      .spyOn(GroupPrivilegeRepository.prototype, 'findOne')
-      .mockResolvedValueOnce(null);
-
-    await expect(GroupPrivilege.init(null, 1)).rejects.toThrow(ClassError);
-
-    expect(findOneMock).toBeCalledWith({
-      where: { GroupPrivilegeId: 1 },
-      transaction: null,
-    });
-  });
-
-  it('should initialize with default values', async () => {
-    const groupPrivilege = await GroupPrivilege.init();
-
-    expect(groupPrivilege).toBeInstanceOf(GroupPrivilege);
-    expect(groupPrivilege.GroupPrivilegeId).toBeUndefined();
-    expect(groupPrivilege.GroupCode).toBeUndefined();
-    expect(groupPrivilege.SystemPrivilegeId).toBeUndefined();
-    expect(groupPrivilege.Status).toBeUndefined();
-    expect(groupPrivilege.CreatedAt).toBeUndefined();
-    expect(groupPrivilege.UpdatedAt).toBeUndefined();
-    expect(groupPrivilege.CreatedById).toBeUndefined();
-    expect(groupPrivilege.UpdatedById).toBeUndefined();
-  });
+import { GroupPrivilege } from '../../../../src/components/group-privilege/group-privilege';
+import { GroupPrivilegeRepository } from '../../../../src/components/group-privilege/group-privilege.repository';
+import { ClassError } from '@tomei/general';
+
+describe('GroupPrivilege', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('should initialize with GroupPrivilegeAttr', async () => {
+    const mockGroupPrivilegeAttr = {
+      GroupPrivilegeId: 1,
+      GroupCode: 'group1',
+      SystemPrivilegeId: 'privilege1',
+      Status: 'active',
+      CreatedAt: new Date(),
+      UpdatedAt: new Date(),
+      CreatedById: 1,
+      UpdatedById: 1,
+    };
+
+    const findOneMock = jest
+      .spyOn(GroupPrivilegeRepository.prototype, 'findOne')
+      .mockResolvedValueOnce({ get: jest.fn().mockReturnValue(mockGroupPrivilegeAttr) } as any);
+
+    const groupPrivilege = await GroupPrivilege.init(null, 1);
+
+    expect(findOneMock).toBeCalledWith({
+      where: { GroupPrivilegeId: 1 },
+      transaction: null,
+    });
+    expect(groupPrivilege).toBeInstanceOf(GroupPrivilege);
+    expect(groupPrivilege.GroupPrivilegeId).toEqual(mockGroupPrivilegeAttr.GroupPrivilegeId);
+    expect(groupPrivilege.GroupCode).toEqual(mockGroupPrivilegeAttr.GroupCode);
+    expect(groupPrivilege.SystemPrivilegeId).toEqual(mockGroupPrivilegeAttr.SystemPrivilegeId);
+    expect(groupPrivilege.Status).toEqual(mockGroupPrivilegeAttr.Status);
+    expect(groupPrivilege.CreatedAt).toEqual(mockGroupPrivilegeAttr.CreatedAt);
+    expect(groupPrivilege.UpdatedAt).toEqual(mockGroupPrivilegeAttr.UpdatedAt);
+    expect(groupPrivilege.CreatedById).toEqual(mockGroupPrivilegeAttr.CreatedById);
+    expect(groupPrivilege.UpdatedById).toEqual(mockGroupPrivilegeAttr.UpdatedById);
+  });
+
+  it('should throw ClassError when GroupPrivilegeAttr is not found', async () => {
+    const findOneMock = jest
+      .spyOn(GroupPrivilegeRepository.prototype, 'findOne')
+      .mockResolvedValueOnce(null);
+
+    await expect(GroupPrivilege.init(null, 1)).rejects.toThrow(ClassError);
+
+    expect(findOneMock).toBeCalledWith({
+      where: { GroupPrivilegeId: 1 },
+      transaction: null,
+    });
+  });
+
+  it('should initialize with default values', async () => {
+    const groupPrivilege = await GroupPrivilege.init();
+
+    expect(groupPrivilege).toBeInstanceOf(GroupPrivilege);
+    expect(groupPrivilege.GroupPrivilegeId).toBeUndefined();
+    expect(groupPrivilege.GroupCode).toBeUndefined();
+    expect(groupPrivilege.SystemPrivilegeId).toBeUndefined();
+    expect(groupPrivilege.Status).toBeUndefined();
+    expect(groupPrivilege.CreatedAt).toBeUndefined();
+    expect(groupPrivilege.UpdatedAt).toBeUndefined();
+    expect(groupPrivilege.CreatedById).toBeUndefined();
+    expect(groupPrivilege.UpdatedById).toBeUndefined();
+  });
 });

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

@@ -1,67 +1,67 @@
-import { GroupReportingUser } from '../../../../src/components/group-reporting-user/group-reporting-user';
-import { GroupReportingUserRepository } from '../../../../src/components/group-reporting-user/group-reporting-user.repository';
-import { ClassError } from '@tomei/general';
-
-describe('GroupReportingUser', () => {
-  const mockGroupReportingUserAttr = {
-    GroupReportingUserId: 1,
-    GroupCode: 'test',
-    UserId: 1,
-    Rank: 1,
-    Status: 'active',
-    CreatedById: 1,
-    CreatedAt: new Date(),
-    UpdatedById: 1,
-    UpdatedAt: new Date(),
-  };
-
-  beforeEach(async () => {
-    jest.clearAllMocks();
-  });
-
-
-  describe('init', () => {
-    const mockDbTransaction = {};
-
-    it('should initialize GroupReportingUser without GroupReportingUserId', async () => {
-      const initGroupReportingUser = await GroupReportingUser.init(mockDbTransaction);
-      expect(initGroupReportingUser).toBeDefined();
-      expect(initGroupReportingUser).toBeInstanceOf(GroupReportingUser);
-    });
-
-    it('should initialize GroupReportingUser with valid GroupReportingUserId', async () => {
-      const mockFindByPk = jest
-        .spyOn(GroupReportingUserRepository.prototype, 'findByPk')
-        .mockResolvedValue({
-          ...mockGroupReportingUserAttr,
-          get: () => mockGroupReportingUserAttr,
-        } as any);
-
-      const initGroupReportingUser = await GroupReportingUser.init(
-        mockDbTransaction,
-        '1'
-      );
-      expect(initGroupReportingUser).toBeDefined();
-      expect(initGroupReportingUser).toBeInstanceOf(GroupReportingUser);
-      expect(mockFindByPk).toHaveBeenCalledWith('1', {
-        transaction: mockDbTransaction,
-      });
-    });
-
-    it('should throw ClassError when GroupReportingUser is not found', async () => {
-      jest.spyOn(GroupReportingUserRepository.prototype, 'findByPk').mockResolvedValue(null);
-
-      await expect(
-        GroupReportingUser.init(mockDbTransaction, '1')
-      ).rejects.toThrowError(ClassError);
-    });
-
-    it('should throw ClassError when failed to initialize GroupReportingUser', async () => {
-      jest.spyOn(GroupReportingUserRepository.prototype, 'findByPk').mockRejectedValue(new Error());
-
-      await expect(
-        GroupReportingUser.init(mockDbTransaction, '1')
-      ).rejects.toThrowError(ClassError);
-    });
-  });
+import { GroupReportingUser } from '../../../../src/components/group-reporting-user/group-reporting-user';
+import { GroupReportingUserRepository } from '../../../../src/components/group-reporting-user/group-reporting-user.repository';
+import { ClassError } from '@tomei/general';
+
+describe('GroupReportingUser', () => {
+  const mockGroupReportingUserAttr = {
+    GroupReportingUserId: 1,
+    GroupCode: 'test',
+    UserId: 1,
+    Rank: 1,
+    Status: 'active',
+    CreatedById: 1,
+    CreatedAt: new Date(),
+    UpdatedById: 1,
+    UpdatedAt: new Date(),
+  };
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+  });
+
+
+  describe('init', () => {
+    const mockDbTransaction = {};
+
+    it('should initialize GroupReportingUser without GroupReportingUserId', async () => {
+      const initGroupReportingUser = await GroupReportingUser.init(mockDbTransaction);
+      expect(initGroupReportingUser).toBeDefined();
+      expect(initGroupReportingUser).toBeInstanceOf(GroupReportingUser);
+    });
+
+    it('should initialize GroupReportingUser with valid GroupReportingUserId', async () => {
+      const mockFindByPk = jest
+        .spyOn(GroupReportingUserRepository.prototype, 'findByPk')
+        .mockResolvedValue({
+          ...mockGroupReportingUserAttr,
+          get: () => mockGroupReportingUserAttr,
+        } as any);
+
+      const initGroupReportingUser = await GroupReportingUser.init(
+        mockDbTransaction,
+        '1'
+      );
+      expect(initGroupReportingUser).toBeDefined();
+      expect(initGroupReportingUser).toBeInstanceOf(GroupReportingUser);
+      expect(mockFindByPk).toHaveBeenCalledWith('1', {
+        transaction: mockDbTransaction,
+      });
+    });
+
+    it('should throw ClassError when GroupReportingUser is not found', async () => {
+      jest.spyOn(GroupReportingUserRepository.prototype, 'findByPk').mockResolvedValue(null);
+
+      await expect(
+        GroupReportingUser.init(mockDbTransaction, '1')
+      ).rejects.toThrowError(ClassError);
+    });
+
+    it('should throw ClassError when failed to initialize GroupReportingUser', async () => {
+      jest.spyOn(GroupReportingUserRepository.prototype, 'findByPk').mockRejectedValue(new Error());
+
+      await expect(
+        GroupReportingUser.init(mockDbTransaction, '1')
+      ).rejects.toThrowError(ClassError);
+    });
+  });
 });

package/__tests__/unit/components/group-system-access/group-system-access.spec.ts

@@ -1,84 +1,84 @@
-import { GroupSystemAccess } from '../../../../src/components/group-system-access/group-system-access';
-import { GroupSystemAccessRepository } from '../../../../src/components/group-system-access/group-system-access.repository';
-import { ClassError } from '@tomei/general';
-
-describe('GroupSystemAccess', () => {
-  let groupSystemAccess: GroupSystemAccess;
-  const groupSystemAccessAttr = {
-    GroupSystemAccessId: 1,
-    GroupCode: 'test',
-    SystemCode: 'test',
-    Status: 'test',
-    CreatedById: 1,
-    CreatedAt: new Date(),
-    UpdatedById: 1,
-    UpdatedAt: new Date(),
-  };
-
-  beforeEach(() => {
-    jest.resetAllMocks();
-    groupSystemAccess = new GroupSystemAccess(groupSystemAccessAttr);
-  });
-
-  it('should create a new GroupSystemAccess instance', () => {
-    expect(groupSystemAccess).toBeDefined();
-    expect(groupSystemAccess).toBeInstanceOf(GroupSystemAccess);
-    expect(groupSystemAccess.GroupSystemAccessId).toBe(groupSystemAccessAttr.GroupSystemAccessId);
-    expect(groupSystemAccess.GroupCode).toBe(groupSystemAccessAttr.GroupCode);
-    expect(groupSystemAccess.SystemCode).toBe(groupSystemAccessAttr.SystemCode);
-    expect(groupSystemAccess.Status).toBe(groupSystemAccessAttr.Status);
-    expect(groupSystemAccess.CreatedById).toBe(groupSystemAccessAttr.CreatedById);
-    expect(groupSystemAccess.CreatedAt).toBe(groupSystemAccessAttr.CreatedAt);
-    expect(groupSystemAccess.UpdatedById).toBe(groupSystemAccessAttr.UpdatedById);
-    expect(groupSystemAccess.UpdatedAt).toBe(groupSystemAccessAttr.UpdatedAt);
-  });
-
-  describe('init', () => {
-    it('should initialize GroupSystemAccess without GroupSystemAccessId', async () => {
-      const groupSystemAccess = await GroupSystemAccess.init(null);
-      expect(groupSystemAccess).toBeDefined();
-      expect(groupSystemAccess).toBeInstanceOf(GroupSystemAccess);
-      expect(groupSystemAccess.GroupSystemAccessId).toBeUndefined();
-      expect(groupSystemAccess.GroupCode).toBeUndefined();
-      expect(groupSystemAccess.SystemCode).toBeUndefined();
-      expect(groupSystemAccess.Status).toBeUndefined();
-      expect(groupSystemAccess.CreatedById).toBeUndefined();
-      expect(groupSystemAccess.CreatedAt).toBeUndefined();
-      expect(groupSystemAccess.UpdatedById).toBeUndefined();
-      expect(groupSystemAccess.UpdatedAt).toBeUndefined();
-    });
-
-    it('should initialize GroupSystemAccess with GroupSystemAccessId', async () => {
-      const findOneSpy = jest
-        .spyOn(GroupSystemAccessRepository.prototype, 'findOne')
-        .mockResolvedValue({
-          ...groupSystemAccessAttr,
-          get: () => groupSystemAccessAttr,
-        } as any);
-
-      const groupSystemAccess = await GroupSystemAccess.init(null, 1);
-      expect(findOneSpy).toHaveBeenCalledWith({
-        where: { GroupSystemAccessId: 1 },
-        transaction: null,
-      });
-      expect(groupSystemAccess).toBeDefined();
-      expect(groupSystemAccess).toBeInstanceOf(GroupSystemAccess);
-      expect(groupSystemAccess.GroupSystemAccessId).toBe(groupSystemAccessAttr.GroupSystemAccessId);
-      expect(groupSystemAccess.GroupCode).toBe(groupSystemAccessAttr.GroupCode);
-      expect(groupSystemAccess.SystemCode).toBe(groupSystemAccessAttr.SystemCode);
-      expect(groupSystemAccess.Status).toBe(groupSystemAccessAttr.Status);
-      expect(groupSystemAccess.CreatedById).toBe(groupSystemAccessAttr.CreatedById);
-      expect(groupSystemAccess.CreatedAt).toBe(groupSystemAccessAttr.CreatedAt);
-      expect(groupSystemAccess.UpdatedById).toBe(groupSystemAccessAttr.UpdatedById);
-      expect(groupSystemAccess.UpdatedAt).toBe(groupSystemAccessAttr.UpdatedAt);
-    });
-
-    it('should throw an error if GroupSystemAccessId is not found', async () => {
-      jest.spyOn(GroupSystemAccessRepository.prototype, 'findOne').mockResolvedValue(null);
-
-      await expect(GroupSystemAccess.init(null, 1)).rejects.toThrow(
-        new ClassError('groupSystemAccess', 'groupSystemAccessErrMsg00', 'groupSystemAccess not found'),
-      );
-    });
-  });
+import { GroupSystemAccess } from '../../../../src/components/group-system-access/group-system-access';
+import { GroupSystemAccessRepository } from '../../../../src/components/group-system-access/group-system-access.repository';
+import { ClassError } from '@tomei/general';
+
+describe('GroupSystemAccess', () => {
+  let groupSystemAccess: GroupSystemAccess;
+  const groupSystemAccessAttr = {
+    GroupSystemAccessId: 1,
+    GroupCode: 'test',
+    SystemCode: 'test',
+    Status: 'test',
+    CreatedById: 1,
+    CreatedAt: new Date(),
+    UpdatedById: 1,
+    UpdatedAt: new Date(),
+  };
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    groupSystemAccess = new GroupSystemAccess(groupSystemAccessAttr);
+  });
+
+  it('should create a new GroupSystemAccess instance', () => {
+    expect(groupSystemAccess).toBeDefined();
+    expect(groupSystemAccess).toBeInstanceOf(GroupSystemAccess);
+    expect(groupSystemAccess.GroupSystemAccessId).toBe(groupSystemAccessAttr.GroupSystemAccessId);
+    expect(groupSystemAccess.GroupCode).toBe(groupSystemAccessAttr.GroupCode);
+    expect(groupSystemAccess.SystemCode).toBe(groupSystemAccessAttr.SystemCode);
+    expect(groupSystemAccess.Status).toBe(groupSystemAccessAttr.Status);
+    expect(groupSystemAccess.CreatedById).toBe(groupSystemAccessAttr.CreatedById);
+    expect(groupSystemAccess.CreatedAt).toBe(groupSystemAccessAttr.CreatedAt);
+    expect(groupSystemAccess.UpdatedById).toBe(groupSystemAccessAttr.UpdatedById);
+    expect(groupSystemAccess.UpdatedAt).toBe(groupSystemAccessAttr.UpdatedAt);
+  });
+
+  describe('init', () => {
+    it('should initialize GroupSystemAccess without GroupSystemAccessId', async () => {
+      const groupSystemAccess = await GroupSystemAccess.init(null);
+      expect(groupSystemAccess).toBeDefined();
+      expect(groupSystemAccess).toBeInstanceOf(GroupSystemAccess);
+      expect(groupSystemAccess.GroupSystemAccessId).toBeUndefined();
+      expect(groupSystemAccess.GroupCode).toBeUndefined();
+      expect(groupSystemAccess.SystemCode).toBeUndefined();
+      expect(groupSystemAccess.Status).toBeUndefined();
+      expect(groupSystemAccess.CreatedById).toBeUndefined();
+      expect(groupSystemAccess.CreatedAt).toBeUndefined();
+      expect(groupSystemAccess.UpdatedById).toBeUndefined();
+      expect(groupSystemAccess.UpdatedAt).toBeUndefined();
+    });
+
+    it('should initialize GroupSystemAccess with GroupSystemAccessId', async () => {
+      const findOneSpy = jest
+        .spyOn(GroupSystemAccessRepository.prototype, 'findOne')
+        .mockResolvedValue({
+          ...groupSystemAccessAttr,
+          get: () => groupSystemAccessAttr,
+        } as any);
+
+      const groupSystemAccess = await GroupSystemAccess.init(null, 1);
+      expect(findOneSpy).toHaveBeenCalledWith({
+        where: { GroupSystemAccessId: 1 },
+        transaction: null,
+      });
+      expect(groupSystemAccess).toBeDefined();
+      expect(groupSystemAccess).toBeInstanceOf(GroupSystemAccess);
+      expect(groupSystemAccess.GroupSystemAccessId).toBe(groupSystemAccessAttr.GroupSystemAccessId);
+      expect(groupSystemAccess.GroupCode).toBe(groupSystemAccessAttr.GroupCode);
+      expect(groupSystemAccess.SystemCode).toBe(groupSystemAccessAttr.SystemCode);
+      expect(groupSystemAccess.Status).toBe(groupSystemAccessAttr.Status);
+      expect(groupSystemAccess.CreatedById).toBe(groupSystemAccessAttr.CreatedById);
+      expect(groupSystemAccess.CreatedAt).toBe(groupSystemAccessAttr.CreatedAt);
+      expect(groupSystemAccess.UpdatedById).toBe(groupSystemAccessAttr.UpdatedById);
+      expect(groupSystemAccess.UpdatedAt).toBe(groupSystemAccessAttr.UpdatedAt);
+    });
+
+    it('should throw an error if GroupSystemAccessId is not found', async () => {
+      jest.spyOn(GroupSystemAccessRepository.prototype, 'findOne').mockResolvedValue(null);
+
+      await expect(GroupSystemAccess.init(null, 1)).rejects.toThrow(
+        new ClassError('groupSystemAccess', 'groupSystemAccessErrMsg00', 'groupSystemAccess not found'),
+      );
+    });
+  });
 });