@contrail/flexplm 1.3.0 → 1.3.1-alpha.56221f6

package/publish.bat

@@ -1,5 +0,0 @@
-rd /s /q lib
-call npm install
-call npm run build
-call npm version patch
-call npm publish

package/publish.sh

@@ -1,5 +0,0 @@
-rm -rf lib;
-npm install;
-npm run build;
-npm version patch;
-npm publish;

package/src/entity-processor/base-entity-processor.spec.ts

@@ -1,460 +0,0 @@
-import { Entities, TypeClientOptions } from "@contrail/sdk";
-import { MapFileUtil } from "@contrail/transform-data";
-import { EntityPayloadType, FCConfig } from "../interfaces/interfaces";
-import { DataConverter } from "../util/data-converter";
-import { BaseEntityProcessor, IncomingEntityResponse } from "./base-entity-processor";
-import { TypeConversionUtils } from "../util/type-conversion-utils";
-import { ThumbnailUtil } from "../util/thumbnail-util";
-
-const mockRootType = {
-  typeProperties: [
-    { slug: 'rootText' }
-  ]
-};
-const mockTypeUtilGetByRootAndPath = jest.fn((options: TypeClientOptions) => {
-  return Promise.resolve(mockRootType);
-});
-
-jest.mock('@contrail/sdk', () => {
-  const origModule = jest.requireActual('@contrail/sdk');
-  return {
-    __esModule: true,
-    ...origModule,
-    Types: jest.fn().mockImplementation(() => {
-      return {
-        getByRootAndPath: mockTypeUtilGetByRootAndPath
-      };
-    })
-  };
-});
-
-class TestBaseEntityProcessor extends BaseEntityProcessor {
-  protected getIncomingEntity(event: any, inboundData: any): Promise<IncomingEntityResponse> {
-    throw new Error("Method not implemented.");
-  }
-  protected getCreateEntity(inboundData: any): Promise<IncomingEntityResponse> {
-    throw new Error("Method not implemented.");
-  }
-  protected getOutgoingUpsertPayload(entityType: any, event: any): Promise<EntityPayloadType> {
-    throw new Error("Method not implemented.");
-  }
-
-}
-describe('BaseEntityProcessor', () =>{
-  describe('getOutboundEntityUpdates', () =>{
-
-    const config = {} as FCConfig;
-    const mapFileUtil = new MapFileUtil(new Entities());
-    const dc = new DataConverter(config, mapFileUtil);
-    it('no payload', async () =>{
-      const btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'test');
-      const event = {};
-      const flexResponse = {};
-
-      const updates = await btep.getOutboundEntityUpdates(event, flexResponse);
-      expect(updates).toBeUndefined();
-    });
-
-    it('flexPayload.status === OK', async () =>{
-      const btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'test');
-      const event = {};
-      const flexResponse = {
-        data: {
-          payload: [
-            {
-              status: 'OK'
-            }
-          ]
-        }
-      };
-      const getTransformedDataSpy = jest.spyOn(btep, 'getTransformedData').mockReturnValue(Promise.resolve({}));
-      const returnValue = {
-        name: 'Test'
-      };
-      const getUpdatesForEntitySpy = jest.spyOn(btep, 'getUpdatesForEntity').mockReturnValue(Promise.resolve(returnValue));
-      const updates = await btep.getOutboundEntityUpdates(event, flexResponse);
-      expect(getTransformedDataSpy).toBeCalledTimes(1);
-      expect(getUpdatesForEntitySpy).toBeCalledTimes(1);
-      expect(updates).toBe(returnValue);
-    });
-
-    it('flexPayload.status === FAIL', async () =>{
-      const btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'test');
-      const event = {};
-      const flexResponse = {
-        data: {
-          payload: [
-            {
-              status: 'FAIL'
-            }
-          ]
-        }
-      };
-      const getTransformedDataSpy = jest.spyOn(btep, 'getTransformedData').mockReturnValue(Promise.resolve({}));
-      const returnValue = {
-        name: 'Test'
-      };
-      const getUpdatesForEntitySpy = jest.spyOn(btep, 'getUpdatesForEntity').mockReturnValue(Promise.resolve(returnValue));
-      const updates = await btep.getOutboundEntityUpdates(event, flexResponse);
-      expect(getTransformedDataSpy).toBeCalledTimes(0);
-      expect(getUpdatesForEntitySpy).toBeCalledTimes(0);
-      expect(updates).toBeUndefined();
-    });
-
-    it('should set flexPLMObjectClass when data exists but flexPLMObjectClass is missing', async () =>{
-      const btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'test');
-      const event = { newData: { id: '123' } };
-      const flexResponse = {
-        data: {
-          payload: [
-            {
-              status: 'OK',
-              objectClass: 'Material',
-              data: {
-                name: 'Test Material'
-              }
-            }
-          ]
-        }
-      };
-      const getTransformedDataSpy = jest.spyOn(btep, 'getTransformedData').mockReturnValue(Promise.resolve({}));
-      const returnValue = {
-        name: 'Test'
-      };
-      const getUpdatesForEntitySpy = jest.spyOn(btep, 'getUpdatesForEntity').mockReturnValue(Promise.resolve(returnValue));
-
-      await btep.getOutboundEntityUpdates(event, flexResponse);
-
-      expect(flexResponse.data.payload[0].data['flexPLMObjectClass']).toBe('Material');
-      expect(getTransformedDataSpy).toBeCalledTimes(1);
-      expect(getTransformedDataSpy).toBeCalledWith(flexResponse.data.payload[0]);
-      expect(getUpdatesForEntitySpy).toBeCalledTimes(1);
-    });
-
-    it('should not override existing flexPLMObjectClass', async () =>{
-      const btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'test');
-      const event = { newData: { id: '123' } };
-      const flexResponse = {
-        data: {
-          payload: [
-            {
-              status: 'OK',
-              objectClass: 'Material',
-              data: {
-                name: 'Test Material',
-                flexPLMObjectClass: 'ExistingClass'
-              }
-            }
-          ]
-        }
-      };
-      const getTransformedDataSpy = jest.spyOn(btep, 'getTransformedData').mockReturnValue(Promise.resolve({}));
-      const returnValue = {
-        name: 'Test'
-      };
-      const getUpdatesForEntitySpy = jest.spyOn(btep, 'getUpdatesForEntity').mockReturnValue(Promise.resolve(returnValue));
-
-      await btep.getOutboundEntityUpdates(event, flexResponse);
-
-      expect(flexResponse.data.payload[0].data.flexPLMObjectClass).toBe('ExistingClass');
-      expect(getTransformedDataSpy).toBeCalledTimes(1);
-      expect(getTransformedDataSpy).toBeCalledWith(flexResponse.data.payload[0]);
-      expect(getUpdatesForEntitySpy).toBeCalledTimes(1);
-    });
-
-    it('should skip setting flexPLMObjectClass when data is null or undefined', async () =>{
-      const btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'test');
-      const event = { newData: { id: '123' } };
-      const flexResponse = {
-        data: {
-          payload: [
-            {
-              status: 'OK',
-              objectClass: 'Material',
-              data: null
-            }
-          ]
-        }
-      };
-      const getTransformedDataSpy = jest.spyOn(btep, 'getTransformedData').mockReturnValue(Promise.resolve({}));
-      const returnValue = {
-        name: 'Test'
-      };
-      const getUpdatesForEntitySpy = jest.spyOn(btep, 'getUpdatesForEntity').mockReturnValue(Promise.resolve(returnValue));
-
-      await btep.getOutboundEntityUpdates(event, flexResponse);
-
-      expect(getTransformedDataSpy).toBeCalledTimes(1);
-      expect(getTransformedDataSpy).toBeCalledWith(flexResponse.data.payload[0]);
-      expect(getUpdatesForEntitySpy).toBeCalledTimes(1);
-    });
-
-  });
-
-  describe('queryEntityWithSubType', () =>{
-    const config = {} as FCConfig;
-    const mapFileUtil = new MapFileUtil(new Entities());
-    beforeEach(() =>{
-      jest.clearAllMocks();
-    });
-    it('entity parameter not set', async () =>{
-      const btep = new TestBaseEntityProcessor({} as FCConfig, {} as DataConverter, {} as MapFileUtil, 'test');
-      const entity = '';
-      const subType = 'test';
-      const propertyCriteria = {a:'val'};
-      expect(async () => {await btep.queryEntityWithSubTypeCriteria(entity, subType, propertyCriteria)}).rejects.toThrow();
-    });
-    it('entityTypePath not set', async () =>{
-      const btep = new TestBaseEntityProcessor({} as FCConfig, {} as DataConverter, {} as MapFileUtil, 'test');
-      const entity = 'test';
-      const subType = '';
-      const propertyCriteria = {};
-      expect(async () => {await btep.queryEntityWithSubTypeCriteria(entity, subType, propertyCriteria)}).rejects.toThrow();
-
-    });
-    it('propertyCriteria not set', async () =>{
-      const btep = new TestBaseEntityProcessor({} as FCConfig, {} as DataConverter, {} as MapFileUtil, 'test');
-      const entity = 'test';
-      const subType = 'test';
-      const propertyCriteria = {};
-      expect(async () => {await btep.queryEntityWithSubTypeCriteria(entity, subType, propertyCriteria)}).rejects.toThrow();
-    });
-
-    it('basic queryEntityWithSubTypeCriteria test', async () =>{
-      const dc = new DataConverter(config, mapFileUtil);
-      const btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'test');
-      const entityType = 'custom-entity';
-      const entityTypePath = 'custom-entity:sample';
-      const rootCriteria = {
-        rootText: 'root'
-      };
-      const subCriteria = {
-        sampleText: 'sample',
-        typePath: entityTypePath
-      };
-      const propertyCriteria = Object.assign({}, rootCriteria, subCriteria);
-      const rootCriteriaResults = Object.assign({}, rootCriteria);
-
-      const mockGetByRootTypeProperties = jest.spyOn(btep, 'getRootTypePropertyKeys').mockReturnValue(['rootText']);
-      const mockDCgetAllObjectReferences = jest.spyOn(dc, 'getAllObjectReferences').mockReturnValue(Promise.resolve([]));
-
-      const results = await btep.queryEntityWithSubTypeCriteria(entityType, entityTypePath, propertyCriteria);
-      expect(results).toEqual([]);
-      expect(mockTypeUtilGetByRootAndPath).toBeCalledTimes(1);
-      expect(mockTypeUtilGetByRootAndPath).toBeCalledWith({ root: entityType});
-      expect(mockGetByRootTypeProperties).toBeCalledTimes(1);
-      expect(mockGetByRootTypeProperties).toBeCalledWith(mockRootType, propertyCriteria);
-
-      expect(mockDCgetAllObjectReferences).toBeCalledTimes(1);
-      expect(mockDCgetAllObjectReferences).toBeCalledWith(entityType, rootCriteriaResults, subCriteria);
-    });
-
-  });
-
-  describe('getCriteriaForEntity', () =>{
-    const config = {} as FCConfig;
-    const mapFileUtil = new MapFileUtil(new Entities());
-    beforeEach(() =>{
-      jest.clearAllMocks();
-    });
-    it('entity parameter not set', async () =>{
-      const btep = new TestBaseEntityProcessor({} as FCConfig, {} as DataConverter, {} as MapFileUtil, 'test');
-      const entity = '';
-      const subType = 'test';
-      const propertyCriteria = {a:'val'};
-      expect(async () => {await btep.getCriteriaForEntity(entity, subType, propertyCriteria)}).rejects.toThrow();
-    });
-    it('entityTypePath not set', async () =>{
-      const btep = new TestBaseEntityProcessor({} as FCConfig, {} as DataConverter, {} as MapFileUtil, 'test');
-      const entity = 'test';
-      const subType = '';
-      const propertyCriteria = {};
-      expect(async () => {await btep.getCriteriaForEntity(entity, subType, propertyCriteria)}).rejects.toThrow();
-
-    });
-    it('propertyCriteria not set', async () =>{
-      const btep = new TestBaseEntityProcessor({} as FCConfig, {} as DataConverter, {} as MapFileUtil, 'test');
-      const entity = 'test';
-      const subType = 'test';
-      const propertyCriteria = {};
-      expect(async () => {await btep.getCriteriaForEntity(entity, subType, propertyCriteria)}).rejects.toThrow();
-    });
-
-    it('basic getCriteriaForEntity test', async () =>{
-      const dc = new DataConverter(config, mapFileUtil);
-      const btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'test');
-      const entityType = 'custom-entity';
-      const entityTypePath = 'custom-entity:sample';
-      const rootCriteria = {
-        rootText: 'root'
-      };
-      const subCriteria = {
-        sampleText: 'sample',
-        typePath: entityTypePath
-      };
-      const propertyCriteria = Object.assign({}, rootCriteria, subCriteria);
-      const rootCriteriaResults = Object.assign({}, rootCriteria);
-      const subCriteriaResults = Object.assign({}, subCriteria);
-
-      const mockGetByRootTypeProperties = jest.spyOn(btep, 'getRootTypePropertyKeys').mockReturnValue(['rootText']);
-      // const mockDCgetAllObjectReferences = jest.spyOn(dc, 'getAllObjectReferences').mockReturnValue(Promise.resolve([]));
-
-      const {rootTypeCriteria, subTypeCriteria} = await btep.getCriteriaForEntity(entityType, entityTypePath, propertyCriteria);
-      expect(mockTypeUtilGetByRootAndPath).toBeCalledTimes(1);
-      expect(mockTypeUtilGetByRootAndPath).toBeCalledWith({ root: entityType});
-      expect(mockGetByRootTypeProperties).toBeCalledTimes(1);
-      expect(mockGetByRootTypeProperties).toBeCalledWith(mockRootType, propertyCriteria);
-      expect(rootTypeCriteria).toEqual(rootCriteriaResults);
-      expect(subTypeCriteria).toEqual(subCriteriaResults);
-
-    });
-  });
-
-  describe('getRootTypePropertyKeys', () =>{
-    it('rootType parameter not set', async () =>{
-      const btep = new TestBaseEntityProcessor({} as FCConfig, {} as DataConverter, {} as MapFileUtil, 'test');
-      const rootType = '';
-      expect(async () => {await btep.getRootTypePropertyKeys(rootType)}).rejects.toThrow();
-    });
-
-    it('get keys from rootType.typeProperties', async () =>{
-      const btep = new TestBaseEntityProcessor({} as FCConfig, {} as DataConverter, {} as MapFileUtil, 'test');
-      const rootType = {
-        typeProperties: ['a', 'b']
-      };
-      const keys = await btep.getRootTypePropertyKeys(rootType);
-      expect(keys).not.toEqual(['a', 'b']);
-    });
-
-    it('get keys from rootType.typeProperties', async () =>{
-      const btep = new TestBaseEntityProcessor({} as FCConfig, {} as DataConverter, {} as MapFileUtil, 'test');
-      const rootType = {
-        typeProperties: [{ slug: 'a'},{slug: 'b'}]
-      };
-      const keys = await btep.getRootTypePropertyKeys(rootType);
-      expect(keys).toEqual(['a', 'b']);
-    });
-
-  });
-
-  describe('handleIncomingUpsert - inbound image sync', () =>{
-    const config = {} as FCConfig;
-    const mapFileUtil = new MapFileUtil(new Entities());
-    const dc = new DataConverter(config, mapFileUtil);
-    const mockEvent = { objectClass: 'TestClass', federatedId: 'fed-123', data: { name: 'test' }, entityReference: 'ref-1', eventType: 'PERSIST' } as EntityPayloadType;
-    const mockInboundData = { name: 'transformed-test' };
-    const mockCreatedEntity = { id: 'created-1', name: 'created', primaryViewableId: 'pv-created' };
-    const mockUpdatedEntity = { id: 'updated-1', name: 'updated', primaryViewableId: 'pv-updated' };
-    const mockExistingEntity = { id: 'existing-1', name: 'existing', typeId: 'type-1', roles: [] };
-
-    let btep: TestBaseEntityProcessor;
-    let syncInboundImagesSpy: jest.SpyInstance;
-    let syncThumbnailSpy: jest.SpyInstance;
-
-    beforeEach(() =>{
-      jest.clearAllMocks();
-      btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'test');
-      jest.spyOn(btep, 'getTransformedData').mockResolvedValue(mockInboundData);
-      syncInboundImagesSpy = jest.spyOn(TypeConversionUtils, 'syncInboundImages');
-      syncThumbnailSpy = jest.spyOn(ThumbnailUtil.prototype, 'syncThumbnailToVibeIQ').mockResolvedValue(undefined);
-    });
-
-    it('should call syncThumbnailToVibeIQ with entity after create when syncInboundImages returns true', async () =>{
-      jest.spyOn(btep, 'getIncomingEntity' as any).mockResolvedValue({ entity: null });
-      jest.spyOn(btep, 'getCreateEntity' as any).mockResolvedValue({ entity: { name: 'new' } });
-      jest.spyOn(btep, 'createEntity').mockResolvedValue(mockCreatedEntity);
-      syncInboundImagesSpy.mockResolvedValue(true);
-
-      const result = await btep.handleIncomingUpsert(mockEvent);
-
-      expect(syncThumbnailSpy).toBeCalledTimes(1);
-      expect(syncThumbnailSpy).toBeCalledWith({ entityId: 'created-1', primaryViewableId: 'pv-created', event: mockEvent, entityName: 'test' });
-      expect(result).toBe(mockCreatedEntity);
-    });
-
-    it('should not sync images after create when syncInboundImages returns false', async () =>{
-      jest.spyOn(btep, 'getIncomingEntity' as any).mockResolvedValue({ entity: null });
-      jest.spyOn(btep, 'getCreateEntity' as any).mockResolvedValue({ entity: { name: 'new' } });
-      jest.spyOn(btep, 'createEntity').mockResolvedValue(mockCreatedEntity);
-      syncInboundImagesSpy.mockResolvedValue(false);
-
-      const result = await btep.handleIncomingUpsert(mockEvent);
-
-      expect(syncInboundImagesSpy).toBeCalledTimes(1);
-      expect(syncThumbnailSpy).toBeCalledTimes(0);
-      expect(result).toBe(mockCreatedEntity);
-    });
-
-    it('should call syncThumbnailToVibeIQ with entity and update with property diffs on update', async () =>{
-      jest.spyOn(btep, 'getIncomingEntity' as any).mockResolvedValue({ entity: mockExistingEntity });
-      jest.spyOn(btep, 'getUpdatesForEntity').mockResolvedValue({ name: 'changed' });
-      const updateEntitySpy = jest.spyOn(btep, 'updateEntity').mockResolvedValue(mockUpdatedEntity);
-      syncInboundImagesSpy.mockResolvedValue(true);
-
-      const result = await btep.handleIncomingUpsert(mockEvent);
-
-      expect(syncThumbnailSpy).toBeCalledTimes(1);
-      expect(syncThumbnailSpy).toBeCalledWith({ entityId: 'existing-1', primaryViewableId: undefined, event: mockEvent, entityName: 'test' });
-      expect(updateEntitySpy).toBeCalledWith('test', mockExistingEntity, { name: 'changed' });
-      expect(result).toBe(mockUpdatedEntity);
-    });
-
-    it('should not sync images on update when syncInboundImages returns false', async () =>{
-      jest.spyOn(btep, 'getIncomingEntity' as any).mockResolvedValue({ entity: mockExistingEntity });
-      jest.spyOn(btep, 'getUpdatesForEntity').mockResolvedValue({ name: 'changed' });
-      jest.spyOn(btep, 'updateEntity').mockResolvedValue(mockUpdatedEntity);
-      syncInboundImagesSpy.mockResolvedValue(false);
-
-      const result = await btep.handleIncomingUpsert(mockEvent);
-
-      expect(syncInboundImagesSpy).toBeCalledTimes(1);
-      expect(syncThumbnailSpy).toBeCalledTimes(0);
-      expect(result).toBe(mockUpdatedEntity);
-    });
-
-    it('should not sync images on early return from getIncomingEntity', async () =>{
-      jest.spyOn(btep, 'getIncomingEntity' as any).mockResolvedValue({
-        earlyReturn: { status: 400, data: { message: 'error' }, shortStatusMessage: 'FAIL' }
-      });
-
-      await btep.handleIncomingUpsert(mockEvent);
-
-      expect(syncInboundImagesSpy).toBeCalledTimes(0);
-      expect(syncThumbnailSpy).toBeCalledTimes(0);
-    });
-
-    it('should not sync images on early return from getCreateEntity', async () =>{
-      jest.spyOn(btep, 'getIncomingEntity' as any).mockResolvedValue({ entity: null });
-      jest.spyOn(btep, 'getCreateEntity' as any).mockResolvedValue({
-        earlyReturn: { status: 400, data: { message: 'not creatable' }, shortStatusMessage: 'NOT_CREATABLE' }
-      });
-
-      await btep.handleIncomingUpsert(mockEvent);
-
-      expect(syncInboundImagesSpy).toBeCalledTimes(0);
-      expect(syncThumbnailSpy).toBeCalledTimes(0);
-    });
-
-    it('should return no changes when no property diffs and no thumbnail updates', async () =>{
-      jest.spyOn(btep, 'getIncomingEntity' as any).mockResolvedValue({ entity: mockExistingEntity });
-      jest.spyOn(btep, 'getUpdatesForEntity').mockResolvedValue({});
-      syncInboundImagesSpy.mockResolvedValue(true);
-      syncThumbnailSpy.mockResolvedValue(undefined);
-
-      const result = await btep.handleIncomingUpsert(mockEvent);
-
-      expect(result).toEqual({ status: 200, data: { message: 'No Changes to persist for entity: existing-1' } });
-    });
-
-    it('should return no changes when syncInboundImages is false and no property diffs', async () =>{
-      jest.spyOn(btep, 'getIncomingEntity' as any).mockResolvedValue({ entity: mockExistingEntity });
-      jest.spyOn(btep, 'getUpdatesForEntity').mockResolvedValue({});
-      syncInboundImagesSpy.mockResolvedValue(false);
-
-      const result = await btep.handleIncomingUpsert(mockEvent);
-
-      expect(result).toEqual({ status: 200, data: { message: 'No Changes to persist for entity: existing-1' } });
-    });
-  });
-
-});