@tomei/product/__tests__/product.base.spec.ts

NestJS package for product module

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

describe('ProductBase', () => {
  class TestProduct extends ProductBase {
    constructor(product?: IProductAttrBase) {
      super(product);
    }
  }

  let 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',
    UOM: 'Test',
    TotalUnits: 0,
    TotalUnitsAvailable: 0,
    TotalUnitsInCurrentOrder: 0,
    TotalUnitsSold: 0,
    TotalUnitsReserved: 0,
    TotalUnitsOnConsignment: 0,
    TotalUnitsUnderMaintenance: 0,
    TotalUnitsVoid: 0,
    TotalUnitsInTransit: 0,
    TotalUnitsBackOrdered: 0,
    TotalUnitsPreOrdered: 0,
    StockLowAlertLevel: 0,
    StockReorderLevel: 0,
    BufferStockLevel: 0,
  };
  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);

  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);

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

  describe('init', () => {
    it('should initialize the product base with existing data', async () => {
      const product = new TestProduct({
        ...data,
      });

      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('delete', () => {
    it('should delete product', async () => {
      let called = false;
      const findMock = jest
        .spyOn(ProductRepository.prototype, 'findOne')
        .mockReturnValueOnce({
          ...data,
          get: () => data,
          save: () => {
            called = true;
          },
        } as any);
      const sessionService = await SessionService.init();
      const loginUser = await LoginUser.init(sessionService);
      loginUser.ObjectId = '1234567890';
      const product = new TestProduct({
        ...data,
      });
      await product.delete(loginUser);

      expect(findMock).toBeCalledTimes(1);
      expect(called).toBeTruthy();
      expect(product['Status']).toBe('Deleted');
      expect(product['UpdatedById']).toBe('1234567890');
      expect(product['UpdatedSSYN']).toBe('N');
      expect(true).toBe(true);
    });

    it('should throw error if user dont have the privileges to delete product', async () => {
      jest
        .spyOn(LoginUser.prototype, 'checkPrivileges')
        .mockResolvedValueOnce(false);
      try {
        const product = new TestProduct({
          ...data,
        });
        const sessionService = await SessionService.init();
        const loginUser = await LoginUser.init(sessionService);
        loginUser.ObjectId = '1234567890';
        await product.delete(loginUser);
      } catch (error) {
        expect(error.message).toEqual(
          'You do not have permission to delete product.',
        );
      }
    });
  });

  describe('findOne', () => {
    it('should return product', async () => {
      const findOneMock = jest
        .spyOn(ProductRepository.prototype, 'findOne')
        .mockReturnValueOnce({
          ...data,
          get: () => data,
        } as any);

      await TestProduct['findOne']({
        where: {
          ProductId: '123',
        },
      });

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

  describe('findAllWithPagination', () => {
    it('should return products', async () => {
      const findAllWithPaginationMock = jest
        .spyOn(ProductRepository.prototype, 'findAllWithPagination')
        .mockReturnValueOnce({
          count: 1,
          rows: [
            {
              ...data,
              get: () => data,
            },
          ],
        } as any);
      const product = new TestProduct({
        ...data,
      });
      await product.findAllWithPagination({
        where: {
          ProductId: '123',
        },
      });

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

  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 = new TestProduct({
        ...data,
      });
      await product.create(loginUser);

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

    it('should throw error if SKU is already existed', async () => {
      jest.spyOn(ProductRepository.prototype, 'findOne').mockReturnValueOnce({
        ...data,
        get: () => data,
      } as any);

      const product = new TestProduct({
        ...data,
      });
      try {
        const sessionService = await SessionService.init();
        const loginUser = await LoginUser.init(sessionService);
        loginUser.ObjectId = '1234567890';
        await product.create(loginUser);
      } catch (error) {
        expect(error.message).toEqual('SKU is already existed.');
      }

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

    it('should throw error if IsPriceInclusiveTaxYN not defined if IsTaxable equal to Y', async () => {
      const temp = {
        ...data,
      };
      data.IsTaxableYN = 'Y';
      data.IsPriceInclusiveTaxYN = 'Y';

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

      jest
        .spyOn(ProductRepository.prototype, 'findOne')
        .mockReturnValueOnce(null as any);

      const product = new TestProduct({
        ...data,
      });
      try {
        const sessionService = await SessionService.init();
        const loginUser = await LoginUser.init(sessionService);
        loginUser.ObjectId = '1234567890';
        await product.create(loginUser);
      } catch (error) {
        expect(error.message).toEqual(
          'IsPriceInclusiveTaxYN is required if IsTaxableYN equal Y.',
        );
      }

      data = temp;
      expect(pRepoCreate).toBeCalledTimes(0);
    });

    it('should throw error if TaxCode not defined if IsTaxable equal to Y', async () => {
      const temp = {
        ...data,
      };
      data.IsTaxableYN = 'Y';
      data.TaxCode = null as any;

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

      jest
        .spyOn(ProductRepository.prototype, 'findOne')
        .mockReturnValueOnce(null as any);

      const product = new TestProduct({
        ...data,
      });
      try {
        const sessionService = await SessionService.init();
        const loginUser = await LoginUser.init(sessionService);
        loginUser.ObjectId = '1234567890';
        await product.create(loginUser);
      } catch (error) {
        expect(error.message).toEqual(
          'TaxCode is required if IsTaxableYN equal Y.',
        );
      }

      expect(pRepoCreate).toBeCalledTimes(0);
      data = temp;
    });

    it('should throw error if user dont have the privileges to create product', async () => {
      jest
        .spyOn(LoginUser.prototype, 'checkPrivileges')
        .mockResolvedValueOnce(false);
      jest
        .spyOn(ProductRepository.prototype, 'findOne')
        .mockReturnValueOnce(null as any);
      try {
        const product = new TestProduct({
          ...data,
        });
        const sessionService = await SessionService.init();
        const loginUser = await LoginUser.init(sessionService);
        loginUser.ObjectId = '1234567890';
        await product.create(loginUser);
      } catch (error) {
        expect(error.message).toEqual(
          'You do not have permission to add product.',
        );
      }
    });
  });

  describe('update', () => {
    it('should update product', async () => {
      // let called = false;
      // const updateMock = jest
      //   .spyOn(ProductRepository.prototype, 'findOne')
      //   .mockReturnValueOnce({
      //     ...data,
      //     get: () => data,
      //     update: () => {
      //       called = true;
      //     },
      //     save: () => {
      //       called = true;
      //     },
      //   } as any);
      // const product = new TestProduct({
      //   ...data,
      // });
      const sessionService = await SessionService.init();
      const loginUser = await LoginUser.init(sessionService);
      loginUser.ObjectId = '1234567890';
      // await product.update(loginUser, product);

      // expect(updateMock).toBeCalledTimes(1);
      // expect(called).toBeTruthy();
      expect(true).toBe(true);
    });
  });

  describe('diactivate', () => {
    it('should deactivate product', async () => {
      let called = false;
      const findMock = jest
        .spyOn(ProductRepository.prototype, 'findOne')
        .mockReturnValueOnce({
          ...data,
          get: () => data,
          save: () => {
            called = true;
          },
        } as any);
      const sessionService = await SessionService.init();
      const loginUser = await LoginUser.init(sessionService);
      loginUser.ObjectId = '1234567890';
      const product = new TestProduct({
        ...data,
      });
      await product.deactivate(loginUser);

      expect(findMock).toBeCalledTimes(1);
      expect(called).toBeTruthy();
      expect(product['Status']).toBe('Inactive');
      expect(product['UpdatedById']).toBe('1234567890');
      expect(product['UpdatedSSYN']).toBe('N');
      expect(true).toBe(true);
    });

    it('should throw error if user dont have the privileges to deactivate product', async () => {
      jest
        .spyOn(LoginUser.prototype, 'checkPrivileges')
        .mockResolvedValueOnce(false);
      try {
        const product = new TestProduct({
          ...data,
        });
        const sessionService = await SessionService.init();
        const loginUser = await LoginUser.init(sessionService);
        loginUser.ObjectId = '1234567890';
        await product.deactivate(loginUser);
      } catch (error) {
        expect(error.message).toEqual(
          'You do not have permission to deactivate product.',
        );
      }
    });
  });

  describe('discontinue', () => {
    it('should discontinue product', async () => {
      let called = false;
      const findMock = jest
        .spyOn(ProductRepository.prototype, 'findOne')
        .mockReturnValueOnce({
          ...data,
          get: () => data,
          save: () => {
            called = true;
          },
        } as any);
      const sessionService = await SessionService.init();
      const loginUser = await LoginUser.init(sessionService);
      loginUser.ObjectId = '1234567890';
      const product = new TestProduct({
        ...data,
      });
      await product.discontinue(loginUser);

      expect(findMock).toBeCalledTimes(1);
      expect(called).toBeTruthy();
      expect(product['Status']).toBe('Discontinue');
      expect(product['UpdatedById']).toBe('1234567890');
      expect(product['UpdatedSSYN']).toBe('N');
      expect(true).toBe(true);
    });

    it('should throw error if user dont have the privileges to discontinue product', async () => {
      jest
        .spyOn(LoginUser.prototype, 'checkPrivileges')
        .mockResolvedValueOnce(false);
      try {
        const product = new TestProduct({
          ...data,
        });
        const sessionService = await SessionService.init();
        const loginUser = await LoginUser.init(sessionService);
        loginUser.ObjectId = '1234567890';
        await product.discontinue(loginUser);
      } catch (error) {
        expect(error.message).toEqual(
          'You do not have permission to discontinue product.',
        );
      }
    });
  });

  describe('activate', () => {
    it('should activate product', async () => {
      let called = false;
      const findMock = jest
        .spyOn(ProductRepository.prototype, 'findOne')
        .mockReturnValueOnce({
          ...data,
          get: () => data,
          save: () => {
            called = true;
          },
        } as any);
      const sessionService = await SessionService.init();
      const loginUser = await LoginUser.init(sessionService);
      loginUser.ObjectId = '1234567890';
      const product = new TestProduct({
        ...data,
      });
      await product.activate(loginUser);

      expect(findMock).toBeCalledTimes(1);
      expect(called).toBeTruthy();
      expect(product['Status']).toBe('Active');
      expect(product['UpdatedById']).toBe('1234567890');
      expect(product['UpdatedSSYN']).toBe('N');
      expect(true).toBe(true);
    });

    it('should throw error if user dont have the privileges to activate product', async () => {
      jest
        .spyOn(LoginUser.prototype, 'checkPrivileges')
        .mockResolvedValueOnce(false);
      try {
        const product = new TestProduct({
          ...data,
        });
        const sessionService = await SessionService.init();
        const loginUser = await LoginUser.init(sessionService);
        loginUser.ObjectId = '1234567890';
        await product.activate(loginUser);
      } catch (error) {
        expect(error.message).toEqual(
          'You do not have permission to activate product.',
        );
      }
    });
  });

  describe('verify', () => {
    it('should activate product', async () => {
      let called = false;
      const findMock = jest
        .spyOn(ProductRepository.prototype, 'findOne')
        .mockReturnValueOnce({
          ...data,
          get: () => data,
          save: () => {
            called = true;
          },
        } as any);
      const sessionService = await SessionService.init();
      const loginUser = await LoginUser.init(sessionService);
      loginUser.ObjectId = '1234567890';
      const product = new TestProduct({
        ...data,
      });
      await product.verify(loginUser);

      expect(findMock).toBeCalledTimes(1);
      expect(called).toBeTruthy();
      expect(product['VerifiedYN']).toBe('Y');
      expect(product['VerifiedById']).toBe('1234567890');
      expect(true).toBe(true);
    });

    it('should throw error if user dont have the privileges to activate product', async () => {
      jest
        .spyOn(LoginUser.prototype, 'checkPrivileges')
        .mockResolvedValueOnce(false);
      try {
        const product = new TestProduct({
          ...data,
        });
        const sessionService = await SessionService.init();
        const loginUser = await LoginUser.init(sessionService);
        loginUser.ObjectId = '1234567890';
        await product.verify(loginUser);
      } catch (error) {
        expect(error.message).toEqual(
          'You do not have permission to verify product.',
        );
      }
    });
  });
});