@contrail/flexplm 1.2.1 → 1.3.0-alpha.3

package/lib/util/thumbnail-util.spec.js

@@ -2,6 +2,30 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const thumbnail_util_1 = require("./thumbnail-util");
 const mockData_1 = require("./mockData");
+const mockEntitiesGet = jest.fn();
+const mockEntitiesUpdate = jest.fn();
+const mockEntitiesDelete = jest.fn();
+const mockContentCreate = jest.fn();
+jest.mock('@contrail/sdk', () => {
+    return {
+        Entities: jest.fn().mockImplementation(() => ({
+            get: mockEntitiesGet,
+            update: mockEntitiesUpdate,
+            delete: mockEntitiesDelete,
+        })),
+        Content: jest.fn().mockImplementation(() => ({
+            create: mockContentCreate,
+        })),
+    };
+});
+const mockGetRequest = jest.fn();
+jest.mock('./flexplm-connect', () => {
+    return {
+        FlexPLMConnect: jest.fn().mockImplementation(() => ({
+            getRequest: mockGetRequest,
+        })),
+    };
+});
 describe('ThumbnailUtil Tests', () => {
     const config = {};
     describe('setOutboundThumbnail()', () => {
@@ -239,4 +263,136 @@ describe('ThumbnailUtil Tests', () => {
             expect(content.primaryFile.id).toEqual('file123');
         });
     });
+    describe('syncThumbnailToVibeIQ', () => {
+        let tu;
+        beforeEach(() => {
+            jest.clearAllMocks();
+            tu = new thumbnail_util_1.ThumbnailUtil(config);
+            mockEntitiesGet.mockImplementation((opts) => {
+                if (opts.entityName === 'content-custom-size')
+                    return Promise.resolve([]);
+                return Promise.resolve({});
+            });
+            mockEntitiesUpdate.mockImplementation((opts) => Promise.resolve({ id: opts.id }));
+            mockEntitiesDelete.mockImplementation((opts) => Promise.resolve({ id: opts.id }));
+        });
+        it('returns undefined when no thumbnail IDs in event data', async () => {
+            const event = { data: {} };
+            const result = await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', event, entityName: 'color' });
+            expect(result).toBeUndefined();
+            expect(mockEntitiesUpdate).not.toHaveBeenCalled();
+            expect(mockEntitiesDelete).not.toHaveBeenCalled();
+            expect(mockContentCreate).not.toHaveBeenCalled();
+        });
+        it('returns undefined when event.data is undefined', async () => {
+            const event = {};
+            const result = await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', event, entityName: 'color' });
+            expect(result).toBeUndefined();
+            expect(mockEntitiesUpdate).not.toHaveBeenCalled();
+            expect(mockEntitiesDelete).not.toHaveBeenCalled();
+        });
+        it('REMOVE_THUMBNAIL with existing primaryViewableId deletes content and returns clear updates', async () => {
+            const event = { data: { [thumbnail_util_1.ThumbnailUtil.NEW_THUMBNAIL_ID]: thumbnail_util_1.ThumbnailUtil.REMOVE_THUMBNAIL } };
+            const result = await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', primaryViewableId: 'pv1', event, entityName: 'color' });
+            expect(mockEntitiesDelete).toHaveBeenCalledWith({ entityName: 'content', id: 'pv1' });
+            expect(result).toEqual(expect.objectContaining({ primaryViewableId: null, primaryFileUrl: null }));
+        });
+        it('REMOVE_THUMBNAIL with no primaryViewableId returns clear updates without deleting', async () => {
+            const event = { data: { [thumbnail_util_1.ThumbnailUtil.NEW_THUMBNAIL_ID]: thumbnail_util_1.ThumbnailUtil.REMOVE_THUMBNAIL } };
+            const result = await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', event, entityName: 'item' });
+            expect(mockEntitiesDelete).not.toHaveBeenCalled();
+            expect(result).toEqual(expect.objectContaining({ primaryViewableId: null }));
+        });
+        it('creates new content when no primaryViewableId exists and returns primary viewable updates', async () => {
+            const mockResponse = {
+                arrayBuffer: jest.fn().mockResolvedValue(new ArrayBuffer(8)),
+                headers: { get: jest.fn().mockReturnValue('image/png') },
+            };
+            mockGetRequest.mockResolvedValue(mockResponse);
+            const createdContent = {
+                id: 'newContent1',
+                contentType: 'image/png',
+                fileName: 'thumb.png',
+                primaryFileUrl: 'https://files/primary.png',
+                largeViewableUrl: 'https://files/large.png',
+                mediumLargeViewableUrl: null,
+                mediumViewableUrl: null,
+                smallViewableUrl: null,
+                tinyViewableUrl: null,
+            };
+            mockContentCreate.mockResolvedValue(createdContent);
+            const event = { data: { [thumbnail_util_1.ThumbnailUtil.NEW_THUMBNAIL_ID]: '/rest/thumbnail/thumb.png' } };
+            const result = await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', event, entityName: 'color' });
+            expect(mockGetRequest).toHaveBeenCalledWith({ urlPath: '/rest/thumbnail/thumb.png', includeUrlContext: false, returnFullResponse: true });
+            expect(mockContentCreate).toHaveBeenCalledWith(expect.objectContaining({
+                fileName: 'thumb.png',
+                contentType: 'image/png',
+                contentHolderReference: 'color:entity1',
+            }));
+            expect(mockEntitiesUpdate).toHaveBeenCalledWith(expect.objectContaining({
+                entityName: 'content',
+                id: 'newContent1',
+                object: { flexplmThumbnailUrl: '/rest/thumbnail/thumb.png' },
+            }));
+            expect(result).toEqual(expect.objectContaining({
+                primaryViewableId: 'newContent1',
+                primaryFileUrl: 'https://files/primary.png',
+                largeViewableDownloadUrl: 'https://files/large.png',
+            }));
+        });
+        it('replaces content when primaryViewable.flexplmThumbnailUrl differs and returns updates', async () => {
+            mockEntitiesGet.mockImplementation((opts) => {
+                if (opts.entityName === 'content-custom-size')
+                    return Promise.resolve([]);
+                if (opts.entityName === 'content' && opts.id === 'oldPv') {
+                    return Promise.resolve({ id: 'oldPv', flexplmThumbnailUrl: '/rest/thumbnail/old.png' });
+                }
+                return Promise.resolve({});
+            });
+            const mockResponse = {
+                arrayBuffer: jest.fn().mockResolvedValue(new ArrayBuffer(8)),
+                headers: { get: jest.fn().mockReturnValue('image/jpeg') },
+            };
+            mockGetRequest.mockResolvedValue(mockResponse);
+            const createdContent = {
+                id: 'newContent2',
+                contentType: 'image/jpeg',
+                fileName: 'new.jpg',
+                primaryFileUrl: 'https://files/new-primary.jpg',
+                largeViewableUrl: null,
+                mediumLargeViewableUrl: null,
+                mediumViewableUrl: null,
+                smallViewableUrl: null,
+                tinyViewableUrl: null,
+            };
+            mockContentCreate.mockResolvedValue(createdContent);
+            const event = { data: { [thumbnail_util_1.ThumbnailUtil.NEW_THUMBNAIL_ID]: '/rest/thumbnail/new.jpg' } };
+            const result = await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', primaryViewableId: 'oldPv', event, entityName: 'item' });
+            expect(mockContentCreate).toHaveBeenCalled();
+            expect(mockEntitiesUpdate).toHaveBeenCalledWith(expect.objectContaining({
+                entityName: 'content',
+                id: 'newContent2',
+                object: { flexplmThumbnailUrl: '/rest/thumbnail/new.jpg' },
+            }));
+            expect(result).toEqual(expect.objectContaining({ primaryViewableId: 'newContent2' }));
+            expect(mockEntitiesDelete).toHaveBeenCalledWith({ entityName: 'content', id: 'oldPv' });
+        });
+        it('returns undefined when primaryViewable.flexplmThumbnailUrl matches', async () => {
+            const thumbnailUrl = '/rest/thumbnail/same.png';
+            mockEntitiesGet.mockImplementation((opts) => {
+                if (opts.entityName === 'content-custom-size')
+                    return Promise.resolve([]);
+                if (opts.entityName === 'content' && opts.id === 'pv1') {
+                    return Promise.resolve({ id: 'pv1', flexplmThumbnailUrl: thumbnailUrl });
+                }
+                return Promise.resolve({});
+            });
+            const event = { data: { [thumbnail_util_1.ThumbnailUtil.EXISTING_THUMBNAIL_ID]: thumbnailUrl } };
+            const result = await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', primaryViewableId: 'pv1', event, entityName: 'color' });
+            expect(result).toBeUndefined();
+            expect(mockContentCreate).not.toHaveBeenCalled();
+            expect(mockEntitiesUpdate).not.toHaveBeenCalled();
+            expect(mockEntitiesDelete).not.toHaveBeenCalled();
+        });
+    });
 });

