@contrail/flexplm 1.4.0 → 1.5.0-alpha.14a4f1b

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

@@ -1,689 +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' } });
-    });
-  });
-
-  describe('getIdentityEntity', () => {
-    const config = {} as FCConfig;
-    const mapFileUtil = new MapFileUtil(new Entities());
-    const dc = new DataConverter(config, mapFileUtil);
-    let btep: TestBaseEntityProcessor;
-    let mockEntitiesGet: jest.Mock;
-
-    beforeEach(() => {
-      btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'item');
-      mockEntitiesGet = jest.fn();
-      (btep as any).entities = { get: mockEntitiesGet };
-    });
-
-    it('should throw error when poolKey is missing', async () => {
-      await expect(btep.getIdentityEntity({
-        poolKey: '',
-        propertyName: 'itemNumber',
-        propertyValue: '12345'
-      })).rejects.toThrow('poolKey, propertyName, and propertyValue must be defined');
-    });
-
-    it('should throw error when propertyName is missing', async () => {
-      await expect(btep.getIdentityEntity({
-        poolKey: 'item',
-        propertyName: '',
-        propertyValue: '12345'
-      })).rejects.toThrow('poolKey, propertyName, and propertyValue must be defined');
-    });
-
-    it('should throw error when propertyValue is missing', async () => {
-      await expect(btep.getIdentityEntity({
-        poolKey: 'item',
-        propertyName: 'itemNumber',
-        propertyValue: ''
-      })).rejects.toThrow('poolKey, propertyName, and propertyValue must be defined');
-    });
-
-    it('should return undefined when no identity entities are found (empty array)', async () => {
-      mockEntitiesGet.mockResolvedValue([]);
-
-      const result = await btep.getIdentityEntity({
-        poolKey: 'item',
-        propertyName: 'itemNumber',
-        propertyValue: '12345'
-      });
-
-      expect(result).toBeUndefined();
-      expect(mockEntitiesGet).toHaveBeenCalledWith({
-        entityName: 'identity',
-        criteria: { poolKey: 'item', propertyName: 'itemNumber', propertyValue: '12345' }
-      });
-    });
-
-    it('should return undefined when identity entities result is null', async () => {
-      mockEntitiesGet.mockResolvedValue(null);
-
-      const result = await btep.getIdentityEntity({
-        poolKey: 'item',
-        propertyName: 'itemNumber',
-        propertyValue: '12345'
-      });
-
-      expect(result).toBeUndefined();
-    });
-
-    it('should throw error when multiple identity entities are found', async () => {
-      mockEntitiesGet.mockResolvedValue([
-        { entityReference: 'item:1' },
-        { entityReference: 'item:2' }
-      ]);
-
-      await expect(btep.getIdentityEntity({
-        poolKey: 'item',
-        propertyName: 'itemNumber',
-        propertyValue: '12345'
-      })).rejects.toThrow('Multiple identity entities found for poolKey: item, itemNumber: 12345');
-    });
-
-    it('should return the identity entity when one is found (array)', async () => {
-      const identityEntity = { entityReference: 'item:1' };
-      mockEntitiesGet.mockResolvedValue([identityEntity]);
-
-      const result = await btep.getIdentityEntity({
-        poolKey: 'item',
-        propertyName: 'itemNumber',
-        propertyValue: '12345'
-      });
-
-      expect(result).toEqual(identityEntity);
-      expect(mockEntitiesGet).toHaveBeenCalledTimes(1);
-    });
-
-    it('should return the identity entity when result is a single object (not array)', async () => {
-      const identityEntity = { entityReference: 'item:5' };
-      mockEntitiesGet.mockResolvedValue(identityEntity);
-
-      const result = await btep.getIdentityEntity({
-        poolKey: 'item:material',
-        propertyName: 'materialNumber',
-        propertyValue: 'MAT-001'
-      });
-
-      expect(result).toEqual(identityEntity);
-      expect(mockEntitiesGet).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe('getEntityUsingIdentityService', () => {
-    const config = {} as FCConfig;
-    const mapFileUtil = new MapFileUtil(new Entities());
-    const dc = new DataConverter(config, mapFileUtil);
-    let btep: TestBaseEntityProcessor;
-    let mockEntitiesGet: jest.Mock;
-
-    beforeEach(() => {
-      btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'item');
-      mockEntitiesGet = jest.fn();
-      (btep as any).entities = { get: mockEntitiesGet };
-    });
-
-    it('should throw error when poolKey is missing', async () => {
-      await expect(btep.getEntityUsingIdentityService({
-        poolKey: '',
-        propertyName: 'itemNumber',
-        propertyValue: '12345'
-      })).rejects.toThrow('poolKey, propertyName, and propertyValue must be defined');
-    });
-
-    it('should throw error when propertyName is missing', async () => {
-      await expect(btep.getEntityUsingIdentityService({
-        poolKey: 'item',
-        propertyName: '',
-        propertyValue: '12345'
-      })).rejects.toThrow('poolKey, propertyName, and propertyValue must be defined');
-    });
-
-    it('should throw error when propertyValue is missing', async () => {
-      await expect(btep.getEntityUsingIdentityService({
-        poolKey: 'item',
-        propertyName: 'itemNumber',
-        propertyValue: ''
-      })).rejects.toThrow('poolKey, propertyName, and propertyValue must be defined');
-    });
-
-    it('should return undefined when no identity entities are found (empty array)', async () => {
-      mockEntitiesGet.mockResolvedValue([]);
-
-      const result = await btep.getEntityUsingIdentityService({
-        poolKey: 'item',
-        propertyName: 'itemNumber',
-        propertyValue: '12345'
-      });
-
-      expect(result).toBeUndefined();
-      expect(mockEntitiesGet).toHaveBeenCalledWith({
-        entityName: 'identity',
-        criteria: { poolKey: 'item', propertyName: 'itemNumber', propertyValue: '12345' }
-      });
-    });
-
-    it('should return undefined when identity entities result is null', async () => {
-      mockEntitiesGet.mockResolvedValue(null);
-
-      const result = await btep.getEntityUsingIdentityService({
-        poolKey: 'item',
-        propertyName: 'itemNumber',
-        propertyValue: '12345'
-      });
-
-      expect(result).toBeUndefined();
-    });
-
-    it('should throw error when multiple identity entities are found', async () => {
-      mockEntitiesGet.mockResolvedValue([
-        { entityReference: 'item:1' },
-        { entityReference: 'item:2' }
-      ]);
-
-      await expect(btep.getEntityUsingIdentityService({
-        poolKey: 'item',
-        propertyName: 'itemNumber',
-        propertyValue: '12345'
-      })).rejects.toThrow('Multiple identity entities found for poolKey: item, itemNumber: 12345');
-    });
-
-    it('should return the entity when one identity entity is found (array)', async () => {
-      const mockEntity = { id: '1', name: 'Test Item' };
-      mockEntitiesGet
-        .mockResolvedValueOnce([{ entityReference: 'item:1' }])
-        .mockResolvedValueOnce(mockEntity);
-
-      const result = await btep.getEntityUsingIdentityService({
-        poolKey: 'item',
-        propertyName: 'itemNumber',
-        propertyValue: '12345'
-      });
-
-      expect(result).toEqual(mockEntity);
-      expect(mockEntitiesGet).toHaveBeenCalledTimes(2);
-      expect(mockEntitiesGet).toHaveBeenNthCalledWith(1, {
-        entityName: 'identity',
-        criteria: { poolKey: 'item', propertyName: 'itemNumber', propertyValue: '12345' }
-      });
-      expect(mockEntitiesGet).toHaveBeenNthCalledWith(2, {
-        entityName: 'item',
-        id: '1'
-      });
-    });
-
-    it('should return the entity when identity result is a single object (not array)', async () => {
-      const mockEntity = { id: '5', name: 'Test Material' };
-      mockEntitiesGet
-        .mockResolvedValueOnce({ entityReference: 'item:5' })
-        .mockResolvedValueOnce(mockEntity);
-
-      const result = await btep.getEntityUsingIdentityService({
-        poolKey: 'item:material',
-        propertyName: 'materialNumber',
-        propertyValue: 'MAT-001'
-      });
-
-      expect(result).toEqual(mockEntity);
-      expect(mockEntitiesGet).toHaveBeenNthCalledWith(2, {
-        entityName: 'item',
-        id: '5'
-      });
-    });
-  });
-
-});