@contrail/flexplm 1.2.1 → 1.3.0-alpha.04c91a9

package/lib/entity-processor/base-entity-processor.spec.js

@@ -1,302 +1,397 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const sdk_1 = require("@contrail/sdk");
-const transform_data_1 = require("@contrail/transform-data");
-const data_converter_1 = require("../util/data-converter");
-const base_entity_processor_1 = require("./base-entity-processor");
-const mockRootType = {
-    typeProperties: [
-        { slug: 'rootText' }
-    ]
-};
-const mockTypeUtilGetByRootAndPath = jest.fn((options) => {
-    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 base_entity_processor_1.BaseEntityProcessor {
-    getIncomingEntity(event, inboundData) {
-        throw new Error("Method not implemented.");
-    }
-    getCreateEntity(inboundData) {
-        throw new Error("Method not implemented.");
-    }
-    getOutgoingUpsertPayload(entityType, event) {
-        throw new Error("Method not implemented.");
-    }
-}
-describe('BaseEntityProcessor', () => {
-    describe('getOutboundEntityUpdates', () => {
-        const config = {};
-        const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
-        const dc = new data_converter_1.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 = {};
-        const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
-        beforeEach(() => {
-            jest.clearAllMocks();
-        });
-        it('entity parameter not set', async () => {
-            const btep = new TestBaseEntityProcessor({}, {}, {}, '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({}, {}, {}, '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({}, {}, {}, '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 data_converter_1.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 = {};
-        const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
-        beforeEach(() => {
-            jest.clearAllMocks();
-        });
-        it('entity parameter not set', async () => {
-            const btep = new TestBaseEntityProcessor({}, {}, {}, '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({}, {}, {}, '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({}, {}, {}, '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 data_converter_1.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 { 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({}, {}, {}, 'test');
-            const rootType = '';
-            expect(async () => { await btep.getRootTypePropertyKeys(rootType); }).rejects.toThrow();
-        });
-        it('get keys from rootType.typeProperties', async () => {
-            const btep = new TestBaseEntityProcessor({}, {}, {}, '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({}, {}, {}, 'test');
-            const rootType = {
-                typeProperties: [{ slug: 'a' }, { slug: 'b' }]
-            };
-            const keys = await btep.getRootTypePropertyKeys(rootType);
-            expect(keys).toEqual(['a', 'b']);
-        });
-    });
-});
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_1 = require("@contrail/sdk");
+const transform_data_1 = require("@contrail/transform-data");
+const data_converter_1 = require("../util/data-converter");
+const base_entity_processor_1 = require("./base-entity-processor");
+const type_conversion_utils_1 = require("../util/type-conversion-utils");
+const thumbnail_util_1 = require("../util/thumbnail-util");
+const mockRootType = {
+    typeProperties: [
+        { slug: 'rootText' }
+    ]
+};
+const mockTypeUtilGetByRootAndPath = jest.fn((options) => {
+    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 base_entity_processor_1.BaseEntityProcessor {
+    getIncomingEntity(event, inboundData) {
+        throw new Error("Method not implemented.");
+    }
+    getCreateEntity(inboundData) {
+        throw new Error("Method not implemented.");
+    }
+    getOutgoingUpsertPayload(entityType, event) {
+        throw new Error("Method not implemented.");
+    }
+}
+describe('BaseEntityProcessor', () => {
+    describe('getOutboundEntityUpdates', () => {
+        const config = {};
+        const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+        const dc = new data_converter_1.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 = {};
+        const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+        beforeEach(() => {
+            jest.clearAllMocks();
+        });
+        it('entity parameter not set', async () => {
+            const btep = new TestBaseEntityProcessor({}, {}, {}, '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({}, {}, {}, '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({}, {}, {}, '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 data_converter_1.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 = {};
+        const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+        beforeEach(() => {
+            jest.clearAllMocks();
+        });
+        it('entity parameter not set', async () => {
+            const btep = new TestBaseEntityProcessor({}, {}, {}, '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({}, {}, {}, '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({}, {}, {}, '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 data_converter_1.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 { 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({}, {}, {}, 'test');
+            const rootType = '';
+            expect(async () => { await btep.getRootTypePropertyKeys(rootType); }).rejects.toThrow();
+        });
+        it('get keys from rootType.typeProperties', async () => {
+            const btep = new TestBaseEntityProcessor({}, {}, {}, '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({}, {}, {}, '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 = {};
+        const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+        const dc = new data_converter_1.DataConverter(config, mapFileUtil);
+        const mockEvent = { objectClass: 'TestClass', federatedId: 'fed-123', data: { name: 'test' }, entityReference: 'ref-1', eventType: 'PERSIST' };
+        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;
+        let syncInboundImagesSpy;
+        let syncThumbnailSpy;
+        beforeEach(() => {
+            jest.clearAllMocks();
+            btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'test');
+            jest.spyOn(btep, 'getTransformedData').mockResolvedValue(mockInboundData);
+            syncInboundImagesSpy = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'syncInboundImages');
+            syncThumbnailSpy = jest.spyOn(thumbnail_util_1.ThumbnailUtil.prototype, 'syncThumbnailToVibeIQ').mockResolvedValue(undefined);
+        });
+        it('should call syncThumbnailToVibeIQ with entity after create when syncInboundImages returns true', async () => {
+            jest.spyOn(btep, 'getIncomingEntity').mockResolvedValue({ entity: null });
+            jest.spyOn(btep, 'getCreateEntity').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').mockResolvedValue({ entity: null });
+            jest.spyOn(btep, 'getCreateEntity').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').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').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').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').mockResolvedValue({ entity: null });
+            jest.spyOn(btep, 'getCreateEntity').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').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').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' } });
+        });
+    });
+});