package/lib/util/type-conversion-utils-spec-mockData.js

@@ -137,6 +137,12 @@ exports.mapping = {
         isOutboundCreatable: (entity, context) => {
             return false;
         },
+        syncInboundImages: (entity, context) => {
+            return true;
+        },
+        syncOutboundImages: (entity, context) => {
+            return false;
+        },
         vibe2flex: {
             transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
             rekey: {
@@ -169,6 +175,18 @@ exports.mapping = {
             }
             return true;
         },
+        syncInboundImages: (entity, context) => {
+            if (context && context.skipImages) {
+                return false;
+            }
+            return true;
+        },
+        syncOutboundImages: (entity, context) => {
+            if (context && context.skipImages) {
+                return false;
+            }
+            return true;
+        },
         vibe2flex: {
             transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
             rekey: {

package/lib/util/type-conversion-utils.d.ts

@@ -17,5 +17,7 @@ export declare class TypeConversionUtils {
     static getMapKeyFromObject(fileId: any, mapFileUtil: MapFileUtil, object: any, direction: string): Promise<string>;
     static isInboundCreatableFromObject(fileId: string, mapFileUtil: MapFileUtil, object: any, context?: any): Promise<boolean>;
     static isOutboundCreatableFromEntity(fileId: string, mapFileUtil: MapFileUtil, entity: any, context?: any): Promise<boolean>;
+    static syncInboundImages(fileId: string, mapFileUtil: MapFileUtil, object: any, context?: any): Promise<boolean>;
+    static syncOutboundImages(fileId: string, mapFileUtil: MapFileUtil, entity: any, context?: any): Promise<boolean>;
     static getObjectType(object: any): any;
 }

package/lib/util/type-conversion-utils.js

@@ -179,6 +179,7 @@ class TypeConversionUtils {
             }
             return type;
         }
+        return '';
     }
     static async isInboundCreatableFromObject(fileId, mapFileUtil, object, context) {
         let isInboundCreatable = false;
@@ -212,6 +213,48 @@ class TypeConversionUtils {
         }
         return isOutboundCreatable;
     }
+    static async syncInboundImages(fileId, mapFileUtil, object, context) {
+        let syncImages = false;
+        if (!fileId) {
+            return syncImages;
+        }
+        let mapKey;
+        try {
+            mapKey = await this.getMapKeyFromObject(fileId, mapFileUtil, object, TypeConversionUtils.FLEX2VIBE_DIRECTION);
+        }
+        catch {
+            return syncImages;
+        }
+        if (!mapKey) {
+            return syncImages;
+        }
+        const mapData = await map_utils_1.MapUtil.getFullMapSection(fileId, mapFileUtil, mapKey);
+        if (mapData && mapData['syncInboundImages']) {
+            syncImages = await mapData['syncInboundImages'](object, context);
+        }
+        return syncImages;
+    }
+    static async syncOutboundImages(fileId, mapFileUtil, entity, context) {
+        let syncImages = true;
+        if (!fileId) {
+            return syncImages;
+        }
+        let mapKey;
+        try {
+            mapKey = await this.getMapKey(fileId, mapFileUtil, entity, TypeConversionUtils.VIBE2FLEX_DIRECTION);
+        }
+        catch {
+            return syncImages;
+        }
+        if (!mapKey) {
+            return syncImages;
+        }
+        const mapData = await map_utils_1.MapUtil.getFullMapSection(fileId, mapFileUtil, mapKey);
+        if (mapData && mapData['syncOutboundImages']) {
+            syncImages = await mapData['syncOutboundImages'](entity, context);
+        }
+        return syncImages;
+    }
     static getObjectType(object) {
         let objectType = object['flexPLMObjectClass'];
         return objectType;

package/lib/util/type-conversion-utils.spec.js

@@ -705,4 +705,164 @@ describe('conversion-utils', () => {
             }
         });
     });
