@tomei/sso 0.51.0 → 0.51.1

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

@@ -1 +1 @@
-export {};
+export {};

package/dist/__tests__/unit/components/group/group.spec.js

@@ -1,72 +1,72 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const group_1 = require("../../../../src/components/group/group");
-const group_repository_1 = require("../../../../src/components/group/group.repository");
-const general_1 = require("@tomei/general");
-const group_type_enum_1 = require("../../../../src/enum/group-type.enum");
-describe('Group', () => {
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-    it('should initialize a group with valid GroupCode', () => __awaiter(void 0, void 0, void 0, function* () {
-        const groupAttr = {
-            GroupCode: 'group1',
-            Name: 'Group 1',
-            Description: 'This is Group 1',
-            Type: group_type_enum_1.GroupTypeEnum.ROLE,
-            ParentGroupCode: 'parentGroup1',
-            InheritParentPrivilegeYN: 'Y',
-            InheritParentSystemAccessYN: 'N',
-            Status: 'Active',
-            CreatedById: 1,
-            CreatedAt: new Date(),
-            UpdatedById: 2,
-            UpdatedAt: new Date(),
-        };
-        const groupRepositoryMock = jest.spyOn(group_repository_1.GroupRepository.prototype, 'findByPk').mockResolvedValueOnce(Object.assign(Object.assign({}, groupAttr), { get: () => groupAttr }));
-        const result = yield group_1.Group.init(null, 'group1');
-        expect(result).toBeInstanceOf(group_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
-        const groupRepositoryMock = jest.spyOn(group_repository_1.GroupRepository.prototype, 'findByPk').mockResolvedValueOnce(null);
-        yield expect(group_1.Group.init(null, 'invalidGroupCode')).rejects.toThrow(new general_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
-        const groupRepositoryMock = jest.spyOn(group_repository_1.GroupRepository.prototype, 'findByPk').mockRejectedValueOnce(new Error('Database error'));
-        yield expect(group_1.Group.init(null, 'group1')).rejects.toThrow(new general_1.ClassError('Group', 'GroupErrMsg01', 'Failed To Initialize Group'));
-        expect(groupRepositoryMock).toHaveBeenCalledTimes(1);
-        expect(groupRepositoryMock).toHaveBeenCalledWith('group1', {
-            transaction: null,
-        });
-    }));
-});
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const group_1 = require("../../../../src/components/group/group");
+const group_repository_1 = require("../../../../src/components/group/group.repository");
+const general_1 = require("@tomei/general");
+const group_type_enum_1 = require("../../../../src/enum/group-type.enum");
+describe('Group', () => {
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should initialize a group with valid GroupCode', () => __awaiter(void 0, void 0, void 0, function* () {
+        const groupAttr = {
+            GroupCode: 'group1',
+            Name: 'Group 1',
+            Description: 'This is Group 1',
+            Type: group_type_enum_1.GroupTypeEnum.ROLE,
+            ParentGroupCode: 'parentGroup1',
+            InheritParentPrivilegeYN: 'Y',
+            InheritParentSystemAccessYN: 'N',
+            Status: 'Active',
+            CreatedById: 1,
+            CreatedAt: new Date(),
+            UpdatedById: 2,
+            UpdatedAt: new Date(),
+        };
+        const groupRepositoryMock = jest.spyOn(group_repository_1.GroupRepository.prototype, 'findByPk').mockResolvedValueOnce(Object.assign(Object.assign({}, groupAttr), { get: () => groupAttr }));
+        const result = yield group_1.Group.init(null, 'group1');
+        expect(result).toBeInstanceOf(group_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+        const groupRepositoryMock = jest.spyOn(group_repository_1.GroupRepository.prototype, 'findByPk').mockResolvedValueOnce(null);
+        yield expect(group_1.Group.init(null, 'invalidGroupCode')).rejects.toThrow(new general_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+        const groupRepositoryMock = jest.spyOn(group_repository_1.GroupRepository.prototype, 'findByPk').mockRejectedValueOnce(new Error('Database error'));
+        yield expect(group_1.Group.init(null, 'group1')).rejects.toThrow(new general_1.ClassError('Group', 'GroupErrMsg01', 'Failed To Initialize Group'));
+        expect(groupRepositoryMock).toHaveBeenCalledTimes(1);
+        expect(groupRepositoryMock).toHaveBeenCalledWith('group1', {
+            transaction: null,
+        });
+    }));
+});
 //# sourceMappingURL=group.spec.js.map

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

@@ -1 +1 @@
-export {};
+export {};

package/dist/__tests__/unit/components/group-object-privilege/group-object-privilege.spec.js

@@ -1,86 +1,86 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const group_object_privilege_repository_1 = require("../../../../src/components/group-object-privilege/group-object-privilege.repository");
-const group_object_privilege_1 = require("../../../../src/components/group-object-privilege/group-object-privilege");
-describe('GroupObjectPrivilege', () => {
-    let groupObjectPrivilege;
-    beforeEach(() => {
-        groupObjectPrivilege = new group_object_privilege_1.GroupObjectPrivilege();
-    });
-    it('should create an instance of GroupObjectPrivilege', () => {
-        expect(groupObjectPrivilege).toBeInstanceOf(group_object_privilege_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
-            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(group_object_privilege_repository_1.GroupObjectPrivilegeRepository.prototype, 'findOne').mockResolvedValueOnce({
-                get: () => mockGroupObjectPrivilegeAttr,
-            });
-            const result = yield group_object_privilege_1.GroupObjectPrivilege.init(null, GroupObjectPrivilegeId);
-            expect(result).toBeInstanceOf(group_object_privilege_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
-            const GroupObjectPrivilegeId = 1;
-            jest.spyOn(group_object_privilege_repository_1.GroupObjectPrivilegeRepository.prototype, 'findOne').mockResolvedValueOnce(null);
-            yield expect(group_object_privilege_1.GroupObjectPrivilege.init(null, GroupObjectPrivilegeId)).rejects.toThrowError('GroupObjectPrivilege not found');
-        }));
-        it('should return a new instance of GroupObjectPrivilege when GroupObjectPrivilegeId is not provided', () => __awaiter(void 0, void 0, void 0, function* () {
-            const result = yield group_object_privilege_1.GroupObjectPrivilege.init();
-            expect(result).toBeInstanceOf(group_object_privilege_1.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();
-        }));
-    });
-});
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const group_object_privilege_repository_1 = require("../../../../src/components/group-object-privilege/group-object-privilege.repository");
+const group_object_privilege_1 = require("../../../../src/components/group-object-privilege/group-object-privilege");
+describe('GroupObjectPrivilege', () => {
+    let groupObjectPrivilege;
+    beforeEach(() => {
+        groupObjectPrivilege = new group_object_privilege_1.GroupObjectPrivilege();
+    });
+    it('should create an instance of GroupObjectPrivilege', () => {
+        expect(groupObjectPrivilege).toBeInstanceOf(group_object_privilege_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+            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(group_object_privilege_repository_1.GroupObjectPrivilegeRepository.prototype, 'findOne').mockResolvedValueOnce({
+                get: () => mockGroupObjectPrivilegeAttr,
+            });
+            const result = yield group_object_privilege_1.GroupObjectPrivilege.init(null, GroupObjectPrivilegeId);
+            expect(result).toBeInstanceOf(group_object_privilege_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+            const GroupObjectPrivilegeId = 1;
+            jest.spyOn(group_object_privilege_repository_1.GroupObjectPrivilegeRepository.prototype, 'findOne').mockResolvedValueOnce(null);
+            yield expect(group_object_privilege_1.GroupObjectPrivilege.init(null, GroupObjectPrivilegeId)).rejects.toThrowError('GroupObjectPrivilege not found');
+        }));
+        it('should return a new instance of GroupObjectPrivilege when GroupObjectPrivilegeId is not provided', () => __awaiter(void 0, void 0, void 0, function* () {
+            const result = yield group_object_privilege_1.GroupObjectPrivilege.init();
+            expect(result).toBeInstanceOf(group_object_privilege_1.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();
+        }));
+    });
+});
 //# sourceMappingURL=group-object-privilege.spec.js.map

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

@@ -1 +1 @@
-export {};
+export {};

package/dist/__tests__/unit/components/group-privilege/group-privilege.spec.js

@@ -1,71 +1,71 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const group_privilege_1 = require("../../../../src/components/group-privilege/group-privilege");
-const group_privilege_repository_1 = require("../../../../src/components/group-privilege/group-privilege.repository");
-const general_1 = require("@tomei/general");
-describe('GroupPrivilege', () => {
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-    it('should initialize with GroupPrivilegeAttr', () => __awaiter(void 0, void 0, void 0, function* () {
-        const mockGroupPrivilegeAttr = {
-            GroupPrivilegeId: 1,
-            GroupCode: 'group1',
-            SystemPrivilegeId: 'privilege1',
-            Status: 'active',
-            CreatedAt: new Date(),
-            UpdatedAt: new Date(),
-            CreatedById: 1,
-            UpdatedById: 1,
-        };
-        const findOneMock = jest
-            .spyOn(group_privilege_repository_1.GroupPrivilegeRepository.prototype, 'findOne')
-            .mockResolvedValueOnce({ get: jest.fn().mockReturnValue(mockGroupPrivilegeAttr) });
-        const groupPrivilege = yield group_privilege_1.GroupPrivilege.init(null, 1);
-        expect(findOneMock).toBeCalledWith({
-            where: { GroupPrivilegeId: 1 },
-            transaction: null,
-        });
-        expect(groupPrivilege).toBeInstanceOf(group_privilege_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
-        const findOneMock = jest
-            .spyOn(group_privilege_repository_1.GroupPrivilegeRepository.prototype, 'findOne')
-            .mockResolvedValueOnce(null);
-        yield expect(group_privilege_1.GroupPrivilege.init(null, 1)).rejects.toThrow(general_1.ClassError);
-        expect(findOneMock).toBeCalledWith({
-            where: { GroupPrivilegeId: 1 },
-            transaction: null,
-        });
-    }));
-    it('should initialize with default values', () => __awaiter(void 0, void 0, void 0, function* () {
-        const groupPrivilege = yield group_privilege_1.GroupPrivilege.init();
-        expect(groupPrivilege).toBeInstanceOf(group_privilege_1.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();
-    }));
-});
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const group_privilege_1 = require("../../../../src/components/group-privilege/group-privilege");
+const group_privilege_repository_1 = require("../../../../src/components/group-privilege/group-privilege.repository");
+const general_1 = require("@tomei/general");
+describe('GroupPrivilege', () => {
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    it('should initialize with GroupPrivilegeAttr', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockGroupPrivilegeAttr = {
+            GroupPrivilegeId: 1,
+            GroupCode: 'group1',
+            SystemPrivilegeId: 'privilege1',
+            Status: 'active',
+            CreatedAt: new Date(),
+            UpdatedAt: new Date(),
+            CreatedById: 1,
+            UpdatedById: 1,
+        };
+        const findOneMock = jest
+            .spyOn(group_privilege_repository_1.GroupPrivilegeRepository.prototype, 'findOne')
+            .mockResolvedValueOnce({ get: jest.fn().mockReturnValue(mockGroupPrivilegeAttr) });
+        const groupPrivilege = yield group_privilege_1.GroupPrivilege.init(null, 1);
+        expect(findOneMock).toBeCalledWith({
+            where: { GroupPrivilegeId: 1 },
+            transaction: null,
+        });
+        expect(groupPrivilege).toBeInstanceOf(group_privilege_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+        const findOneMock = jest
+            .spyOn(group_privilege_repository_1.GroupPrivilegeRepository.prototype, 'findOne')
+            .mockResolvedValueOnce(null);
+        yield expect(group_privilege_1.GroupPrivilege.init(null, 1)).rejects.toThrow(general_1.ClassError);
+        expect(findOneMock).toBeCalledWith({
+            where: { GroupPrivilegeId: 1 },
+            transaction: null,
+        });
+    }));
+    it('should initialize with default values', () => __awaiter(void 0, void 0, void 0, function* () {
+        const groupPrivilege = yield group_privilege_1.GroupPrivilege.init();
+        expect(groupPrivilege).toBeInstanceOf(group_privilege_1.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();
+    }));
+});
 //# sourceMappingURL=group-privilege.spec.js.map

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

@@ -1 +1 @@
-export {};
+export {};

package/dist/__tests__/unit/components/group-reporting-user/group-reporting-user.spec.js

@@ -1,58 +1,58 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const group_reporting_user_1 = require("../../../../src/components/group-reporting-user/group-reporting-user");
-const group_reporting_user_repository_1 = require("../../../../src/components/group-reporting-user/group-reporting-user.repository");
-const general_1 = require("@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(() => __awaiter(void 0, void 0, void 0, function* () {
-        jest.clearAllMocks();
-    }));
-    describe('init', () => {
-        const mockDbTransaction = {};
-        it('should initialize GroupReportingUser without GroupReportingUserId', () => __awaiter(void 0, void 0, void 0, function* () {
-            const initGroupReportingUser = yield group_reporting_user_1.GroupReportingUser.init(mockDbTransaction);
-            expect(initGroupReportingUser).toBeDefined();
-            expect(initGroupReportingUser).toBeInstanceOf(group_reporting_user_1.GroupReportingUser);
-        }));
-        it('should initialize GroupReportingUser with valid GroupReportingUserId', () => __awaiter(void 0, void 0, void 0, function* () {
-            const mockFindByPk = jest
-                .spyOn(group_reporting_user_repository_1.GroupReportingUserRepository.prototype, 'findByPk')
-                .mockResolvedValue(Object.assign(Object.assign({}, mockGroupReportingUserAttr), { get: () => mockGroupReportingUserAttr }));
-            const initGroupReportingUser = yield group_reporting_user_1.GroupReportingUser.init(mockDbTransaction, '1');
-            expect(initGroupReportingUser).toBeDefined();
-            expect(initGroupReportingUser).toBeInstanceOf(group_reporting_user_1.GroupReportingUser);
-            expect(mockFindByPk).toHaveBeenCalledWith('1', {
-                transaction: mockDbTransaction,
-            });
-        }));
-        it('should throw ClassError when GroupReportingUser is not found', () => __awaiter(void 0, void 0, void 0, function* () {
-            jest.spyOn(group_reporting_user_repository_1.GroupReportingUserRepository.prototype, 'findByPk').mockResolvedValue(null);
-            yield expect(group_reporting_user_1.GroupReportingUser.init(mockDbTransaction, '1')).rejects.toThrowError(general_1.ClassError);
-        }));
-        it('should throw ClassError when failed to initialize GroupReportingUser', () => __awaiter(void 0, void 0, void 0, function* () {
-            jest.spyOn(group_reporting_user_repository_1.GroupReportingUserRepository.prototype, 'findByPk').mockRejectedValue(new Error());
-            yield expect(group_reporting_user_1.GroupReportingUser.init(mockDbTransaction, '1')).rejects.toThrowError(general_1.ClassError);
-        }));
-    });
-});
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const group_reporting_user_1 = require("../../../../src/components/group-reporting-user/group-reporting-user");
+const group_reporting_user_repository_1 = require("../../../../src/components/group-reporting-user/group-reporting-user.repository");
+const general_1 = require("@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(() => __awaiter(void 0, void 0, void 0, function* () {
+        jest.clearAllMocks();
+    }));
+    describe('init', () => {
+        const mockDbTransaction = {};
+        it('should initialize GroupReportingUser without GroupReportingUserId', () => __awaiter(void 0, void 0, void 0, function* () {
+            const initGroupReportingUser = yield group_reporting_user_1.GroupReportingUser.init(mockDbTransaction);
+            expect(initGroupReportingUser).toBeDefined();
+            expect(initGroupReportingUser).toBeInstanceOf(group_reporting_user_1.GroupReportingUser);
+        }));
+        it('should initialize GroupReportingUser with valid GroupReportingUserId', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockFindByPk = jest
+                .spyOn(group_reporting_user_repository_1.GroupReportingUserRepository.prototype, 'findByPk')
+                .mockResolvedValue(Object.assign(Object.assign({}, mockGroupReportingUserAttr), { get: () => mockGroupReportingUserAttr }));
+            const initGroupReportingUser = yield group_reporting_user_1.GroupReportingUser.init(mockDbTransaction, '1');
+            expect(initGroupReportingUser).toBeDefined();
+            expect(initGroupReportingUser).toBeInstanceOf(group_reporting_user_1.GroupReportingUser);
+            expect(mockFindByPk).toHaveBeenCalledWith('1', {
+                transaction: mockDbTransaction,
+            });
+        }));
+        it('should throw ClassError when GroupReportingUser is not found', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(group_reporting_user_repository_1.GroupReportingUserRepository.prototype, 'findByPk').mockResolvedValue(null);
+            yield expect(group_reporting_user_1.GroupReportingUser.init(mockDbTransaction, '1')).rejects.toThrowError(general_1.ClassError);
+        }));
+        it('should throw ClassError when failed to initialize GroupReportingUser', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(group_reporting_user_repository_1.GroupReportingUserRepository.prototype, 'findByPk').mockRejectedValue(new Error());
+            yield expect(group_reporting_user_1.GroupReportingUser.init(mockDbTransaction, '1')).rejects.toThrowError(general_1.ClassError);
+        }));
+    });
+});
 //# sourceMappingURL=group-reporting-user.spec.js.map

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

@@ -1 +1 @@
-export {};
+export {};