@tomei/product/__tests__/gemlab-product.spec.ts

NestJS package for product module

import { ProductRepository } from '../src/base/product/product.repository';
import {
  describe,
  expect,
  it,
  beforeAll,
  jest,
} from '@jest/globals';
import { GemLabProduct } from '../src/components/gemlab-product/gemlab-product';
import { SessionService, LoginUser } from '@tomei/sso';
import { ApplicationConfig } from '@tomei/config';
import { Activity } from '@tomei/activity-history';

describe('GemlabProduct', () => {
  const data = {
    ProductId: '123',
    Name: 'Test',
    Description: 'Test',
    SKU: 'Test',
    Type: 'Test',
    Remark: 'Test',
    IsTaxableYN: 'N',
    TaxCode: 'Test',
    IsPriceInclusiveTaxYN: 'N',
    Status: 'Active',
    VerifiedYN: 'Y',
    VerifiedById: '123',
    VerifiedAt: new Date(),
    VariantLevels: 0,
    VariantTypeLevel1: '',
    VariantTypeLevel2: '',
    VariantTypeLevel3: '',
    CreatedById: '123',
    CreatedAt: new Date(),
    UpdatedById: '123',
    UpdatedAt: new Date(),
    UpdatedSSYN: 'Y',
  };
  beforeAll(() => {});

  const pRepoCreate = jest
    .spyOn(ProductRepository.prototype, 'create')
    .mockResolvedValue({
      ...data,
      get: () => data,
    } as any);

  jest.spyOn(ProductRepository.prototype, 'findByPk').mockResolvedValue({
    ...data,
    get: () => data,
  } as any);

  const GemLabMock = GemLabProduct as jest.Mocked<typeof GemLabProduct>;
  GemLabMock['_GemLabProductRepository'] = {
    findOne: () => {
      return {
        ...data,
        get: () => data,
      } as any;
    },
  };

  jest.spyOn(SessionService, 'init').mockResolvedValue({
    setUserSession: jest.fn(),
    retrieveUserSession: jest.fn(),
    refreshDuration: jest.fn(),
  } as any);

  jest.spyOn(ApplicationConfig, 'getComponentConfigValue').mockResolvedValue("ezc" as any);
  jest.spyOn(LoginUser.prototype, 'checkPrivileges').mockResolvedValue(true as any);
  jest.spyOn(Activity.prototype, 'create').mockResolvedValue(undefined as any);

  describe('init', () => {
    it('should initialize the product base with existing data', async () => {
      jest.spyOn(ProductRepository.prototype, 'findOne').mockReturnValueOnce({
        ...data,
        get: () => data,
      } as any);
      const product = await GemLabMock.init('123');

      expect(product).toBeInstanceOf(GemLabProduct);
      expect(product.ProductId).toBe('123');
      expect(product.Name).toBe('Test');
      expect(product.Description).toBe('Test');
      expect(product.SKU).toBe('Test');
      expect(product.Type).toBe('Test');
      expect(product.Remark).toBe('Test');
      expect(product.IsTaxableYN).toBe('N');
      expect(product.TaxCode).toBe('Test');
      expect(product.IsPriceInclusiveTaxYN).toBe('N');
      expect(product.Status).toBe('Active');
      expect(product.VerifiedYN).toBe('Y');
      expect(product.VerifiedById).toBe('123');
      expect(product.VerifiedAt).toBeInstanceOf(Date);
      expect(product.VariantLevels).toBe(0);
      expect(product.VariantTypeLevel1).toBe('');
      expect(product.VariantTypeLevel2).toBe('');
      expect(product.VariantTypeLevel3).toBe('');
      expect(product.CreatedById).toBe('123');
      expect(product.CreatedAt).toBeInstanceOf(Date);
      expect(product.UpdatedById).toBe('123');
      expect(product.UpdatedAt).toBeInstanceOf(Date);
      expect(product.UpdatedSSYN).toBe('Y');
    });
  });

  describe('create', () => {
    it('should create a new product', async () => {
      jest
        .spyOn(ProductRepository.prototype, 'findOne')
        .mockReturnValueOnce(null as any);
      const sessionService = await SessionService.init();
      const loginUser = await LoginUser.init(sessionService);
      loginUser.ObjectId = '1234567890';
      const product = await GemLabMock.init();
      await product.create(loginUser);

      expect(pRepoCreate).toBeCalledTimes(1);
    });
  });
});