+    describe('syncInboundImages', () => {
+        const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+        it('should return true for Revisable Entity\\packaging (mapping entry true)', async () => {
+            const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+                .mockImplementation(async () => {
+                return mapping;
+            });
+            const obj = {
+                flexPLMObjectClass: 'LCSRevisableEntity',
+                flexPLMTypePath: 'Revisable Entity\\packaging'
+            };
+            try {
+                const results = await type_conversion_utils_1.TypeConversionUtils.syncInboundImages(TRANSFORM_MAP_FILE, mapFileUtil, obj);
+                expect(results).toBeTruthy();
+            }
+            finally {
+                spy.mockRestore();
+            }
+        });
+        it('should return true for Revisable Entity\\prefix (mapping entry true)', async () => {
+            const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+                .mockImplementation(async () => {
+                return mapping;
+            });
+            const obj = {
+                flexPLMObjectClass: 'LCSRevisableEntity',
+                flexPLMTypePath: 'Revisable Entity\\prefix'
+            };
+            try {
+                const results = await type_conversion_utils_1.TypeConversionUtils.syncInboundImages(TRANSFORM_MAP_FILE, mapFileUtil, obj);
+                expect(results).toBeTruthy();
+            }
+            finally {
+                spy.mockRestore();
+            }
+        });
+        it('should pass context to syncInboundImages function', async () => {
+            const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+                .mockImplementation(async () => {
+                return mapping;
+            });
+            const obj = {
+                flexPLMObjectClass: 'LCSRevisableEntity',
+                flexPLMTypePath: 'Revisable Entity\\prefix'
+            };
+            const context = { skipImages: true };
+            try {
+                const results = await type_conversion_utils_1.TypeConversionUtils.syncInboundImages(TRANSFORM_MAP_FILE, mapFileUtil, obj, context);
+                expect(results).toBeFalsy();
+            }
+            finally {
+                spy.mockRestore();
+            }
+        });
+        it('should default to false when no mapping exists', async () => {
+            const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+                .mockImplementation(async () => {
+                return mapping;
+            });
+            const obj = {
+                flexPLMObjectClass: 'LCSRevisableEntity',
+                flexPLMTypePath: 'Revisable Entity\\catName'
+            };
+            try {
+                const results = await type_conversion_utils_1.TypeConversionUtils.syncInboundImages(TRANSFORM_MAP_FILE, mapFileUtil, obj);
+                expect(results).toBeFalsy();
+            }
+            finally {
+                spy.mockRestore();
+            }
+        });
+        it('should default to false when no fileId', async () => {
+            const obj = {
+                flexPLMObjectClass: 'LCSRevisableEntity',
+                flexPLMTypePath: 'Revisable Entity\\pack'
+            };
+            const results = await type_conversion_utils_1.TypeConversionUtils.syncInboundImages('', mapFileUtil, obj);
+            expect(results).toBeFalsy();
+        });
+    });
+    describe('syncOutboundImages', () => {
+        const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+        it('should return false for custom-entity:pack (mapping entry false)', async () => {
+            const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+                .mockImplementation(async () => {
+                return mapping;
+            });
+            const entity = {
+                entityType: 'custom-entity',
+                typePath: 'custom-entity:pack'
+            };
+            try {
+                const results = await type_conversion_utils_1.TypeConversionUtils.syncOutboundImages(TRANSFORM_MAP_FILE, mapFileUtil, entity);
+                expect(results).toBeFalsy();
+            }
+            finally {
+                spy.mockRestore();
+            }
+        });
+        it('should return true for custom-entity:prefix (mapping entry true)', async () => {
+            const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+                .mockImplementation(async () => {
+                return mapping;
+            });
+            const entity = {
+                entityType: 'custom-entity',
+                typePath: 'custom-entity:prefix'
+            };
+            try {
+                const results = await type_conversion_utils_1.TypeConversionUtils.syncOutboundImages(TRANSFORM_MAP_FILE, mapFileUtil, entity);
+                expect(results).toBeTruthy();
+            }
+            finally {
+                spy.mockRestore();
+            }
+        });
+        it('should pass context to syncOutboundImages function', async () => {
+            const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+                .mockImplementation(async () => {
+                return mapping;
+            });
+            const entity = {
+                entityType: 'custom-entity',
+                typePath: 'custom-entity:prefix'
+            };
+            const context = { skipImages: true };
+            try {
+                const results = await type_conversion_utils_1.TypeConversionUtils.syncOutboundImages(TRANSFORM_MAP_FILE, mapFileUtil, entity, context);
+                expect(results).toBeFalsy();
+            }
+            finally {
+                spy.mockRestore();
+            }
+        });
+        it('should default to true when no mapping exists', async () => {
+            const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+                .mockImplementation(async () => {
+                return mapping;
+            });
+            const entity = {
+                entityType: 'custom-entity',
+                typePath: 'custom-entity:catName'
+            };
+            try {
+                const results = await type_conversion_utils_1.TypeConversionUtils.syncOutboundImages(TRANSFORM_MAP_FILE, mapFileUtil, entity);
+                expect(results).toBeTruthy();
+            }
+            finally {
+                spy.mockRestore();
+            }
+        });
+        it('should default to true when no fileId', async () => {
+            const entity = {
+                entityType: 'custom-entity',
+                typePath: 'custom-entity:pack'
+            };
+            const results = await type_conversion_utils_1.TypeConversionUtils.syncOutboundImages('', mapFileUtil, entity);
+            expect(results).toBeTruthy();
+        });
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/flexplm",
-  "version": "1.2.1",
+  "version": "1.3.0-alpha.3",
   "description": "Library used for integration with flexplm.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/publish.bat

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

package/publish.sh

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

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

@@ -3,6 +3,8 @@ 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: [
@@ -335,4 +337,159 @@ describe('BaseEntityProcessor', () =>{
 
   });
 
+  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 updateEntity with thumbnail updates 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);
+      const updateEntitySpy = jest.spyOn(btep, 'updateEntity').mockResolvedValue(mockCreatedEntity);
+      syncInboundImagesSpy.mockResolvedValue(true);
+      const thumbnailUpdates = { primaryViewableId: 'pv-new', primaryFileUrl: 'https://files/new.png' };
+      syncThumbnailSpy.mockResolvedValue(thumbnailUpdates);
+
+      const result = await btep.handleIncomingUpsert(mockEvent);
+
+      expect(syncThumbnailSpy).toBeCalledTimes(1);
+      expect(syncThumbnailSpy).toBeCalledWith({ entityId: 'created-1', primaryViewableId: 'pv-created', event: mockEvent, entityName: 'test' });
+      expect(updateEntitySpy).toBeCalledWith('test', mockCreatedEntity, thumbnailUpdates);
+      expect(result).toBe(mockCreatedEntity);
+    });
+
+    it('should not call updateEntity after create when syncThumbnailToVibeIQ returns undefined', 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);
+      const updateEntitySpy = jest.spyOn(btep, 'updateEntity');
+      syncInboundImagesSpy.mockResolvedValue(true);
+      syncThumbnailSpy.mockResolvedValue(undefined);
+
+      const result = await btep.handleIncomingUpsert(mockEvent);
+
+      expect(syncThumbnailSpy).toBeCalledTimes(1);
+      expect(updateEntitySpy).not.toHaveBeenCalled();
+      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 merge thumbnail updates 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 thumbnailUpdates = { primaryViewableId: 'pv-new' };
+      syncThumbnailSpy.mockResolvedValue(thumbnailUpdates);
+
+      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', primaryViewableId: 'pv-new' });
+      expect(result).toBe(mockUpdatedEntity);
+    });
+
+    it('should update entity with only thumbnail changes when no property diffs', async () =>{
+      jest.spyOn(btep, 'getIncomingEntity' as any).mockResolvedValue({ entity: mockExistingEntity });
+      jest.spyOn(btep, 'getUpdatesForEntity').mockResolvedValue({});
+      const updateEntitySpy = jest.spyOn(btep, 'updateEntity').mockResolvedValue(mockUpdatedEntity);
+      syncInboundImagesSpy.mockResolvedValue(true);
+      const thumbnailUpdates = { primaryViewableId: 'pv-new' };
+      syncThumbnailSpy.mockResolvedValue(thumbnailUpdates);
+
+      const result = await btep.handleIncomingUpsert(mockEvent);
+
+      expect(updateEntitySpy).toBeCalledWith('test', mockExistingEntity, { primaryViewableId: 'pv-new' });
+      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' } });
+    });
+  });
+
 });