@thoughtspot/visual-embed-sdk 1.50.0 → 1.51.0-test

package/src/utils/processData.spec.ts

@@ -80,6 +80,11 @@ describe('Unit test for process data', () => {
         );
     });
 
+    test('ProcessData QueryChanged default branch returns payload unchanged', () => {
+        const e = { type: EmbedEvent.QueryChanged, data: { query: 'revenue by region' } };
+        expect(processDataInstance.processEventData(EmbedEvent.QueryChanged, e, thoughtSpotHost, null)).toEqual(e);
+    });
+
     test('ProcessData, when Action is non CustomAction', () => {
         const processedData = { type: EmbedEvent.Data };
         jest.spyOn(processDataInstance, 'processCustomAction').mockImplementation(async () => ({}));
@@ -311,6 +316,98 @@ describe('Unit test for process data', () => {
         expect(base.notifyAuthFailure).not.toHaveBeenCalled();
     });
 
+    test('processEventData default branch returns payload unchanged for non-special events', () => {
+        const events = [
+            EmbedEvent.Drilldown,
+            EmbedEvent.DataSourceSelected,
+            EmbedEvent.AddRemoveColumns,
+            EmbedEvent.VizPointDoubleClick,
+            EmbedEvent.VizPointClick,
+            EmbedEvent.Alert,
+            EmbedEvent.GetDataClick,
+            EmbedEvent.DialogClose,
+            EmbedEvent.Download,
+            EmbedEvent.DownloadAsPng,
+            EmbedEvent.DownloadAsPdf,
+            EmbedEvent.DownloadAsCsv,
+            EmbedEvent.DownloadAsXlsx,
+            EmbedEvent.DownloadLiveboardAsContinuousPDF,
+            EmbedEvent.AnswerDelete,
+            EmbedEvent.AIHighlights,
+            EmbedEvent.Pin,
+            EmbedEvent.SpotIQAnalyze,
+            EmbedEvent.Share,
+            EmbedEvent.DrillInclude,
+            EmbedEvent.DrillExclude,
+            EmbedEvent.CopyToClipboard,
+            EmbedEvent.UpdateTML,
+            EmbedEvent.EditTML,
+            EmbedEvent.ExportTML,
+            EmbedEvent.SaveAsView,
+            EmbedEvent.CopyAEdit,
+            EmbedEvent.ShowUnderlyingData,
+            EmbedEvent.AnswerChartSwitcher,
+            EmbedEvent.LiveboardInfo,
+            EmbedEvent.AddToFavorites,
+            EmbedEvent.Schedule,
+            EmbedEvent.Edit,
+            EmbedEvent.MakeACopy,
+            EmbedEvent.Present,
+            EmbedEvent.Delete,
+            EmbedEvent.SchedulesList,
+            EmbedEvent.Cancel,
+            EmbedEvent.Explore,
+            EmbedEvent.CopyLink,
+            EmbedEvent.CrossFilterChanged,
+            EmbedEvent.VizPointRightClick,
+            EmbedEvent.InsertIntoSlide,
+            EmbedEvent.FilterChanged,
+            EmbedEvent.UpdateConnection,
+            EmbedEvent.CreateConnection,
+            EmbedEvent.ResetLiveboard,
+            EmbedEvent.ChangePersonalizedView,
+            EmbedEvent.CreateWorksheet,
+            EmbedEvent.AskSageInit,
+            EmbedEvent.Rename,
+            EmbedEvent.ParameterChanged,
+            EmbedEvent.TableVizRendered,
+            EmbedEvent.CreateLiveboard,
+            EmbedEvent.CreateModel,
+            EmbedEvent.SpotterData,
+            EmbedEvent.PreviewSpotterData,
+            EmbedEvent.AddToCoaching,
+            EmbedEvent.DataModelInstructions,
+            EmbedEvent.SpotterQueryTriggered,
+            EmbedEvent.LastPromptEdited,
+            EmbedEvent.LastPromptDeleted,
+            EmbedEvent.ResetSpotterConversation,
+            EmbedEvent.SpotterInit,
+            EmbedEvent.SpotterLoadComplete,
+            EmbedEvent.OrgSwitched,
+            EmbedEvent.SpotterConversationRenamed,
+            EmbedEvent.SpotterConversationDeleted,
+            EmbedEvent.SpotterConversationSelected,
+            EmbedEvent.EmbedPageContextChanged,
+            EmbedEvent.Subscribed,
+            EmbedEvent.SendTestScheduleEmail,
+            EmbedEvent.SpotterVizInit,
+            EmbedEvent.SpotterVizQueryTriggered,
+            EmbedEvent.SpotterVizResponseComplete,
+            EmbedEvent.SpotterVizCheckpointCreated,
+            EmbedEvent.SpotterVizCheckpointRestored,
+            EmbedEvent.SpotterVizError,
+            EmbedEvent.SpotterVizClosed,
+            EmbedEvent.RefreshLiveboardBrowserCache,
+            EmbedEvent.V1Data,
+        ];
+        events.forEach((eventType) => {
+            const e = { type: eventType, data: 'test-payload' };
+            expect(
+                processDataInstance.processEventData(eventType, e, thoughtSpotHost, null),
+            ).toEqual(e);
+        });
+    });
+
     test('should handle ClearInfoCache', () => {
         const mockResetCachedPreauthInfo = jest.spyOn(sessionInfoService, 'resetCachedPreauthInfo').mockImplementation(() => {});
         const mockResetCachedSessionInfo = jest.spyOn(sessionInfoService, 'resetCachedSessionInfo').mockImplementation(() => {});

package/src/utils/processTrigger.spec.ts

@@ -216,5 +216,96 @@ describe('Unit test for processTrigger', () => {
                 'Fullscreen presentation mode is disabled. Set disableFullscreenPresentation: false to enable this feature.',
             );
         });
+
+        test('postMessage is called with type=present when disableFullscreenPresentation is false', () => {
+            mockGetEmbedConfig.mockReturnValue({ disableFullscreenPresentation: false });
+            const thoughtSpotHost = 'https://example.thoughtspot.com';
+            _processTriggerInstance.processTrigger(iFrame, HostEvent.Present, thoughtSpotHost, {});
+            expect(iFrame.contentWindow.postMessage).toHaveBeenCalledWith(
+                expect.objectContaining({ type: HostEvent.Present }),
+                thoughtSpotHost,
+                expect.anything(),
+            );
+        });
+
+        test('postMessage is still called with type=present when disableFullscreenPresentation is true', () => {
+            mockGetEmbedConfig.mockReturnValue({ disableFullscreenPresentation: true });
+            const thoughtSpotHost = 'https://example.thoughtspot.com';
+            _processTriggerInstance.processTrigger(iFrame, HostEvent.Present, thoughtSpotHost, {});
+            expect(iFrame.contentWindow.postMessage).toHaveBeenCalledWith(
+                expect.objectContaining({ type: HostEvent.Present }),
+                thoughtSpotHost,
+                expect.anything(),
+            );
+        });
+
+        test('handlePresentEvent receives the exact iFrame reference passed to processTrigger', () => {
+            mockGetEmbedConfig.mockReturnValue({ disableFullscreenPresentation: false });
+            _processTriggerInstance.processTrigger(
+                iFrame, HostEvent.Present, 'https://example.thoughtspot.com', {},
+            );
+            expect(mockHandlePresentEvent).toHaveBeenCalledWith(iFrame);
+        });
+    });
+
+    test('nested responseData.data.error causes promise rejection', async () => {
+        const messageType = HostEvent.Search;
+        const thoughtSpotHost = 'http://localhost:3000';
+        mockMessageChannel();
+        const triggerPromise = _processTriggerInstance.processTrigger(
+            iFrame, messageType, thoughtSpotHost, {},
+        );
+        messageChannelMock.port1.onmessage({ data: { data: { error: 'nested-error' } } });
+        await expect(triggerPromise).rejects.toEqual('nested-error');
+    });
+
+    test('context parameter is forwarded as context field in the postMessage payload', async () => {
+        const messageType = HostEvent.Search;
+        const thoughtSpotHost = 'http://localhost:3000';
+        const context = 'Liveboard' as any;
+        mockMessageChannel();
+        _processTriggerInstance.processTrigger(iFrame, messageType, thoughtSpotHost, {}, context);
+        expect(iFrame.contentWindow.postMessage).toHaveBeenCalledWith(
+            expect.objectContaining({ context }),
+            thoughtSpotHost,
+            expect.anything(),
+        );
+    });
+
+    describe('Reload timing and side-effects', () => {
+        test('src is cleared immediately but not restored until exactly 100ms', () => {
+            jest.useFakeTimers();
+            const iFrameElement = document.createElement('iframe');
+            iFrameElement.src = 'http://localhost:3000';
+            const originalSrc = iFrameElement.src; // normalized by jsdom
+
+            _processTriggerInstance.reload(iFrameElement);
+
+            expect(iFrameElement.src).not.toBe(originalSrc); // cleared
+            jest.advanceTimersByTime(99);
+            expect(iFrameElement.src).not.toBe(originalSrc); // not yet restored
+            jest.advanceTimersByTime(1);
+            expect(iFrameElement.src).toBe(originalSrc); // restored at 100ms
+            jest.useRealTimers();
+        });
+
+        test('processTrigger(Reload) does not call iFrame.contentWindow.postMessage', () => {
+            jest.useFakeTimers();
+            // Use the outer iFrame mock which has a mockable contentWindow
+            jest.clearAllMocks();
+            _processTriggerInstance.processTrigger(
+                iFrame, HostEvent.Reload, 'http://localhost:3000', {},
+            );
+            jest.advanceTimersByTime(200);
+            expect(iFrame.contentWindow.postMessage).not.toHaveBeenCalled();
+            jest.useRealTimers();
+        });
+
+        test('processTrigger(Reload) resolves with null', async () => {
+            const result = await _processTriggerInstance.processTrigger(
+                iFrame, HostEvent.Reload, 'http://localhost:3000', {},
+            );
+            expect(result).toBeNull();
+        });
     });
 });

package/src/utils.spec.ts

@@ -37,6 +37,7 @@ import {
 } from './utils';
 import { RuntimeFilterOp } from './types';
 import { logger } from './utils/logger';
+import { DEFAULT_LAZY_LOADING_MARGIN } from './config';
 import { ERROR_MESSAGE } from './errors';
 
 // Mock logger
@@ -1029,6 +1030,10 @@ describe('isValidCssMargin', () => {
         expect(isValidCssMargin('10')).toBe(false); // missing unit
     });
 
+    it('should accept DEFAULT_LAZY_LOADING_MARGIN', () => {
+        expect(isValidCssMargin(DEFAULT_LAZY_LOADING_MARGIN)).toBe(true);
+    });
+
     it('should return false and log error when value is not a string (non-string type)', () => {
         // Covers line 147-148: typeof value !== 'string' branch
         expect(isValidCssMargin(42 as any)).toBe(false);