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

Tomei SSO Package

import { GroupObjectPrivilegeRepository } from '../../../../src/components/group-object-privilege/group-object-privilege.repository';
import { GroupObjectPrivilege } from '../../../../src/components/group-object-privilege/group-object-privilege';

describe('GroupObjectPrivilege', () => {
  let groupObjectPrivilege: GroupObjectPrivilege;

  beforeEach(() => {
    groupObjectPrivilege = new GroupObjectPrivilege();
  });

  it('should create an instance of GroupObjectPrivilege', () => {
    expect(groupObjectPrivilege).toBeInstanceOf(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', async () => {
      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(GroupObjectPrivilegeRepository.prototype, 'findOne').mockResolvedValueOnce({
        get: () => mockGroupObjectPrivilegeAttr,
      } as any);

      const result = await GroupObjectPrivilege.init(null, GroupObjectPrivilegeId);

      expect(result).toBeInstanceOf(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', async () => {
      const GroupObjectPrivilegeId = 1;
      jest.spyOn(GroupObjectPrivilegeRepository.prototype, 'findOne').mockResolvedValueOnce(null);

      await expect(GroupObjectPrivilege.init(null, GroupObjectPrivilegeId)).rejects.toThrowError(
        'GroupObjectPrivilege not found',
      );
    });

    it('should return a new instance of GroupObjectPrivilege when GroupObjectPrivilegeId is not provided', async () => {
      const result = await GroupObjectPrivilege.init();

      expect(result).toBeInstanceOf(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();
    });
  });
});