@tomei/sso 0.50.4 → 0.50.5

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

@@ -1,84 +1,84 @@
-import { SystemPrivilege } from '../../../../src/components/system-privilege/system-privilege';
-import { SystemPrivilegeRepository } from '../../../../src/components/system-privilege/system-privilege.repository';
-import { ClassError } from '@tomei/general';
-
-describe('SystemPrivilege', () => {
-  let systemPrivilege: SystemPrivilege;
-  const systemPrivilegeAttr = {
-    PrivilegeCode: 'test',
-    SystemCode: 'test',
-    Name: 'test',
-    Description: 'test',
-    Status: 'test',
-    CreatedById: 1,
-    CreatedAt: new Date(),
-    UpdatedById: 1,
-    UpdatedAt: new Date(),
-  };
-
-  beforeEach(() => {
-    jest.resetAllMocks();
-  });
-
-  describe('constructor', () => {
-    it('should create a new SystemPrivilege instance', () => {
-      systemPrivilege = new (SystemPrivilege as any)(systemPrivilegeAttr);
-
-      expect(systemPrivilege).toBeDefined();
-      expect(systemPrivilege).toBeInstanceOf(SystemPrivilege);
-      expect(systemPrivilege.PrivilegeCode).toBe(systemPrivilegeAttr.PrivilegeCode);
-      expect(systemPrivilege.SystemCode).toBe(systemPrivilegeAttr.SystemCode);
-      expect(systemPrivilege.Description).toBe(systemPrivilegeAttr.Description);
-      expect(systemPrivilege.Status).toBe(systemPrivilegeAttr.Status);
-      expect(systemPrivilege.CreatedById).toBe(systemPrivilegeAttr.CreatedById);
-      expect(systemPrivilege.CreatedAt).toBe(systemPrivilegeAttr.CreatedAt);
-      expect(systemPrivilege.UpdatedById).toBe(systemPrivilegeAttr.UpdatedById);
-      expect(systemPrivilege.UpdatedAt).toBe(systemPrivilegeAttr.UpdatedAt);
-    });
-  });
-
-  describe('init', () => {
-    it('should initialize SystemPrivilege without PrivilegeCode', async () => {
-      const systemPrivilege = await SystemPrivilege.init(null);
-      expect(systemPrivilege).toBeDefined();
-      expect(systemPrivilege).toBeInstanceOf(SystemPrivilege);
-      expect(systemPrivilege.PrivilegeCode).toBeUndefined();
-      expect(systemPrivilege.SystemCode).toBeUndefined();
-      expect(systemPrivilege.Description).toBeUndefined();
-      expect(systemPrivilege.Status).toBeUndefined();
-      expect(systemPrivilege.CreatedById).toBeUndefined();
-      expect(systemPrivilege.CreatedAt).toBeUndefined();
-      expect(systemPrivilege.UpdatedById).toBeUndefined();
-      expect(systemPrivilege.UpdatedAt).toBeUndefined();
-    });
-
-    it('should initialize SystemPrivilege with PrivilegeCode', async () => {
-      const findByPkSpy = jest
-        .spyOn(SystemPrivilegeRepository.prototype, 'findByPk')
-        .mockResolvedValue(systemPrivilegeAttr as any);
-
-      const systemPrivilege = await SystemPrivilege.init(null, 'test');
-      expect(findByPkSpy).toHaveBeenCalledWith('test', {
-        transaction: null,
-      });
-      expect(systemPrivilege).toBeDefined();
-      expect(systemPrivilege).toBeInstanceOf(SystemPrivilege);
-      expect(systemPrivilege.PrivilegeCode).toBe(systemPrivilegeAttr.PrivilegeCode);
-      expect(systemPrivilege.SystemCode).toBe(systemPrivilegeAttr.SystemCode);
-      expect(systemPrivilege.Description).toBe(systemPrivilegeAttr.Description);
-      expect(systemPrivilege.Status).toBe(systemPrivilegeAttr.Status);
-      expect(systemPrivilege.CreatedById).toBe(systemPrivilegeAttr.CreatedById);
-      expect(systemPrivilege.CreatedAt).toBe(systemPrivilegeAttr.CreatedAt);
-      expect(systemPrivilege.UpdatedById).toBe(systemPrivilegeAttr.UpdatedById);
-      expect(systemPrivilege.UpdatedAt).toBe(systemPrivilegeAttr.UpdatedAt);
-    });
-
-    it('should throw an error if PrivilegeCode is not found', async () => {
-      jest.spyOn(SystemPrivilegeRepository.prototype, 'findByPk').mockResolvedValue(null);
-
-      await expect(SystemPrivilege.init(null, 'test')).rejects.toThrow(
-        new ClassError('SystemPrivilege', 'SystemPrivilegeErrMsg00', 'System Privilege Not Found'),
-      );
-    });
-  });
+import { SystemPrivilege } from '../../../../src/components/system-privilege/system-privilege';
+import { SystemPrivilegeRepository } from '../../../../src/components/system-privilege/system-privilege.repository';
+import { ClassError } from '@tomei/general';
+
+describe('SystemPrivilege', () => {
+  let systemPrivilege: SystemPrivilege;
+  const systemPrivilegeAttr = {
+    PrivilegeCode: 'test',
+    SystemCode: 'test',
+    Name: 'test',
+    Description: 'test',
+    Status: 'test',
+    CreatedById: 1,
+    CreatedAt: new Date(),
+    UpdatedById: 1,
+    UpdatedAt: new Date(),
+  };
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should create a new SystemPrivilege instance', () => {
+      systemPrivilege = new (SystemPrivilege as any)(systemPrivilegeAttr);
+
+      expect(systemPrivilege).toBeDefined();
+      expect(systemPrivilege).toBeInstanceOf(SystemPrivilege);
+      expect(systemPrivilege.PrivilegeCode).toBe(systemPrivilegeAttr.PrivilegeCode);
+      expect(systemPrivilege.SystemCode).toBe(systemPrivilegeAttr.SystemCode);
+      expect(systemPrivilege.Description).toBe(systemPrivilegeAttr.Description);
+      expect(systemPrivilege.Status).toBe(systemPrivilegeAttr.Status);
+      expect(systemPrivilege.CreatedById).toBe(systemPrivilegeAttr.CreatedById);
+      expect(systemPrivilege.CreatedAt).toBe(systemPrivilegeAttr.CreatedAt);
+      expect(systemPrivilege.UpdatedById).toBe(systemPrivilegeAttr.UpdatedById);
+      expect(systemPrivilege.UpdatedAt).toBe(systemPrivilegeAttr.UpdatedAt);
+    });
+  });
+
+  describe('init', () => {
+    it('should initialize SystemPrivilege without PrivilegeCode', async () => {
+      const systemPrivilege = await SystemPrivilege.init(null);
+      expect(systemPrivilege).toBeDefined();
+      expect(systemPrivilege).toBeInstanceOf(SystemPrivilege);
+      expect(systemPrivilege.PrivilegeCode).toBeUndefined();
+      expect(systemPrivilege.SystemCode).toBeUndefined();
+      expect(systemPrivilege.Description).toBeUndefined();
+      expect(systemPrivilege.Status).toBeUndefined();
+      expect(systemPrivilege.CreatedById).toBeUndefined();
+      expect(systemPrivilege.CreatedAt).toBeUndefined();
+      expect(systemPrivilege.UpdatedById).toBeUndefined();
+      expect(systemPrivilege.UpdatedAt).toBeUndefined();
+    });
+
+    it('should initialize SystemPrivilege with PrivilegeCode', async () => {
+      const findByPkSpy = jest
+        .spyOn(SystemPrivilegeRepository.prototype, 'findByPk')
+        .mockResolvedValue(systemPrivilegeAttr as any);
+
+      const systemPrivilege = await SystemPrivilege.init(null, 'test');
+      expect(findByPkSpy).toHaveBeenCalledWith('test', {
+        transaction: null,
+      });
+      expect(systemPrivilege).toBeDefined();
+      expect(systemPrivilege).toBeInstanceOf(SystemPrivilege);
+      expect(systemPrivilege.PrivilegeCode).toBe(systemPrivilegeAttr.PrivilegeCode);
+      expect(systemPrivilege.SystemCode).toBe(systemPrivilegeAttr.SystemCode);
+      expect(systemPrivilege.Description).toBe(systemPrivilegeAttr.Description);
+      expect(systemPrivilege.Status).toBe(systemPrivilegeAttr.Status);
+      expect(systemPrivilege.CreatedById).toBe(systemPrivilegeAttr.CreatedById);
+      expect(systemPrivilege.CreatedAt).toBe(systemPrivilegeAttr.CreatedAt);
+      expect(systemPrivilege.UpdatedById).toBe(systemPrivilegeAttr.UpdatedById);
+      expect(systemPrivilege.UpdatedAt).toBe(systemPrivilegeAttr.UpdatedAt);
+    });
+
+    it('should throw an error if PrivilegeCode is not found', async () => {
+      jest.spyOn(SystemPrivilegeRepository.prototype, 'findByPk').mockResolvedValue(null);
+
+      await expect(SystemPrivilege.init(null, 'test')).rejects.toThrow(
+        new ClassError('SystemPrivilege', 'SystemPrivilegeErrMsg00', 'System Privilege Not Found'),
+      );
+    });
+  });
 });

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

