@contrail/flexplm 1.1.65 → 1.1.66

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

@@ -1,249 +1,338 @@
-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";
-
-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();
-    });
-  });
-
-  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']);
-    });
-
-  });
-
-});
+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";
+
+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 handle 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']);
+    });
+
+  });
+
+});