@tomei/sso 0.51.0 → 0.51.1

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 {};

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

@@ -1,76 +1,76 @@
-"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_privilege_1 = require("../../../../src/components/user-privilege/user-privilege");
-const user_privilege_repository_1 = require("../../../../src/components/user-privilege/user-privilege.repository");
-const general_1 = require("@tomei/general");
-describe('UserPrivilege', () => {
-    let userPrivilege;
-    const userPrivilegeAttr = {
-        UserPrivilegeId: 1,
-        UserId: 1,
-        SystemPrivilegeId: 'privilege1',
-        Status: 'active',
-        CreatedById: 1,
-        CreatedAt: new Date(),
-        UpdatedById: 1,
-        UpdatedAt: new Date(),
-    };
-    beforeEach(() => {
-        userPrivilege = new user_privilege_1.UserPrivilege(userPrivilegeAttr);
-    });
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('constructor', () => {
-        it('should create a new UserPrivilege instance', () => {
-            expect(userPrivilege).toBeDefined();
-            expect(userPrivilege).toBeInstanceOf(user_privilege_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
-            const findOneMock = jest
-                .spyOn(user_privilege_repository_1.UserPrivilegeRepository.prototype, 'findOne')
-                .mockResolvedValueOnce(userPrivilegeAttr);
-            const result = yield user_privilege_1.UserPrivilege.init(null, 1);
-            expect(findOneMock).toHaveBeenCalledTimes(1);
-            expect(findOneMock).toHaveBeenCalledWith({
-                where: { UserPrivilegeId: 1 },
-                transaction: null,
-            });
-            expect(result).toBeInstanceOf(user_privilege_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
-            jest
-                .spyOn(user_privilege_repository_1.UserPrivilegeRepository.prototype, 'findOne')
-                .mockResolvedValueOnce(null);
-            yield expect(user_privilege_1.UserPrivilege.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_privilege_1 = require("../../../../src/components/user-privilege/user-privilege");
+const user_privilege_repository_1 = require("../../../../src/components/user-privilege/user-privilege.repository");
+const general_1 = require("@tomei/general");
+describe('UserPrivilege', () => {
+    let userPrivilege;
+    const userPrivilegeAttr = {
+        UserPrivilegeId: 1,
+        UserId: 1,
+        SystemPrivilegeId: 'privilege1',
+        Status: 'active',
+        CreatedById: 1,
+        CreatedAt: new Date(),
+        UpdatedById: 1,
+        UpdatedAt: new Date(),
+    };
+    beforeEach(() => {
+        userPrivilege = new user_privilege_1.UserPrivilege(userPrivilegeAttr);
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('constructor', () => {
+        it('should create a new UserPrivilege instance', () => {
+            expect(userPrivilege).toBeDefined();
+            expect(userPrivilege).toBeInstanceOf(user_privilege_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+            const findOneMock = jest
+                .spyOn(user_privilege_repository_1.UserPrivilegeRepository.prototype, 'findOne')
+                .mockResolvedValueOnce(userPrivilegeAttr);
+            const result = yield user_privilege_1.UserPrivilege.init(null, 1);
+            expect(findOneMock).toHaveBeenCalledTimes(1);
+            expect(findOneMock).toHaveBeenCalledWith({
+                where: { UserPrivilegeId: 1 },
+                transaction: null,
+            });
+            expect(result).toBeInstanceOf(user_privilege_1.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', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest
+                .spyOn(user_privilege_repository_1.UserPrivilegeRepository.prototype, 'findOne')
+                .mockResolvedValueOnce(null);
+            yield expect(user_privilege_1.UserPrivilege.init(null, 1)).rejects.toThrow(general_1.ClassError);
+        }));
+    });
+});
 //# sourceMappingURL=user-privilege.spec.js.map

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

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