@@ -1,87 +1,87 @@
-import { UserGroup } from '../../../../src/components/user-group/user-group';
-import { UserGroupRepository } from '../../../../src/components/user-group/user-group.repository';
-import { ClassError } from '@tomei/general';
-
-describe('UserGroup', () => {
-  let userGroup: UserGroup;
-  const userGroupAttr = {
-    UserGroupId: 1,
-    UserId: 1,
-    GroupCode: 'group1',
-    Status: 'active',
-    InheritGroupPrivilegeYN: 'yes',
-    InheritGroupSystemAccessYN: 'yes',
-    CreatedById: 1,
-    CreatedAt: new Date(),
-    UpdatedById: 1,
-    UpdatedAt: new Date(),
-  };
-
-  beforeEach(() => {
-    userGroup = new (UserGroup as any)(userGroupAttr);
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('constructor', () => {
-    it('should create a new UserGroup instance', () => {
-      expect(userGroup).toBeDefined();
-      expect(userGroup).toBeInstanceOf(UserGroup);
-      expect(userGroup.UserGroupId).toBe(userGroupAttr.UserGroupId);
-      expect(userGroup.UserId).toBe(userGroupAttr.UserId);
-      expect(userGroup.GroupCode).toBe(userGroupAttr.GroupCode);
-      expect(userGroup.Status).toBe(userGroupAttr.Status);
-      expect(userGroup.InheritGroupPrivilegeYN).toBe(
-        userGroupAttr.InheritGroupPrivilegeYN
-      );
-      expect(userGroup.InheritGroupSystemAccessYN).toBe(
-        userGroupAttr.InheritGroupSystemAccessYN
-      );
-      expect(userGroup.CreatedById).toBe(userGroupAttr.CreatedById);
-      expect(userGroup.CreatedAt).toBe(userGroupAttr.CreatedAt);
-      expect(userGroup.UpdatedById).toBe(userGroupAttr.UpdatedById);
-      expect(userGroup.UpdatedAt).toBe(userGroupAttr.UpdatedAt);
-    });
-  });
-
-  describe('init', () => {
-    it('should initialize UserGroup with valid UserGroupId', async () => {
-      const findOneMock = jest
-        .spyOn(UserGroupRepository.prototype, 'findOne')
-        .mockResolvedValueOnce(userGroupAttr as any);
-
-      const result = await UserGroup.init(null, 1);
-
-      expect(findOneMock).toHaveBeenCalledTimes(1);
-      expect(findOneMock).toHaveBeenCalledWith({
-        where: { UserGroupId: 1 },
-        transaction: null,
-      });
-      expect(result).toBeInstanceOf(UserGroup);
-      expect(result.UserGroupId).toBe(userGroupAttr.UserGroupId);
-      expect(result.UserId).toBe(userGroupAttr.UserId);
-      expect(result.GroupCode).toBe(userGroupAttr.GroupCode);
-      expect(result.Status).toBe(userGroupAttr.Status);
-      expect(result.InheritGroupPrivilegeYN).toBe(
-        userGroupAttr.InheritGroupPrivilegeYN
-      );
-      expect(result.InheritGroupSystemAccessYN).toBe(
-        userGroupAttr.InheritGroupSystemAccessYN
-      );
-      expect(result.CreatedById).toBe(userGroupAttr.CreatedById);
-      expect(result.CreatedAt).toBe(userGroupAttr.CreatedAt);
-      expect(result.UpdatedById).toBe(userGroupAttr.UpdatedById);
-      expect(result.UpdatedAt).toBe(userGroupAttr.UpdatedAt);
-    });
-
-    it('should throw ClassError when UserGroupId is not found', async () => {
-      jest
-        .spyOn(UserGroupRepository.prototype, 'findOne')
-        .mockResolvedValueOnce(null);
-
-      await expect(UserGroup.init(null, 1)).rejects.toThrow(ClassError);
-    });
-  });
+import { UserGroup } from '../../../../src/components/user-group/user-group';
+import { UserGroupRepository } from '../../../../src/components/user-group/user-group.repository';
+import { ClassError } from '@tomei/general';
+
+describe('UserGroup', () => {
+  let userGroup: UserGroup;
+  const userGroupAttr = {
+    UserGroupId: 1,
+    UserId: 1,
+    GroupCode: 'group1',
+    Status: 'active',
+    InheritGroupPrivilegeYN: 'yes',
+    InheritGroupSystemAccessYN: 'yes',
+    CreatedById: 1,
+    CreatedAt: new Date(),
+    UpdatedById: 1,
+    UpdatedAt: new Date(),
+  };
+
+  beforeEach(() => {
+    userGroup = new (UserGroup as any)(userGroupAttr);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should create a new UserGroup instance', () => {
+      expect(userGroup).toBeDefined();
+      expect(userGroup).toBeInstanceOf(UserGroup);
+      expect(userGroup.UserGroupId).toBe(userGroupAttr.UserGroupId);
+      expect(userGroup.UserId).toBe(userGroupAttr.UserId);
+      expect(userGroup.GroupCode).toBe(userGroupAttr.GroupCode);
+      expect(userGroup.Status).toBe(userGroupAttr.Status);
+      expect(userGroup.InheritGroupPrivilegeYN).toBe(
+        userGroupAttr.InheritGroupPrivilegeYN
+      );
+      expect(userGroup.InheritGroupSystemAccessYN).toBe(
+        userGroupAttr.InheritGroupSystemAccessYN
+      );
+      expect(userGroup.CreatedById).toBe(userGroupAttr.CreatedById);
+      expect(userGroup.CreatedAt).toBe(userGroupAttr.CreatedAt);
+      expect(userGroup.UpdatedById).toBe(userGroupAttr.UpdatedById);
+      expect(userGroup.UpdatedAt).toBe(userGroupAttr.UpdatedAt);
+    });
+  });
+
+  describe('init', () => {
+    it('should initialize UserGroup with valid UserGroupId', async () => {
+      const findOneMock = jest
+        .spyOn(UserGroupRepository.prototype, 'findOne')
+        .mockResolvedValueOnce(userGroupAttr as any);
+
+      const result = await UserGroup.init(null, 1);
+
+      expect(findOneMock).toHaveBeenCalledTimes(1);
+      expect(findOneMock).toHaveBeenCalledWith({
+        where: { UserGroupId: 1 },
+        transaction: null,
+      });
+      expect(result).toBeInstanceOf(UserGroup);
+      expect(result.UserGroupId).toBe(userGroupAttr.UserGroupId);
+      expect(result.UserId).toBe(userGroupAttr.UserId);
+      expect(result.GroupCode).toBe(userGroupAttr.GroupCode);
+      expect(result.Status).toBe(userGroupAttr.Status);
+      expect(result.InheritGroupPrivilegeYN).toBe(
+        userGroupAttr.InheritGroupPrivilegeYN
+      );
+      expect(result.InheritGroupSystemAccessYN).toBe(
+        userGroupAttr.InheritGroupSystemAccessYN
+      );
+      expect(result.CreatedById).toBe(userGroupAttr.CreatedById);
+      expect(result.CreatedAt).toBe(userGroupAttr.CreatedAt);
+      expect(result.UpdatedById).toBe(userGroupAttr.UpdatedById);
+      expect(result.UpdatedAt).toBe(userGroupAttr.UpdatedAt);
+    });
+
+    it('should throw ClassError when UserGroupId is not found', async () => {
+      jest
+        .spyOn(UserGroupRepository.prototype, 'findOne')
+        .mockResolvedValueOnce(null);
+
+      await expect(UserGroup.init(null, 1)).rejects.toThrow(ClassError);
+    });
+  });
 });

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

@@ -1,79 +1,79 @@
-import { UserObjectPrivilege } from '../../../../src/components/user-object-privilege/user-object-privilege';
-import { UserObjectPrivilegeRepository } from '../../../../src/components/user-object-privilege/user-object-privilege.repository';
-import { ClassError } from '@tomei/general';
-
-describe('UserObjectPrivilege', () => {
-  let userObjectPrivilege: UserObjectPrivilege;
-  const userObjectPrivilegeAttr = {
-    ObjectPrivilegeId: 1,
-    UserId: 1,
-    SystemPrivilegeId: 'code1',
-    ObjectId: 'object1',
-    ObjectType: 'type1',
-    CreatedAt: new Date(),
-    UpdatedAt: new Date(),
-    CreatedById: 1,
-    UpdatedById: 1,
-  };
-
-  beforeEach(() => {
-    userObjectPrivilege = new (UserObjectPrivilege as any)(userObjectPrivilegeAttr);
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('constructor', () => {
-    it('should create a new UserObjectPrivilege instance', () => {
-      expect(userObjectPrivilege).toBeDefined();
-      expect(userObjectPrivilege).toBeInstanceOf(UserObjectPrivilege);
-      expect(userObjectPrivilege.ObjectPrivilegeId).toBe(userObjectPrivilegeAttr.ObjectPrivilegeId);
-      expect(userObjectPrivilege.UserId).toBe(userObjectPrivilegeAttr.UserId);
-      expect(userObjectPrivilege.SystemPrivilegeId).toBe(userObjectPrivilegeAttr.SystemPrivilegeId);
-      expect(userObjectPrivilege.ObjectId).toBe(userObjectPrivilegeAttr.ObjectId);
-      expect(userObjectPrivilege.ObjectType).toBe(userObjectPrivilegeAttr.ObjectType);
-      expect(userObjectPrivilege.CreatedAt).toBe(userObjectPrivilegeAttr.CreatedAt);
-      expect(userObjectPrivilege.UpdatedAt).toBe(userObjectPrivilegeAttr.UpdatedAt);
-      expect(userObjectPrivilege.CreatedById).toBe(userObjectPrivilegeAttr.CreatedById);
-      expect(userObjectPrivilege.UpdatedById).toBe(userObjectPrivilegeAttr.UpdatedById);
-    });
-  });
-
-  describe('init', () => {
-    it('should initialize UserObjectPrivilege with valid ObjectPrivilegeId', async () => {
-      const findOneMock = jest
-        .spyOn(UserObjectPrivilegeRepository.prototype, 'findOne')
-        .mockResolvedValueOnce({
-          ...userObjectPrivilegeAttr,
-          get: () => userObjectPrivilegeAttr,
-        } as any);
-
-      const result = await UserObjectPrivilege.init(null, 1);
-
-      expect(findOneMock).toHaveBeenCalledTimes(1);
-      expect(findOneMock).toHaveBeenCalledWith({
-        where: { ObjectPrivilegeId: 1 },
-        transaction: null,
-      });
-      expect(result).toBeInstanceOf(UserObjectPrivilege);
-      expect(result.ObjectPrivilegeId).toBe(userObjectPrivilegeAttr.ObjectPrivilegeId);
-      expect(result.UserId).toBe(userObjectPrivilegeAttr.UserId);
-      expect(result.SystemPrivilegeId).toBe(userObjectPrivilegeAttr.SystemPrivilegeId);
-      expect(result.ObjectId).toBe(userObjectPrivilegeAttr.ObjectId);
-      expect(result.ObjectType).toBe(userObjectPrivilegeAttr.ObjectType);
-      expect(result.CreatedAt).toBe(userObjectPrivilegeAttr.CreatedAt);
-      expect(result.UpdatedAt).toBe(userObjectPrivilegeAttr.UpdatedAt);
-      expect(result.CreatedById).toBe(userObjectPrivilegeAttr.CreatedById);
-      expect(result.UpdatedById).toBe(userObjectPrivilegeAttr.UpdatedById);
-    });
-
-    it('should throw ClassError when ObjectPrivilegeId is not found', async () => {
-      jest
-        .spyOn(UserObjectPrivilegeRepository.prototype, 'findOne')
-        .mockResolvedValueOnce(null);
-
-      await expect(UserObjectPrivilege.init(null, 1)).rejects.toThrow(ClassError);
-    });
-  });
+import { UserObjectPrivilege } from '../../../../src/components/user-object-privilege/user-object-privilege';
+import { UserObjectPrivilegeRepository } from '../../../../src/components/user-object-privilege/user-object-privilege.repository';
+import { ClassError } from '@tomei/general';
+
+describe('UserObjectPrivilege', () => {
+  let userObjectPrivilege: UserObjectPrivilege;
+  const userObjectPrivilegeAttr = {
+    ObjectPrivilegeId: 1,
+    UserId: 1,
+    SystemPrivilegeId: 'code1',
+    ObjectId: 'object1',
+    ObjectType: 'type1',
+    CreatedAt: new Date(),
+    UpdatedAt: new Date(),
+    CreatedById: 1,
+    UpdatedById: 1,
+  };
+
+  beforeEach(() => {
+    userObjectPrivilege = new (UserObjectPrivilege as any)(userObjectPrivilegeAttr);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should create a new UserObjectPrivilege instance', () => {
+      expect(userObjectPrivilege).toBeDefined();
+      expect(userObjectPrivilege).toBeInstanceOf(UserObjectPrivilege);
+      expect(userObjectPrivilege.ObjectPrivilegeId).toBe(userObjectPrivilegeAttr.ObjectPrivilegeId);
+      expect(userObjectPrivilege.UserId).toBe(userObjectPrivilegeAttr.UserId);
+      expect(userObjectPrivilege.SystemPrivilegeId).toBe(userObjectPrivilegeAttr.SystemPrivilegeId);
+      expect(userObjectPrivilege.ObjectId).toBe(userObjectPrivilegeAttr.ObjectId);
+      expect(userObjectPrivilege.ObjectType).toBe(userObjectPrivilegeAttr.ObjectType);
+      expect(userObjectPrivilege.CreatedAt).toBe(userObjectPrivilegeAttr.CreatedAt);
+      expect(userObjectPrivilege.UpdatedAt).toBe(userObjectPrivilegeAttr.UpdatedAt);
+      expect(userObjectPrivilege.CreatedById).toBe(userObjectPrivilegeAttr.CreatedById);
+      expect(userObjectPrivilege.UpdatedById).toBe(userObjectPrivilegeAttr.UpdatedById);
+    });
+  });
+
+  describe('init', () => {
+    it('should initialize UserObjectPrivilege with valid ObjectPrivilegeId', async () => {
+      const findOneMock = jest
+        .spyOn(UserObjectPrivilegeRepository.prototype, 'findOne')
+        .mockResolvedValueOnce({
+          ...userObjectPrivilegeAttr,
+          get: () => userObjectPrivilegeAttr,
+        } as any);
+
+      const result = await UserObjectPrivilege.init(null, 1);
+
+      expect(findOneMock).toHaveBeenCalledTimes(1);
+      expect(findOneMock).toHaveBeenCalledWith({
+        where: { ObjectPrivilegeId: 1 },
+        transaction: null,
+      });
+      expect(result).toBeInstanceOf(UserObjectPrivilege);
+      expect(result.ObjectPrivilegeId).toBe(userObjectPrivilegeAttr.ObjectPrivilegeId);
+      expect(result.UserId).toBe(userObjectPrivilegeAttr.UserId);
+      expect(result.SystemPrivilegeId).toBe(userObjectPrivilegeAttr.SystemPrivilegeId);
+      expect(result.ObjectId).toBe(userObjectPrivilegeAttr.ObjectId);
+      expect(result.ObjectType).toBe(userObjectPrivilegeAttr.ObjectType);
+      expect(result.CreatedAt).toBe(userObjectPrivilegeAttr.CreatedAt);
+      expect(result.UpdatedAt).toBe(userObjectPrivilegeAttr.UpdatedAt);
+      expect(result.CreatedById).toBe(userObjectPrivilegeAttr.CreatedById);
+      expect(result.UpdatedById).toBe(userObjectPrivilegeAttr.UpdatedById);
+    });
+
+    it('should throw ClassError when ObjectPrivilegeId is not found', async () => {
+      jest
+        .spyOn(UserObjectPrivilegeRepository.prototype, 'findOne')
+        .mockResolvedValueOnce(null);
+
+      await expect(UserObjectPrivilege.init(null, 1)).rejects.toThrow(ClassError);
+    });
+  });
 });

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

@@ -1,73 +1,73 @@
-import { UserPrivilege } from '../../../../src/components/user-privilege/user-privilege';
-import { UserPrivilegeRepository } from '../../../../src/components/user-privilege/user-privilege.repository';
-import { ClassError } from '@tomei/general';
-
-describe('UserPrivilege', () => {
-  let userPrivilege: UserPrivilege;
-  const userPrivilegeAttr = {
-    UserPrivilegeId: 1,
-    UserId: 1,
-    SystemPrivilegeId: 'privilege1',
-    Status: 'active',
-    CreatedById: 1,
-    CreatedAt: new Date(),
-    UpdatedById: 1,
-    UpdatedAt: new Date(),
-  };
-
-  beforeEach(() => {
-    userPrivilege = new (UserPrivilege as any)(userPrivilegeAttr);
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('constructor', () => {
-    it('should create a new UserPrivilege instance', () => {
-      expect(userPrivilege).toBeDefined();
-      expect(userPrivilege).toBeInstanceOf(UserPrivilege);
-      expect(userPrivilege.UserPrivilegeId).toBe(userPrivilegeAttr.UserPrivilegeId);
-      expect(userPrivilege.UserId).toBe(userPrivilegeAttr.UserId);
-      expect(userPrivilege.SystemPrivilegeId).toBe(userPrivilegeAttr.SystemPrivilegeId);
-      expect(userPrivilege.Status).toBe(userPrivilegeAttr.Status);
-      expect(userPrivilege.CreatedById).toBe(userPrivilegeAttr.CreatedById);
-      expect(userPrivilege.CreatedAt).toBe(userPrivilegeAttr.CreatedAt);
-      expect(userPrivilege.UpdatedById).toBe(userPrivilegeAttr.UpdatedById);
-      expect(userPrivilege.UpdatedAt).toBe(userPrivilegeAttr.UpdatedAt);
-    });
-  });
-
-  describe('init', () => {
-    it('should initialize UserPrivilege with valid UserPrivilegeId', async () => {
-      const findOneMock = jest
-        .spyOn(UserPrivilegeRepository.prototype, 'findOne')
-        .mockResolvedValueOnce(userPrivilegeAttr as any);
-
-      const result = await UserPrivilege.init(null, 1);
-
-      expect(findOneMock).toHaveBeenCalledTimes(1);
-      expect(findOneMock).toHaveBeenCalledWith({
-        where: { UserPrivilegeId: 1 },
-        transaction: null,
-      });
-      expect(result).toBeInstanceOf(UserPrivilege);
-      expect(result.UserPrivilegeId).toBe(userPrivilegeAttr.UserPrivilegeId);
-      expect(result.UserId).toBe(userPrivilegeAttr.UserId);
-      expect(result.SystemPrivilegeId).toBe(userPrivilegeAttr.SystemPrivilegeId);
-      expect(result.Status).toBe(userPrivilegeAttr.Status);
-      expect(result.CreatedById).toBe(userPrivilegeAttr.CreatedById);
-      expect(result.CreatedAt).toBe(userPrivilegeAttr.CreatedAt);
-      expect(result.UpdatedById).toBe(userPrivilegeAttr.UpdatedById);
-      expect(result.UpdatedAt).toBe(userPrivilegeAttr.UpdatedAt);
-    });
-
-    it('should throw ClassError when UserPrivilegeId is not found', async () => {
-      jest
-        .spyOn(UserPrivilegeRepository.prototype, 'findOne')
-        .mockResolvedValueOnce(null);
-
-      await expect(UserPrivilege.init(null, 1)).rejects.toThrow(ClassError);
-    });
-  });
+import { UserPrivilege } from '../../../../src/components/user-privilege/user-privilege';
+import { UserPrivilegeRepository } from '../../../../src/components/user-privilege/user-privilege.repository';
+import { ClassError } from '@tomei/general';
+
+describe('UserPrivilege', () => {
+  let userPrivilege: UserPrivilege;
+  const userPrivilegeAttr = {
+    UserPrivilegeId: 1,
+    UserId: 1,
+    SystemPrivilegeId: 'privilege1',
+    Status: 'active',
+    CreatedById: 1,
+    CreatedAt: new Date(),
+    UpdatedById: 1,
+    UpdatedAt: new Date(),
+  };
+
+  beforeEach(() => {
+    userPrivilege = new (UserPrivilege as any)(userPrivilegeAttr);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should create a new UserPrivilege instance', () => {
+      expect(userPrivilege).toBeDefined();
+      expect(userPrivilege).toBeInstanceOf(UserPrivilege);
+      expect(userPrivilege.UserPrivilegeId).toBe(userPrivilegeAttr.UserPrivilegeId);
+      expect(userPrivilege.UserId).toBe(userPrivilegeAttr.UserId);
+      expect(userPrivilege.SystemPrivilegeId).toBe(userPrivilegeAttr.SystemPrivilegeId);
+      expect(userPrivilege.Status).toBe(userPrivilegeAttr.Status);
+      expect(userPrivilege.CreatedById).toBe(userPrivilegeAttr.CreatedById);
+      expect(userPrivilege.CreatedAt).toBe(userPrivilegeAttr.CreatedAt);
+      expect(userPrivilege.UpdatedById).toBe(userPrivilegeAttr.UpdatedById);
+      expect(userPrivilege.UpdatedAt).toBe(userPrivilegeAttr.UpdatedAt);
+    });
+  });
+
+  describe('init', () => {
+    it('should initialize UserPrivilege with valid UserPrivilegeId', async () => {
+      const findOneMock = jest
+        .spyOn(UserPrivilegeRepository.prototype, 'findOne')
+        .mockResolvedValueOnce(userPrivilegeAttr as any);
+
+      const result = await UserPrivilege.init(null, 1);
+
+      expect(findOneMock).toHaveBeenCalledTimes(1);
+      expect(findOneMock).toHaveBeenCalledWith({
+        where: { UserPrivilegeId: 1 },
+        transaction: null,
+      });
+      expect(result).toBeInstanceOf(UserPrivilege);
+      expect(result.UserPrivilegeId).toBe(userPrivilegeAttr.UserPrivilegeId);
+      expect(result.UserId).toBe(userPrivilegeAttr.UserId);
+      expect(result.SystemPrivilegeId).toBe(userPrivilegeAttr.SystemPrivilegeId);
+      expect(result.Status).toBe(userPrivilegeAttr.Status);
+      expect(result.CreatedById).toBe(userPrivilegeAttr.CreatedById);
+      expect(result.CreatedAt).toBe(userPrivilegeAttr.CreatedAt);
+      expect(result.UpdatedById).toBe(userPrivilegeAttr.UpdatedById);
+      expect(result.UpdatedAt).toBe(userPrivilegeAttr.UpdatedAt);
+    });
+
+    it('should throw ClassError when UserPrivilegeId is not found', async () => {
+      jest
+        .spyOn(UserPrivilegeRepository.prototype, 'findOne')
+        .mockResolvedValueOnce(null);
+
+      await expect(UserPrivilege.init(null, 1)).rejects.toThrow(ClassError);
+    });
+  });
 });