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

Tomei SSO Package

import { UserObjectPrivilege } from '../../../../src/components/user-object-privilege/user-object-privilege';
import { UserObjectPrivilegeRepository } from '../../../../src/components/user-object-privilege/user-object-privilege.repository';
import { ClassError } from '@tomei/general';

describe('UserObjectPrivilege', () => {
  let userObjectPrivilege: 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 (UserObjectPrivilege as any)(userObjectPrivilegeAttr);
  });

  afterEach(() => {
    jest.clearAllMocks();
  });

  describe('constructor', () => {
    it('should create a new UserObjectPrivilege instance', () => {
      expect(userObjectPrivilege).toBeDefined();
      expect(userObjectPrivilege).toBeInstanceOf(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', async () => {
      const findOneMock = jest
        .spyOn(UserObjectPrivilegeRepository.prototype, 'findOne')
        .mockResolvedValueOnce({
          ...userObjectPrivilegeAttr,
          get: () => userObjectPrivilegeAttr,
        } as any);

      const result = await UserObjectPrivilege.init(null, 1);

      expect(findOneMock).toHaveBeenCalledTimes(1);
      expect(findOneMock).toHaveBeenCalledWith({
        where: { ObjectPrivilegeId: 1 },
        transaction: null,
      });
      expect(result).toBeInstanceOf(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', async () => {
      jest
        .spyOn(UserObjectPrivilegeRepository.prototype, 'findOne')
        .mockResolvedValueOnce(null);

      await expect(UserObjectPrivilege.init(null, 1)).rejects.toThrow(ClassError);
    });
  });
});