@tomei/sso 0.51.0 → 0.51.2

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

@@ -1,85 +1,85 @@
-"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 system_privilege_1 = require("../../../../src/components/system-privilege/system-privilege");
-const system_privilege_repository_1 = require("../../../../src/components/system-privilege/system-privilege.repository");
-const general_1 = require("@tomei/general");
-describe('SystemPrivilege', () => {
-    let 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 system_privilege_1.SystemPrivilege(systemPrivilegeAttr);
-            expect(systemPrivilege).toBeDefined();
-            expect(systemPrivilege).toBeInstanceOf(system_privilege_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
-            const systemPrivilege = yield system_privilege_1.SystemPrivilege.init(null);
-            expect(systemPrivilege).toBeDefined();
-            expect(systemPrivilege).toBeInstanceOf(system_privilege_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
-            const findByPkSpy = jest
-                .spyOn(system_privilege_repository_1.SystemPrivilegeRepository.prototype, 'findByPk')
-                .mockResolvedValue(systemPrivilegeAttr);
-            const systemPrivilege = yield system_privilege_1.SystemPrivilege.init(null, 'test');
-            expect(findByPkSpy).toHaveBeenCalledWith('test', {
-                transaction: null,
-            });
-            expect(systemPrivilege).toBeDefined();
-            expect(systemPrivilege).toBeInstanceOf(system_privilege_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
-            jest.spyOn(system_privilege_repository_1.SystemPrivilegeRepository.prototype, 'findByPk').mockResolvedValue(null);
-            yield expect(system_privilege_1.SystemPrivilege.init(null, 'test')).rejects.toThrow(new general_1.ClassError('SystemPrivilege', 'SystemPrivilegeErrMsg00', 'System Privilege Not Found'));
-        }));
-    });
-});
+"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 system_privilege_1 = require("../../../../src/components/system-privilege/system-privilege");
+const system_privilege_repository_1 = require("../../../../src/components/system-privilege/system-privilege.repository");
+const general_1 = require("@tomei/general");
+describe('SystemPrivilege', () => {
+    let 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 system_privilege_1.SystemPrivilege(systemPrivilegeAttr);
+            expect(systemPrivilege).toBeDefined();
+            expect(systemPrivilege).toBeInstanceOf(system_privilege_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+            const systemPrivilege = yield system_privilege_1.SystemPrivilege.init(null);
+            expect(systemPrivilege).toBeDefined();
+            expect(systemPrivilege).toBeInstanceOf(system_privilege_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+            const findByPkSpy = jest
+                .spyOn(system_privilege_repository_1.SystemPrivilegeRepository.prototype, 'findByPk')
+                .mockResolvedValue(systemPrivilegeAttr);
+            const systemPrivilege = yield system_privilege_1.SystemPrivilege.init(null, 'test');
+            expect(findByPkSpy).toHaveBeenCalledWith('test', {
+                transaction: null,
+            });
+            expect(systemPrivilege).toBeDefined();
+            expect(systemPrivilege).toBeInstanceOf(system_privilege_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(system_privilege_repository_1.SystemPrivilegeRepository.prototype, 'findByPk').mockResolvedValue(null);
+            yield expect(system_privilege_1.SystemPrivilege.init(null, 'test')).rejects.toThrow(new general_1.ClassError('SystemPrivilege', 'SystemPrivilegeErrMsg00', 'System Privilege Not Found'));
+        }));
+    });
+});
 //# sourceMappingURL=system-privilege.spec.js.map

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

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

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

