@thoughtspot/visual-embed-sdk 1.50.0 → 1.50.1

package/src/embed/events.spec.ts

@@ -64,6 +64,24 @@ describe('test communication between host app and ThoughtSpot', () => {
         });
     });
 
+    test('should capture SpotterResponseComplete event from ThoughtSpot app', (done) => {
+        const appEmbed = new AppEmbed(getRootEl(), defaultViewConfig);
+        appEmbed
+            .on(EmbedEvent.SpotterResponseComplete, (data) => {
+                expect(data.data).toEqual({ convId: 'c1', messageId: 'm1' });
+                done();
+            })
+            .render();
+
+        executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            postMessageToParent(iframe.contentWindow, {
+                type: EmbedEvent.SpotterResponseComplete,
+                data: { convId: 'c1', messageId: 'm1' },
+            });
+        });
+    });
+
     // TODO: enable test once we are actually able to load stuff in the iframe
     xtest('should trigger iframe load event', async () => {
         const onLoadSpy = jest.fn();
@@ -324,6 +342,42 @@ describe('test communication between host app and ThoughtSpot', () => {
         }, EVENT_WAIT_TIME);
     });
 
+    test('should fire QueryChanged handler when {type:queryChanged} postMessage arrives from iframe', async () => {
+        const handler = jest.fn();
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        searchEmbed.on(EmbedEvent.QueryChanged, handler).render();
+
+        await executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            postMessageToParent(iframe.contentWindow, {
+                type: EmbedEvent.QueryChanged,
+                data: PAYLOAD,
+            });
+        });
+
+        await executeAfterWait(() => {
+            expect(handler).toHaveBeenCalled();
+            expect(handler.mock.calls[0][0].data).toBe(PAYLOAD);
+        }, EVENT_WAIT_TIME);
+    });
+
+    test('should not fire QueryChanged handler for postMessage from non-iframe source', async () => {
+        const handler = jest.fn();
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        searchEmbed.on(EmbedEvent.QueryChanged, handler).render();
+
+        await executeAfterWait(() => {
+            postMessageToParent(window, {
+                type: EmbedEvent.QueryChanged,
+                data: PAYLOAD,
+            });
+        });
+
+        await executeAfterWait(() => {
+            expect(handler).not.toHaveBeenCalled();
+        }, EVENT_WAIT_TIME);
+    });
+
     test('ALL event listener should fire for all events with the event type set correctly', async () => {
         const embed = new AppEmbed(getRootEl(), defaultViewConfig);
         const spy = jest.fn();
@@ -376,8 +430,658 @@ describe('Americanized enum alias values', () => {
 });
 
 describe('Action enum values', () => {
-   
+
     test('RemoveFromFavorites should resolve to its string value', () => {
         expect(Action.RemoveFromFavorites).toBe('removeFromFavorites');
     });
 });
+
+describe('EmbedEvent basic routing', () => {
+    beforeEach(() => {
+        document.body.innerHTML = getDocumentBody();
+    });
+
+    const UNCOVERED_EVENTS: Array<[string, EmbedEvent]> = [
+        ['Drilldown', EmbedEvent.Drilldown],
+        ['DataSourceSelected', EmbedEvent.DataSourceSelected],
+        ['AddRemoveColumns', EmbedEvent.AddRemoveColumns],
+        ['VizPointDoubleClick', EmbedEvent.VizPointDoubleClick],
+        ['VizPointClick', EmbedEvent.VizPointClick],
+        ['Alert', EmbedEvent.Alert],
+        ['GetDataClick', EmbedEvent.GetDataClick],
+        ['DialogClose', EmbedEvent.DialogClose],
+        ['Download', EmbedEvent.Download],
+        ['DownloadAsPng', EmbedEvent.DownloadAsPng],
+        ['DownloadAsPdf', EmbedEvent.DownloadAsPdf],
+        ['DownloadAsCsv', EmbedEvent.DownloadAsCsv],
+        ['DownloadAsXlsx', EmbedEvent.DownloadAsXlsx],
+        ['DownloadLiveboardAsContinuousPDF', EmbedEvent.DownloadLiveboardAsContinuousPDF],
+        ['AnswerDelete', EmbedEvent.AnswerDelete],
+        ['AIHighlights', EmbedEvent.AIHighlights],
+        ['Pin', EmbedEvent.Pin],
+        ['SpotIQAnalyze', EmbedEvent.SpotIQAnalyze],
+        ['Share', EmbedEvent.Share],
+        ['DrillInclude', EmbedEvent.DrillInclude],
+        ['DrillExclude', EmbedEvent.DrillExclude],
+        ['CopyToClipboard', EmbedEvent.CopyToClipboard],
+        ['UpdateTML', EmbedEvent.UpdateTML],
+        ['EditTML', EmbedEvent.EditTML],
+        ['ExportTML', EmbedEvent.ExportTML],
+        ['SaveAsView', EmbedEvent.SaveAsView],
+        ['CopyAEdit', EmbedEvent.CopyAEdit],
+        ['ShowUnderlyingData', EmbedEvent.ShowUnderlyingData],
+        ['AnswerChartSwitcher', EmbedEvent.AnswerChartSwitcher],
+        ['LiveboardInfo', EmbedEvent.LiveboardInfo],
+        ['AddToFavorites', EmbedEvent.AddToFavorites],
+        ['Schedule', EmbedEvent.Schedule],
+        ['Edit', EmbedEvent.Edit],
+        ['MakeACopy', EmbedEvent.MakeACopy],
+        ['Present', EmbedEvent.Present],
+        ['Delete', EmbedEvent.Delete],
+        ['SchedulesList', EmbedEvent.SchedulesList],
+        ['Cancel', EmbedEvent.Cancel],
+        ['Explore', EmbedEvent.Explore],
+        ['CopyLink', EmbedEvent.CopyLink],
+        ['CrossFilterChanged', EmbedEvent.CrossFilterChanged],
+        ['VizPointRightClick', EmbedEvent.VizPointRightClick],
+        ['InsertIntoSlide', EmbedEvent.InsertIntoSlide],
+        ['FilterChanged', EmbedEvent.FilterChanged],
+        ['UpdateConnection', EmbedEvent.UpdateConnection],
+        ['CreateConnection', EmbedEvent.CreateConnection],
+        ['ResetLiveboard', EmbedEvent.ResetLiveboard],
+        ['ChangePersonalizedView', EmbedEvent.ChangePersonalizedView],
+        ['CreateWorksheet', EmbedEvent.CreateWorksheet],
+        ['AskSageInit', EmbedEvent.AskSageInit],
+        ['Rename', EmbedEvent.Rename],
+        ['ParameterChanged', EmbedEvent.ParameterChanged],
+        ['TableVizRendered', EmbedEvent.TableVizRendered],
+        ['CreateLiveboard', EmbedEvent.CreateLiveboard],
+        ['CreateModel', EmbedEvent.CreateModel],
+        ['SpotterData', EmbedEvent.SpotterData],
+        ['PreviewSpotterData', EmbedEvent.PreviewSpotterData],
+        ['AddToCoaching', EmbedEvent.AddToCoaching],
+        ['DataModelInstructions', EmbedEvent.DataModelInstructions],
+        ['SpotterQueryTriggered', EmbedEvent.SpotterQueryTriggered],
+        ['LastPromptEdited', EmbedEvent.LastPromptEdited],
+        ['LastPromptDeleted', EmbedEvent.LastPromptDeleted],
+        ['ResetSpotterConversation', EmbedEvent.ResetSpotterConversation],
+        ['SpotterInit', EmbedEvent.SpotterInit],
+        ['SpotterLoadComplete', EmbedEvent.SpotterLoadComplete],
+        ['OrgSwitched', EmbedEvent.OrgSwitched],
+        ['SpotterConversationRenamed', EmbedEvent.SpotterConversationRenamed],
+        ['SpotterConversationDeleted', EmbedEvent.SpotterConversationDeleted],
+        ['SpotterConversationSelected', EmbedEvent.SpotterConversationSelected],
+        ['EmbedPageContextChanged', EmbedEvent.EmbedPageContextChanged],
+        ['Subscribed', EmbedEvent.Subscribed],
+        ['SendTestScheduleEmail', EmbedEvent.SendTestScheduleEmail],
+        ['SpotterVizInit', EmbedEvent.SpotterVizInit],
+        ['SpotterVizQueryTriggered', EmbedEvent.SpotterVizQueryTriggered],
+        ['SpotterVizResponseComplete', EmbedEvent.SpotterVizResponseComplete],
+        ['SpotterVizCheckpointCreated', EmbedEvent.SpotterVizCheckpointCreated],
+        ['SpotterVizCheckpointRestored', EmbedEvent.SpotterVizCheckpointRestored],
+        ['SpotterVizError', EmbedEvent.SpotterVizError],
+        ['SpotterVizClosed', EmbedEvent.SpotterVizClosed],
+        ['RefreshLiveboardBrowserCache', EmbedEvent.RefreshLiveboardBrowserCache],
+        ['V1Data', EmbedEvent.V1Data],
+    ];
+
+    test.each(UNCOVERED_EVENTS)(
+        '%s handler fires on iframe postMessage',
+        async (eventName, embedEvent) => {
+            const handler = jest.fn();
+            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+            searchEmbed.on(embedEvent, handler).render();
+
+            await executeAfterWait(() => {
+                const iframe = getIFrameEl();
+                postMessageToParent(iframe.contentWindow, {
+                    type: embedEvent,
+                    data: PAYLOAD,
+                });
+            });
+
+            await executeAfterWait(() => {
+                expect(handler).toHaveBeenCalled();
+                expect(handler.mock.calls[0][0].data).toBe(PAYLOAD);
+            }, EVENT_WAIT_TIME);
+        },
+    );
+});
+
+describe('EmbedEvent start/end status', () => {
+    beforeEach(() => {
+        document.body.innerHTML = getDocumentBody();
+    });
+
+    const START_END_EVENTS: Array<[string, EmbedEvent]> = [
+        ['DownloadAsPng', EmbedEvent.DownloadAsPng],
+        ['DownloadAsPdf', EmbedEvent.DownloadAsPdf],
+        ['DownloadAsCsv', EmbedEvent.DownloadAsCsv],
+        ['DownloadAsXlsx', EmbedEvent.DownloadAsXlsx],
+        ['AnswerDelete', EmbedEvent.AnswerDelete],
+        ['Pin', EmbedEvent.Pin],
+        ['SpotIQAnalyze', EmbedEvent.SpotIQAnalyze],
+        ['Share', EmbedEvent.Share],
+        ['ExportTML', EmbedEvent.ExportTML],
+        ['CopyAEdit', EmbedEvent.CopyAEdit],
+    ];
+
+    test.each(START_END_EVENTS)(
+        '%s start handler fires on START, not END',
+        async (eventName, embedEvent) => {
+            const startHandler = jest.fn();
+            const endHandler = jest.fn();
+            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+            searchEmbed
+                .on(embedEvent, startHandler, { start: true })
+                .on(embedEvent, endHandler)
+                .render();
+
+            await executeAfterWait(() => {
+                const iframe = getIFrameEl();
+                postMessageToParent(iframe.contentWindow, {
+                    type: embedEvent,
+                    data: PAYLOAD,
+                    status: 'start',
+                });
+            });
+
+            await executeAfterWait(() => {
+                expect(startHandler).toHaveBeenCalled();
+                expect(endHandler).not.toHaveBeenCalled();
+            }, EVENT_WAIT_TIME);
+        },
+    );
+
+    test.each(START_END_EVENTS)(
+        '%s end handler fires on END, not START',
+        async (eventName, embedEvent) => {
+            const startHandler = jest.fn();
+            const endHandler = jest.fn();
+            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+            searchEmbed
+                .on(embedEvent, startHandler, { start: true })
+                .on(embedEvent, endHandler)
+                .render();
+
+            await executeAfterWait(() => {
+                const iframe = getIFrameEl();
+                postMessageToParent(iframe.contentWindow, {
+                    type: embedEvent,
+                    data: PAYLOAD,
+                    status: 'end',
+                });
+            });
+
+            await executeAfterWait(() => {
+                expect(endHandler).toHaveBeenCalled();
+                expect(startHandler).not.toHaveBeenCalled();
+            }, EVENT_WAIT_TIME);
+        },
+    );
+
+    const END_ONLY_EVENTS: Array<[string, EmbedEvent]> = [
+        ['Download', EmbedEvent.Download],
+        ['DownloadLiveboardAsContinuousPDF', EmbedEvent.DownloadLiveboardAsContinuousPDF],
+    ];
+
+    test.each(END_ONLY_EVENTS)(
+        '%s ignores start handler (end-only event)',
+        async (eventName, embedEvent) => {
+            const startHandler = jest.fn();
+            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+            searchEmbed.on(embedEvent, startHandler, { start: true }).render();
+
+            await executeAfterWait(() => {
+                const iframe = getIFrameEl();
+                postMessageToParent(iframe.contentWindow, {
+                    type: embedEvent,
+                    data: PAYLOAD,
+                });
+            });
+
+            await executeAfterWait(() => {
+                expect(startHandler).not.toHaveBeenCalled();
+            }, EVENT_WAIT_TIME);
+        },
+    );
+});
+
+describe('EmbedEvent payload and routing', () => {
+    beforeEach(() => {
+        document.body.innerHTML = getDocumentBody();
+    });
+
+    test('Drilldown payload includes additionalFilters, drillDownColumns, nonFilteredColumns', async () => {
+        const handler = jest.fn();
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        searchEmbed.on(EmbedEvent.Drilldown, handler).render();
+
+        const drilldownData = {
+            additionalFilters: [{ column: 'region', value: 'west' }],
+            drillDownColumns: ['revenue'],
+            nonFilteredColumns: ['date'],
+        };
+
+        await executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            postMessageToParent(iframe.contentWindow, {
+                type: EmbedEvent.Drilldown,
+                data: drilldownData,
+            });
+        });
+
+        await executeAfterWait(() => {
+            expect(handler).toHaveBeenCalled();
+            const received = handler.mock.calls[0][0].data;
+            expect(received.additionalFilters).toEqual(drilldownData.additionalFilters);
+            expect(received.drillDownColumns).toEqual(drilldownData.drillDownColumns);
+            expect(received.nonFilteredColumns).toEqual(drilldownData.nonFilteredColumns);
+        }, EVENT_WAIT_TIME);
+    });
+
+    test('DataSourceSelected payload contains dataSourceIds array', async () => {
+        const handler = jest.fn();
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        searchEmbed.on(EmbedEvent.DataSourceSelected, handler).render();
+
+        const dataSourceIds = ['ds-aaa', 'ds-bbb'];
+
+        await executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            postMessageToParent(iframe.contentWindow, {
+                type: EmbedEvent.DataSourceSelected,
+                data: { dataSourceIds },
+            });
+        });
+
+        await executeAfterWait(() => {
+            expect(handler).toHaveBeenCalled();
+            expect(handler.mock.calls[0][0].data.dataSourceIds).toEqual(dataSourceIds);
+        }, EVENT_WAIT_TIME);
+    });
+
+    test('V1Data fires via __type field when type is absent', async () => {
+        const handler = jest.fn();
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        searchEmbed.on(EmbedEvent.V1Data, handler).render();
+
+        await executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            postMessageToParent(iframe.contentWindow, {
+                __type: EmbedEvent.V1Data,
+                data: PAYLOAD,
+            });
+        });
+
+        await executeAfterWait(() => {
+            expect(handler).toHaveBeenCalled();
+        }, EVENT_WAIT_TIME);
+    });
+
+    test('subscribedEvent builds composed key and routes to registered handler', async () => {
+        const handler = jest.fn();
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        const composedEvent = searchEmbed.subscribedEvent(HostEvent.Save);
+
+        expect(composedEvent).toBe(`${HostEvent.Save} ${EmbedEvent.Subscribed}`);
+
+        searchEmbed.on(composedEvent as any, handler).render();
+
+        await executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            postMessageToParent(iframe.contentWindow, {
+                type: composedEvent,
+                data: PAYLOAD,
+            });
+        });
+
+        await executeAfterWait(() => {
+            expect(handler).toHaveBeenCalled();
+        }, EVENT_WAIT_TIME);
+    });
+
+    test('non-iframe postMessage does not trigger registered handler', async () => {
+        const handler = jest.fn();
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        searchEmbed.on(EmbedEvent.Drilldown, handler).render();
+
+        await executeAfterWait(() => {
+            postMessageToParent(window, {
+                type: EmbedEvent.Drilldown,
+                data: PAYLOAD,
+            });
+        });
+
+        await executeAfterWait(() => {
+            expect(handler).not.toHaveBeenCalled();
+        }, EVENT_WAIT_TIME);
+    });
+
+    test('DataSourceSelected falls back to payload field when data is absent', async () => {
+        const handler = jest.fn();
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        searchEmbed.on(EmbedEvent.DataSourceSelected, handler).render();
+
+        const dataSourceIds = ['ds-fallback'];
+
+        await executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            postMessageToParent(iframe.contentWindow, {
+                type: EmbedEvent.DataSourceSelected,
+                payload: { dataSourceIds },
+                // no data field — formatEventData should copy payload → data
+            });
+        });
+
+        await executeAfterWait(() => {
+            expect(handler).toHaveBeenCalled();
+            expect(handler.mock.calls[0][0].data.dataSourceIds).toEqual(dataSourceIds);
+        }, EVENT_WAIT_TIME);
+    });
+
+    test('Alert handler fires independently of window.alert', async () => {
+        const alertSpy = jest.spyOn(window, 'alert').mockImplementation(() => undefined);
+        const handler = jest.fn();
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        searchEmbed.on(EmbedEvent.Alert, handler).render();
+
+        await executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            postMessageToParent(iframe.contentWindow, {
+                type: EmbedEvent.Alert,
+                data: { message: 'test alert' },
+            });
+        });
+
+        await executeAfterWait(() => {
+            expect(handler).toHaveBeenCalled();
+            expect(alertSpy).not.toHaveBeenCalled();
+        }, EVENT_WAIT_TIME);
+
+        alertSpy.mockRestore();
+    });
+
+    test('Share reaches EmbedEvent.ALL wildcard handler', async () => {
+        const allHandler = jest.fn();
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        searchEmbed.on(EmbedEvent.ALL, allHandler).render();
+
+        await executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            postMessageToParent(iframe.contentWindow, {
+                type: EmbedEvent.Share,
+                data: PAYLOAD,
+            });
+        });
+
+        await executeAfterWait(() => {
+            const types = allHandler.mock.calls.map((c) => c[0].type);
+            expect(types).toContain(EmbedEvent.Share);
+        }, EVENT_WAIT_TIME);
+    });
+
+    test('DialogClose reaches EmbedEvent.ALL wildcard handler', async () => {
+        const allHandler = jest.fn();
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        searchEmbed.on(EmbedEvent.ALL, allHandler).render();
+
+        await executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            postMessageToParent(iframe.contentWindow, {
+                type: EmbedEvent.DialogClose,
+                data: PAYLOAD,
+            });
+        });
+
+        await executeAfterWait(() => {
+            const types = allHandler.mock.calls.map((c) => c[0].type);
+            expect(types).toContain(EmbedEvent.DialogClose);
+        }, EVENT_WAIT_TIME);
+    });
+
+    test('SpotterConversationRenamed payload contains convId, oldTitle, newTitle', async () => {
+        const handler = jest.fn();
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        searchEmbed.on(EmbedEvent.SpotterConversationRenamed, handler).render();
+
+        const convData = { convId: 'conv-1', oldTitle: 'Old', newTitle: 'New' };
+
+        await executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            postMessageToParent(iframe.contentWindow, {
+                type: EmbedEvent.SpotterConversationRenamed,
+                data: convData,
+            });
+        });
+
+        await executeAfterWait(() => {
+            expect(handler).toHaveBeenCalled();
+            expect(handler.mock.calls[0][0].data).toMatchObject(convData);
+        }, EVENT_WAIT_TIME);
+    });
+
+    test('SpotterConversationDeleted payload contains convId and title', async () => {
+        const handler = jest.fn();
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        searchEmbed.on(EmbedEvent.SpotterConversationDeleted, handler).render();
+
+        const convData = { convId: 'conv-2', title: 'My Conversation' };
+
+        await executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            postMessageToParent(iframe.contentWindow, {
+                type: EmbedEvent.SpotterConversationDeleted,
+                data: convData,
+            });
+        });
+
+        await executeAfterWait(() => {
+            expect(handler).toHaveBeenCalled();
+            expect(handler.mock.calls[0][0].data).toMatchObject(convData);
+        }, EVENT_WAIT_TIME);
+    });
+
+    test('SpotterConversationSelected payload contains convId, title, worksheetId', async () => {
+        const handler = jest.fn();
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        searchEmbed.on(EmbedEvent.SpotterConversationSelected, handler).render();
+
+        const convData = { convId: 'conv-3', title: 'My Conv', worksheetId: 'ws-1' };
+
+        await executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            postMessageToParent(iframe.contentWindow, {
+                type: EmbedEvent.SpotterConversationSelected,
+                data: convData,
+            });
+        });
+
+        await executeAfterWait(() => {
+            expect(handler).toHaveBeenCalled();
+            expect(handler.mock.calls[0][0].data).toMatchObject(convData);
+        }, EVENT_WAIT_TIME);
+    });
+
+    test('TableVizRendered payload forwards columnDataLite array intact', async () => {
+        const handler = jest.fn();
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        searchEmbed.on(EmbedEvent.TableVizRendered, handler).render();
+
+        const columnDataLite = [['col1', 'col2'], ['val1', 'val2']];
+
+        await executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            postMessageToParent(iframe.contentWindow, {
+                type: EmbedEvent.TableVizRendered,
+                data: { data: { columnDataLite } },
+            });
+        });
+
+        await executeAfterWait(() => {
+            expect(handler).toHaveBeenCalled();
+            expect(handler.mock.calls[0][0].data.data.columnDataLite).toEqual(columnDataLite);
+        }, EVENT_WAIT_TIME);
+    });
+
+    test('SendTestScheduleEmail payload preserves liveboardId and sendToSelf boolean', async () => {
+        const handler = jest.fn();
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        searchEmbed.on(EmbedEvent.SendTestScheduleEmail, handler).render();
+
+        const emailData = { liveboardId: 'lb-123', sendToSelf: true };
+
+        await executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            postMessageToParent(iframe.contentWindow, {
+                type: EmbedEvent.SendTestScheduleEmail,
+                data: emailData,
+            });
+        });
+
+        await executeAfterWait(() => {
+            expect(handler).toHaveBeenCalled();
+            const received = handler.mock.calls[0][0].data;
+            expect(received.liveboardId).toBe('lb-123');
+            expect(received.sendToSelf).toBe(true);
+            expect(typeof received.sendToSelf).toBe('boolean');
+        }, EVENT_WAIT_TIME);
+    });
+
+    test('ChangePersonalizedView payload viewId can be null (reset-to-default)', async () => {
+        const handler = jest.fn();
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        searchEmbed.on(EmbedEvent.ChangePersonalizedView, handler).render();
+
+        await executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            postMessageToParent(iframe.contentWindow, {
+                type: EmbedEvent.ChangePersonalizedView,
+                data: { viewId: null, viewName: 'Original View', liveboardId: 'lb-1', isPublic: false },
+            });
+        });
+
+        await executeAfterWait(() => {
+            expect(handler).toHaveBeenCalled();
+            expect(handler.mock.calls[0][0].data.viewId).toBeNull();
+            expect(handler.mock.calls[0][0].data.viewName).toBe('Original View');
+        }, EVENT_WAIT_TIME);
+    });
+
+    test('VizPointDoubleClick payload exposes vizId and clickedPoint.selectedPoints', async () => {
+        const handler = jest.fn();
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        searchEmbed.on(EmbedEvent.VizPointDoubleClick, handler).render();
+
+        const pointData = {
+            vizId: 'viz-1',
+            clickedPoint: { selectedPoints: [{ x: 10, y: 20 }] },
+        };
+
+        await executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            postMessageToParent(iframe.contentWindow, {
+                type: EmbedEvent.VizPointDoubleClick,
+                data: pointData,
+            });
+        });
+
+        await executeAfterWait(() => {
+            expect(handler).toHaveBeenCalled();
+            const { data } = handler.mock.calls[0][0];
+            expect(data.vizId).toBe('viz-1');
+            expect(data.clickedPoint.selectedPoints).toEqual(pointData.clickedPoint.selectedPoints);
+        }, EVENT_WAIT_TIME);
+    });
+
+    test('VizPointClick payload exposes vizId, selectedAttributes and selectedMeasures', async () => {
+        const handler = jest.fn();
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        searchEmbed.on(EmbedEvent.VizPointClick, handler).render();
+
+        const pointData = {
+            vizId: 'viz-2',
+            clickedPoint: {
+                selectedAttributes: [{ value: 'West', column: { name: 'region' } }],
+                selectedMeasures: [{ value: 42, column: { name: 'revenue' } }],
+            },
+        };
+
+        await executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            postMessageToParent(iframe.contentWindow, {
+                type: EmbedEvent.VizPointClick,
+                data: pointData,
+            });
+        });
+
+        await executeAfterWait(() => {
+            expect(handler).toHaveBeenCalled();
+            const { data } = handler.mock.calls[0][0];
+            expect(data.vizId).toBe('viz-2');
+            expect(data.clickedPoint.selectedAttributes[0].value).toBe('West');
+            expect(data.clickedPoint.selectedAttributes[0].column.name).toBe('region');
+            expect(data.clickedPoint.selectedMeasures[0].value).toBe(42);
+            expect(data.clickedPoint.selectedMeasures[0].column.name).toBe('revenue');
+        }, EVENT_WAIT_TIME);
+    });
+
+    test('SpotterVizError reaches EmbedEvent.ALL handler', async () => {
+        const allHandler = jest.fn();
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        searchEmbed.on(EmbedEvent.ALL, allHandler).render();
+
+        await executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            postMessageToParent(iframe.contentWindow, {
+                type: EmbedEvent.SpotterVizError,
+                data: PAYLOAD,
+            });
+        });
+
+        await executeAfterWait(() => {
+            const types = allHandler.mock.calls.map((c) => c[0].type);
+            expect(types).toContain(EmbedEvent.SpotterVizError);
+        }, EVENT_WAIT_TIME);
+    });
+
+    test('SpotterVizClosed reaches EmbedEvent.ALL handler', async () => {
+        const allHandler = jest.fn();
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        searchEmbed.on(EmbedEvent.ALL, allHandler).render();
+
+        await executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            postMessageToParent(iframe.contentWindow, {
+                type: EmbedEvent.SpotterVizClosed,
+                data: PAYLOAD,
+            });
+        });
+
+        await executeAfterWait(() => {
+            const types = allHandler.mock.calls.map((c) => c[0].type);
+            expect(types).toContain(EmbedEvent.SpotterVizClosed);
+        }, EVENT_WAIT_TIME);
+    });
+
+    test('SpotterVizCheckpointRestored payload newGenNumber is a number', async () => {
+        const handler = jest.fn();
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        searchEmbed.on(EmbedEvent.SpotterVizCheckpointRestored, handler).render();
+
+        await executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            postMessageToParent(iframe.contentWindow, {
+                type: EmbedEvent.SpotterVizCheckpointRestored,
+                data: { checkpointId: 'cp-1', newGenNumber: 42 },
+            });
+        });
+
+        await executeAfterWait(() => {
+            expect(handler).toHaveBeenCalled();
+            const { newGenNumber } = handler.mock.calls[0][0].data;
+            expect(newGenNumber).toBe(42);
+            expect(typeof newGenNumber).toBe('number');
+        }, EVENT_WAIT_TIME);
+    });
+});