@contrail/flexplm 1.5.0-alpha.98b8b06 → 1.5.0

package/src/util/thumbnail-util.spec.ts

@@ -0,0 +1,508 @@
+import { FCConfig } from '../interfaces/interfaces';
+import { ThumbnailUtil } from './thumbnail-util';
+
+import { empty_custom_sizes, four_custom_sizes, thumbnail_content_entity } from './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 = {} as FCConfig;
+  describe('setOutboundThumbnail()', () =>{
+    const tu = new ThumbnailUtil(config);
+    beforeEach(() =>{
+      jest.clearAllMocks();
+    });
+
+    it('no data', async () =>{
+      const data = {};
+      const event = {};
+      const results = await tu.setOutboundThumbnail(data, event);
+      const keys = Object.keys(results);
+
+      expect(results).toEqual(data);
+      expect(keys.length).toEqual(0);
+    });
+
+    it('remove thumbnail', async () =>{
+      const data = {};
+      const event = {
+        propertyDiffs: {
+          largeViewableDownloadUrl: {
+            oldValue: '123',
+            newValue: null
+          }
+        }
+      };
+      const results = await tu.setOutboundThumbnail(data, event);
+      const keys = Object.keys(results);
+
+      expect(keys.length).toEqual(1);
+      expect(keys[0]).toEqual(ThumbnailUtil.NEW_THUMBNAIL_ID);
+      expect(results[ThumbnailUtil.NEW_THUMBNAIL_ID]).toEqual(ThumbnailUtil.REMOVE_THUMBNAIL);
+
+    });
+
+    it('calling getFileId - new thumbnail', async () =>{
+      const data = {};
+      const newDownloadUrl = 'https://api.vibeiq.com/dev/api/files/downloadUrl/w3ckfeGAD8ViOZj-%2Fcontent:E1iBQuWbr74lcdcw%2F9e30ds9o-d34b-451e-ae59-b4km36018d5a.png';
+      const oldDownloadUrl = 'xxx';
+      const thumbnailId = 'Eey3ZOiqdrUA84F8';
+      const event = {
+        newData: {
+          primaryViewableId: 'm5bJa4RtTLUtKBP5',
+          largeViewableDownloadUrl: newDownloadUrl
+        },
+        propertyDiffs: {
+          largeViewableDownloadUrl :{
+            newValue: newDownloadUrl,
+            oldValue: oldDownloadUrl
+          }
+        }
+      };
+
+      const spyCustomSizes = jest.spyOn(tu, 'getCustomSizes');
+      spyCustomSizes.mockReturnValue(Promise.resolve(empty_custom_sizes));
+      const spyGetFileId = jest.spyOn(tu, 'getFileId');
+      spyGetFileId.mockReturnValue(Promise.resolve(thumbnailId));
+      const results = await tu.setOutboundThumbnail(data, event);
+      const keys = Object.keys(results);
+      expect(keys.length).toEqual(1);
+      expect(keys[0]).toEqual(ThumbnailUtil.NEW_THUMBNAIL_ID);
+      const thumbnailValue = results[ThumbnailUtil.NEW_THUMBNAIL_ID];
+      expect(thumbnailValue).toEqual(thumbnailId);
+    });
+
+    it('calling getFileId - existing thumbnail', async () =>{
+      const data = {};
+      const newDownloadUrl = 'https://api.vibeiq.com/dev/api/files/downloadUrl/w3ckfeGAD8ViOZj-%2Fcontent:E1iBQuWbr74lcdcw%2F9e30ds9o-d34b-451e-ae59-b4km36018d5a.png';
+      const thumbnailId = 'Eey3ZOiqdrUA84F8';
+      const event = {
+        newData: {
+          primaryViewableId: 'm5bJa4RtTLUtKBP5',
+          largeViewableDownloadUrl: newDownloadUrl
+        },
+        propertyDiffs: {}
+      };
+
+      const spyCustomSizes = jest.spyOn(tu, 'getCustomSizes');
+      spyCustomSizes.mockReturnValue(Promise.resolve(empty_custom_sizes));
+      const spyGetFileId = jest.spyOn(tu, 'getFileId');
+      spyGetFileId.mockReturnValue(Promise.resolve(thumbnailId));
+      const results = await tu.setOutboundThumbnail(data, event);
+      const keys = Object.keys(results);
+      expect(keys.length).toEqual(1);
+      expect(keys[0]).toEqual(ThumbnailUtil.EXISTING_THUMBNAIL_ID);
+      const thumbnailValue = results[ThumbnailUtil.EXISTING_THUMBNAIL_ID];
+      expect(thumbnailValue).toEqual(thumbnailId);
+    });
+  });
+
+  describe('getFileId', () =>{
+    const primaryFileId = 'yn2d5oHD4rXHRzyB';
+    beforeEach(() =>{
+      jest.clearAllMocks();
+    });
+    it('no custom sizes, default max_thumbnail_size - result large', async () =>{
+      const tu = new ThumbnailUtil(config);
+      const spyCustomSizes = jest.spyOn(tu, 'getCustomSizes');
+      spyCustomSizes.mockReturnValue(Promise.resolve(empty_custom_sizes));
+      const spyContentEntity = jest.spyOn(tu, 'getContentEntity');
+      const content = JSON.parse(JSON.stringify(thumbnail_content_entity));
+
+      spyContentEntity.mockReturnValue(Promise.resolve(content));
+
+      const results = await tu.getFileId(primaryFileId);
+      expect(results).toEqual('vo4N4mCd-tFrw101');
+    });
+
+    it('no custom sizes, 750 * 1_024 max_thumbnail_size - result medium', async () =>{
+      const config1 = {
+        max_thumbnail_size: 750 * 1_024
+      } as any as FCConfig;
+      const tu = new ThumbnailUtil(config1);
+      const spyCustomSizes = jest.spyOn(tu, 'getCustomSizes');
+      spyCustomSizes.mockReturnValue(Promise.resolve(empty_custom_sizes));
+      const spyContentEntity = jest.spyOn(tu, 'getContentEntity');
+      const content = thumbnail_content_entity;
+      spyContentEntity.mockReturnValue(Promise.resolve(content));
+
+      const results = await tu.getFileId(primaryFileId);
+      expect(results).toEqual('AsRvJenpeqxksUNW');
+    });
+
+    it('custom sizes, 750 * 1_024 max_thumbnail_size - result CS_500Id', async () =>{
+      const config1 = {
+        max_thumbnail_size: 750 * 1_024
+      } as any as FCConfig;
+      const tu = new ThumbnailUtil(config1);
+      const spyCustomSizes = jest.spyOn(tu, 'getCustomSizes');
+      spyCustomSizes.mockReturnValue(Promise.resolve(four_custom_sizes));
+      const spyContentEntity = jest.spyOn(tu, 'getContentEntity');
+      const content = thumbnail_content_entity;
+      spyContentEntity.mockReturnValue(Promise.resolve(content));
+
+      const results = await tu.getFileId(primaryFileId);
+      expect(results).toEqual('rBaHc1J2xdOWdbhI');
+    });
+
+  });
+
+  describe('Test isThumbnailNew', () =>{
+    const tu = new ThumbnailUtil(config);
+    it('no propertyDiffs', () =>{
+      const event = {
+        newData: {
+          name: 'Test'
+        },
+        oldData:{
+          name: 'Test'
+        }
+      };
+      const results = tu.isThumbnailNew(event, undefined);
+      expect(results).toBeFalsy();
+    });
+  
+    it('empty propertyDiffs', () =>{
+      const event = {
+        newData: {
+          name: 'Test'
+        },
+        oldData:{
+          name: 'Test'
+        },
+        propertyDiffs: {}
+      };
+      const results = tu.isThumbnailNew(event, undefined);
+      expect(results).toBeFalsy();
+    });
+  
+    it('propertyDiffs diff property', () =>{
+      const event = {
+        newData: {
+          name: 'Test1'
+        },
+        oldData:{
+          name: 'Test'
+        },
+        propertyDiffs: {
+          name: {
+            propertyName: 'name',
+            oldValue: 'Test',
+            newValue: 'Test1'
+          }
+        }
+      };
+      const results = tu.isThumbnailNew(event, undefined);
+      expect(results).toBeFalsy();
+    });
+  
+    it('propertyDiffs OOB property', () =>{
+      const event = {
+        newData: {
+          name: 'Test1'
+        },
+        oldData:{
+          name: 'Test'
+        },
+        propertyDiffs: {
+          mediumLargeViewableDownloadUrl: {
+            propertyName: 'mediumLargeViewableDownloadUrl',
+            oldValue: '',
+            newValue: 'Test1'
+          }
+        }
+      };
+      const results = tu.isThumbnailNew(event, undefined);
+      expect(results).toBeTruthy();
+    });
+  
+    it('propertyDiffs custom property', () =>{
+      const event = {
+        newData: {
+          name: 'Test1'
+        },
+        oldData:{
+          name: 'Test'
+        },
+        propertyDiffs: {
+          RL_1000Url: {
+            propertyName: 'RL_1000Url',
+            oldValue: '',
+            newValue: 'Test1'
+          }
+        }
+      };
+      const results = tu.isThumbnailNew(event, [{slug: 'RL_1000'}]);
+      expect(results).toBeTruthy();
+    });
+  });
+
+  describe('logContentResults', () =>{
+    it('no content - doesnt error', () =>{
+      const tu = new ThumbnailUtil(config);
+      const content = undefined;
+      const relations = [];
+      tu.logContentResults(content, relations);
+    });
+    it('no relations - doesnt error', () =>{
+      const tu = new ThumbnailUtil(config);
+      const content = undefined;
+      const relations = undefined;
+      tu.logContentResults(content, relations);
+    });
+
+    it('content and relations - logs', () =>{
+      const tu = new ThumbnailUtil(config);
+      const content = {
+        id: '123',
+        name: 'Test',
+        primaryFile: { id:'file123'}
+      };
+      const relations = ['primaryFile'];
+      tu.logContentResults(content, relations);
+
+      expect(Object.keys(content)).toHaveLength(3);
+      expect(content).toHaveProperty('primaryFile');
+      expect(content.primaryFile).toHaveProperty('id');
+      expect(content.primaryFile.id).toEqual('file123');
+    });
+
+  });
+
+  describe('syncThumbnailToVibeIQ', () => {
+    let tu: ThumbnailUtil;
+
+    beforeEach(() => {
+      jest.clearAllMocks();
+      tu = new 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('does not update when no thumbnail IDs in event data', async () => {
+      const event = { data: {} };
+      await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', event, entityName: 'color' });
+
+      expect(mockEntitiesUpdate).not.toHaveBeenCalled();
+      expect(mockEntitiesDelete).not.toHaveBeenCalled();
+      expect(mockContentCreate).not.toHaveBeenCalled();
+    });
+
+    it('does not update when event.data is undefined', async () => {
+      const event = {};
+      await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', event, entityName: 'color' });
+
+      expect(mockEntitiesUpdate).not.toHaveBeenCalled();
+      expect(mockEntitiesDelete).not.toHaveBeenCalled();
+    });
+
+    it('REMOVE_THUMBNAIL with existing primaryViewableId deletes content and updates entity', async () => {
+      const event = { data: { [ThumbnailUtil.NEW_THUMBNAIL_ID]: ThumbnailUtil.REMOVE_THUMBNAIL } };
+      await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', primaryViewableId: 'pv1', event, entityName: 'color' });
+
+      expect(mockEntitiesDelete).toHaveBeenCalledWith({ entityName: 'content', id: 'pv1' });
+      expect(mockEntitiesUpdate).toHaveBeenCalledWith(expect.objectContaining({ entityName: 'color', id: 'entity1' }));
+    });
+
+    it('REMOVE_THUMBNAIL with no primaryViewableId updates entity without deleting', async () => {
+      const event = { data: { [ThumbnailUtil.NEW_THUMBNAIL_ID]: ThumbnailUtil.REMOVE_THUMBNAIL } };
+      await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', event, entityName: 'item' });
+
+      expect(mockEntitiesDelete).not.toHaveBeenCalled();
+      expect(mockEntitiesUpdate).toHaveBeenCalledWith(expect.objectContaining({ entityName: 'item', id: 'entity1' }));
+    });
+
+    it('creates new content when no primaryViewableId exists and updates entity', 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: { [ThumbnailUtil.NEW_THUMBNAIL_ID]: '/rest/thumbnail/thumb.png' } };
+      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',
+        }),
+      );
+      // Updates content with flexplmThumbnailUrl
+      expect(mockEntitiesUpdate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          entityName: 'content',
+          id: 'newContent1',
+          object: { flexplmThumbnailUrl: '/rest/thumbnail/thumb.png' },
+        }),
+      );
+      // Updates the main entity
+      expect(mockEntitiesUpdate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          entityName: 'color',
+          id: 'entity1',
+        }),
+      );
+    });
+
+    it('encodes URL path segments with special characters', async () => {
+      const mockResponse = {
+        arrayBuffer: jest.fn().mockResolvedValue(new ArrayBuffer(8)),
+        headers: { get: jest.fn().mockReturnValue('image/png') },
+      };
+      mockGetRequest.mockResolvedValue(mockResponse);
+      mockContentCreate.mockResolvedValue({
+        id: 'c1', contentType: 'image/png', fileName: 'my image.png',
+        primaryFileUrl: 'https://files/primary.png', largeViewableUrl: null,
+        mediumLargeViewableUrl: null, mediumViewableUrl: null, smallViewableUrl: null, tinyViewableUrl: null,
+      });
+
+      const event = { data: { [ThumbnailUtil.NEW_THUMBNAIL_ID]: '/rest/thumbnail/my image.png' } };
+      await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', event, entityName: 'color' });
+
+      expect(mockGetRequest).toHaveBeenCalledWith({
+        urlPath: '/rest/thumbnail/my%20image.png',
+        includeUrlContext: false,
+        returnFullResponse: true,
+      });
+      expect(mockContentCreate).toHaveBeenCalledWith(
+        expect.objectContaining({ fileName: 'my image.png' }),
+      );
+    });
+
+    it('encodes URL path segments with unicode characters', async () => {
+      const mockResponse = {
+        arrayBuffer: jest.fn().mockResolvedValue(new ArrayBuffer(8)),
+        headers: { get: jest.fn().mockReturnValue('image/jpeg') },
+      };
+      mockGetRequest.mockResolvedValue(mockResponse);
+      mockContentCreate.mockResolvedValue({
+        id: 'c2', contentType: 'image/jpeg', fileName: 'café-logo.jpg',
+        primaryFileUrl: 'https://files/primary.jpg', largeViewableUrl: null,
+        mediumLargeViewableUrl: null, mediumViewableUrl: null, smallViewableUrl: null, tinyViewableUrl: null,
+      });
+
+      const event = { data: { [ThumbnailUtil.NEW_THUMBNAIL_ID]: '/rest/thumbnail/café-logo.jpg' } };
+      await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', event, entityName: 'item' });
+
+      expect(mockGetRequest).toHaveBeenCalledWith({
+        urlPath: '/rest/thumbnail/caf%C3%A9-logo.jpg',
+        includeUrlContext: false,
+        returnFullResponse: true,
+      });
+      expect(mockContentCreate).toHaveBeenCalledWith(
+        expect.objectContaining({ fileName: 'café-logo.jpg' }),
+      );
+    });
+
+    it('replaces content when primaryViewable.flexplmThumbnailUrl differs and updates entity', 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: { [ThumbnailUtil.NEW_THUMBNAIL_ID]: '/rest/thumbnail/new.jpg' } };
+      await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', primaryViewableId: 'oldPv', event, entityName: 'item' });
+
+      // Creates new content
+      expect(mockContentCreate).toHaveBeenCalled();
+      // Updates new content with flexplmThumbnailUrl
+      expect(mockEntitiesUpdate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          entityName: 'content',
+          id: 'newContent2',
+          object: { flexplmThumbnailUrl: '/rest/thumbnail/new.jpg' },
+        }),
+      );
+      // Updates the main entity
+      expect(mockEntitiesUpdate).toHaveBeenCalledWith(
+        expect.objectContaining({ entityName: 'item', id: 'entity1' }),
+      );
+      // Deletes old content
+      expect(mockEntitiesDelete).toHaveBeenCalledWith({ entityName: 'content', id: 'oldPv' });
+    });
+
+    it('does not update 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: { [ThumbnailUtil.EXISTING_THUMBNAIL_ID]: thumbnailUrl } };
+      await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', primaryViewableId: 'pv1', event, entityName: 'color' });
+      expect(mockContentCreate).not.toHaveBeenCalled();
+      expect(mockEntitiesUpdate).not.toHaveBeenCalled();
+      expect(mockEntitiesDelete).not.toHaveBeenCalled();
+    });
+  });
+});