@@ -1,82 +1,82 @@
-"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 user_group_1 = require("../../../../src/components/user-group/user-group");
-const user_group_repository_1 = require("../../../../src/components/user-group/user-group.repository");
-const general_1 = require("@tomei/general");
-describe('UserGroup', () => {
-    let 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 user_group_1.UserGroup(userGroupAttr);
-    });
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('constructor', () => {
-        it('should create a new UserGroup instance', () => {
-            expect(userGroup).toBeDefined();
-            expect(userGroup).toBeInstanceOf(user_group_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
-            const findOneMock = jest
-                .spyOn(user_group_repository_1.UserGroupRepository.prototype, 'findOne')
-                .mockResolvedValueOnce(userGroupAttr);
-            const result = yield user_group_1.UserGroup.init(null, 1);
-            expect(findOneMock).toHaveBeenCalledTimes(1);
-            expect(findOneMock).toHaveBeenCalledWith({
-                where: { UserGroupId: 1 },
-                transaction: null,
-            });
-            expect(result).toBeInstanceOf(user_group_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
-            jest
-                .spyOn(user_group_repository_1.UserGroupRepository.prototype, 'findOne')
-                .mockResolvedValueOnce(null);
-            yield expect(user_group_1.UserGroup.init(null, 1)).rejects.toThrow(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 user_group_1 = require("../../../../src/components/user-group/user-group");
+const user_group_repository_1 = require("../../../../src/components/user-group/user-group.repository");
+const general_1 = require("@tomei/general");
+describe('UserGroup', () => {
+    let 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 user_group_1.UserGroup(userGroupAttr);
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('constructor', () => {
+        it('should create a new UserGroup instance', () => {
+            expect(userGroup).toBeDefined();
+            expect(userGroup).toBeInstanceOf(user_group_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+            const findOneMock = jest
+                .spyOn(user_group_repository_1.UserGroupRepository.prototype, 'findOne')
+                .mockResolvedValueOnce(userGroupAttr);
+            const result = yield user_group_1.UserGroup.init(null, 1);
+            expect(findOneMock).toHaveBeenCalledTimes(1);
+            expect(findOneMock).toHaveBeenCalledWith({
+                where: { UserGroupId: 1 },
+                transaction: null,
+            });
+            expect(result).toBeInstanceOf(user_group_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest
+                .spyOn(user_group_repository_1.UserGroupRepository.prototype, 'findOne')
+                .mockResolvedValueOnce(null);
+            yield expect(user_group_1.UserGroup.init(null, 1)).rejects.toThrow(general_1.ClassError);
+        }));
+    });
+});
 //# sourceMappingURL=user-group.spec.js.map

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

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

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

@@ -1,79 +1,79 @@
-"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 user_object_privilege_1 = require("../../../../src/components/user-object-privilege/user-object-privilege");
-const user_object_privilege_repository_1 = require("../../../../src/components/user-object-privilege/user-object-privilege.repository");
-const general_1 = require("@tomei/general");
-describe('UserObjectPrivilege', () => {
-    let 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 user_object_privilege_1.UserObjectPrivilege(userObjectPrivilegeAttr);
-    });
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('constructor', () => {
-        it('should create a new UserObjectPrivilege instance', () => {
-            expect(userObjectPrivilege).toBeDefined();
-            expect(userObjectPrivilege).toBeInstanceOf(user_object_privilege_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
-            const findOneMock = jest
-                .spyOn(user_object_privilege_repository_1.UserObjectPrivilegeRepository.prototype, 'findOne')
-                .mockResolvedValueOnce(Object.assign(Object.assign({}, userObjectPrivilegeAttr), { get: () => userObjectPrivilegeAttr }));
-            const result = yield user_object_privilege_1.UserObjectPrivilege.init(null, 1);
-            expect(findOneMock).toHaveBeenCalledTimes(1);
-            expect(findOneMock).toHaveBeenCalledWith({
-                where: { ObjectPrivilegeId: 1 },
-                transaction: null,
-            });
-            expect(result).toBeInstanceOf(user_object_privilege_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
-            jest
-                .spyOn(user_object_privilege_repository_1.UserObjectPrivilegeRepository.prototype, 'findOne')
-                .mockResolvedValueOnce(null);
-            yield expect(user_object_privilege_1.UserObjectPrivilege.init(null, 1)).rejects.toThrow(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 user_object_privilege_1 = require("../../../../src/components/user-object-privilege/user-object-privilege");
+const user_object_privilege_repository_1 = require("../../../../src/components/user-object-privilege/user-object-privilege.repository");
+const general_1 = require("@tomei/general");
+describe('UserObjectPrivilege', () => {
+    let 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 user_object_privilege_1.UserObjectPrivilege(userObjectPrivilegeAttr);
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('constructor', () => {
+        it('should create a new UserObjectPrivilege instance', () => {
+            expect(userObjectPrivilege).toBeDefined();
+            expect(userObjectPrivilege).toBeInstanceOf(user_object_privilege_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+            const findOneMock = jest
+                .spyOn(user_object_privilege_repository_1.UserObjectPrivilegeRepository.prototype, 'findOne')
+                .mockResolvedValueOnce(Object.assign(Object.assign({}, userObjectPrivilegeAttr), { get: () => userObjectPrivilegeAttr }));
+            const result = yield user_object_privilege_1.UserObjectPrivilege.init(null, 1);
+            expect(findOneMock).toHaveBeenCalledTimes(1);
+            expect(findOneMock).toHaveBeenCalledWith({
+                where: { ObjectPrivilegeId: 1 },
+                transaction: null,
+            });
+            expect(result).toBeInstanceOf(user_object_privilege_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest
+                .spyOn(user_object_privilege_repository_1.UserObjectPrivilegeRepository.prototype, 'findOne')
+                .mockResolvedValueOnce(null);
+            yield expect(user_object_privilege_1.UserObjectPrivilege.init(null, 1)).rejects.toThrow(general_1.ClassError);
+        }));
+    });
+});
 //# sourceMappingURL=user-object-privilege.spec.js.map

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

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