@tomei/sso/dist/__tests__/unit/components/group-object-privilege/group-object-privilege.spec.js

Tomei SSO Package

"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