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

Tomei SSO Package

import { GroupPrivilege } from '../../../../src/components/group-privilege/group-privilege';
import { GroupPrivilegeRepository } from '../../../../src/components/group-privilege/group-privilege.repository';
import { ClassError } from '@tomei/general';

describe('GroupPrivilege', () => {
  afterEach(() => {
    jest.restoreAllMocks();
  });

  it('should initialize with GroupPrivilegeAttr', async () => {
    const mockGroupPrivilegeAttr = {
      GroupPrivilegeId: 1,
      GroupCode: 'group1',
      SystemPrivilegeId: 'privilege1',
      Status: 'active',
      CreatedAt: new Date(),
      UpdatedAt: new Date(),
      CreatedById: 1,
      UpdatedById: 1,
    };

    const findOneMock = jest
      .spyOn(GroupPrivilegeRepository.prototype, 'findOne')
      .mockResolvedValueOnce({ get: jest.fn().mockReturnValue(mockGroupPrivilegeAttr) } as any);

    const groupPrivilege = await GroupPrivilege.init(null, 1);

    expect(findOneMock).toBeCalledWith({
      where: { GroupPrivilegeId: 1 },
      transaction: null,
    });
    expect(groupPrivilege).toBeInstanceOf(GroupPrivilege);
    expect(groupPrivilege.GroupPrivilegeId).toEqual(mockGroupPrivilegeAttr.GroupPrivilegeId);
    expect(groupPrivilege.GroupCode).toEqual(mockGroupPrivilegeAttr.GroupCode);
    expect(groupPrivilege.SystemPrivilegeId).toEqual(mockGroupPrivilegeAttr.SystemPrivilegeId);
    expect(groupPrivilege.Status).toEqual(mockGroupPrivilegeAttr.Status);
    expect(groupPrivilege.CreatedAt).toEqual(mockGroupPrivilegeAttr.CreatedAt);
    expect(groupPrivilege.UpdatedAt).toEqual(mockGroupPrivilegeAttr.UpdatedAt);
    expect(groupPrivilege.CreatedById).toEqual(mockGroupPrivilegeAttr.CreatedById);
    expect(groupPrivilege.UpdatedById).toEqual(mockGroupPrivilegeAttr.UpdatedById);
  });

  it('should throw ClassError when GroupPrivilegeAttr is not found', async () => {
    const findOneMock = jest
      .spyOn(GroupPrivilegeRepository.prototype, 'findOne')
      .mockResolvedValueOnce(null);

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

    expect(findOneMock).toBeCalledWith({
      where: { GroupPrivilegeId: 1 },
      transaction: null,
    });
  });

  it('should initialize with default values', async () => {
    const groupPrivilege = await GroupPrivilege.init();

    expect(groupPrivilege).toBeInstanceOf(GroupPrivilege);
    expect(groupPrivilege.GroupPrivilegeId).toBeUndefined();
    expect(groupPrivilege.GroupCode).toBeUndefined();
    expect(groupPrivilege.SystemPrivilegeId).toBeUndefined();
    expect(groupPrivilege.Status).toBeUndefined();
    expect(groupPrivilege.CreatedAt).toBeUndefined();
    expect(groupPrivilege.UpdatedAt).toBeUndefined();
    expect(groupPrivilege.CreatedById).toBeUndefined();
    expect(groupPrivilege.UpdatedById).toBeUndefined();
  });
});