@thoughtspot/visual-embed-sdk 1.50.0 → 1.51.0

package/lib/src/embed/ts-embed.spec.js

@@ -1170,6 +1170,32 @@ describe('Unit test case for ts embed', () => {
             const { mockGetPreauthInfo } = await setup(true, 123);
             expect(mockGetPreauthInfo).toHaveBeenCalledTimes(0);
         });
+        test('should NOT trigger InfoSuccess when getPreauthInfo resolves with no .info field', async () => {
+            jest.spyOn(window, 'addEventListener').mockImplementationOnce((event, handler) => {
+                handler({
+                    data: { type: 'xyz' },
+                    ports: [3000],
+                    source: null,
+                });
+            });
+            mockProcessTrigger.mockResolvedValueOnce({ session: 'test' });
+            jest.spyOn(authService, 'fetchPreauthInfoService').mockResolvedValueOnce({
+                ok: true,
+                headers: new Headers({ 'content-type': 'application/json' }),
+                json: async () => ({}), // no .info field
+            });
+            const iFrame = document.createElement('div');
+            jest.spyOn(baseInstance, 'getAuthPromise').mockResolvedValueOnce(true);
+            const tsEmbed = new SearchEmbed(getRootEl(), {});
+            iFrame.contentWindow = { postMessage: jest.fn() };
+            jest.spyOn(iFrame, 'addEventListener').mockImplementationOnce((event, handler) => { handler({}); });
+            jest.spyOn(document, 'createElement').mockReturnValueOnce(iFrame);
+            await tsEmbed.render();
+            await executeAfterWait(() => {
+                const infoSuccessCall = mockProcessTrigger.mock.calls.find((call) => call[1] === HostEvent.InfoSuccess);
+                expect(infoSuccessCall).toBeUndefined();
+            });
+        });
     });
     describe('Preauth Cache for FullAppEmbed with PrimaryNavBar', () => {
         beforeAll(() => {
@@ -1893,6 +1919,43 @@ describe('Unit test case for ts embed', () => {
                 orgId: overrideOrgId,
             });
         });
+        it('Sets the overrideHistoryState param', async () => {
+            const appEmbed = new AppEmbed(getRootEl(), {
+                frameParams: {
+                    width: '100%',
+                    height: '100%',
+                },
+                overrideHistoryState: true,
+            });
+            await appEmbed.render();
+            expectUrlToHaveParamsWithValues(getIFrameSrc(), {
+                overrideHistoryState: true,
+            });
+        });
+        it('Sets the overrideHistoryState param to false', async () => {
+            const appEmbed = new AppEmbed(getRootEl(), {
+                frameParams: {
+                    width: '100%',
+                    height: '100%',
+                },
+                overrideHistoryState: false,
+            });
+            await appEmbed.render();
+            expectUrlToHaveParamsWithValues(getIFrameSrc(), {
+                overrideHistoryState: false,
+            });
+        });
+        it('Should not add overrideHistoryState param when it is undefined', async () => {
+            const appEmbed = new AppEmbed(getRootEl(), {
+                frameParams: {
+                    width: '100%',
+                    height: '100%',
+                },
+            });
+            await appEmbed.render();
+            const url = getIFrameSrc();
+            expect(url).not.toContain('overrideHistoryState');
+        });
         it('Should not add contextMenuEnabledOnWhichClick flag to the iframe src when it is not passed', async () => {
             const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
                 ...defaultViewConfig,
@@ -3723,6 +3786,20 @@ describe('Trigger method edge cases', () => {
             expect(result).toBeNull();
         });
     });
+    test('isValidationError catch: handleError called with embedErrorDetails and error is rethrown', async () => {
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        const handleErrorSpy = jest.spyOn(searchEmbed, 'handleError').mockImplementation(() => { });
+        await searchEmbed.render();
+        // First processTrigger call is getAvailableUIPassthroughKeys for DrillDown
+        mockProcessTrigger.mockResolvedValueOnce([
+            { value: { keys: Object.values(UIPassthroughEvent) } },
+        ]);
+        // DrillDown with no points → throwDrillDownValidationError → isValidationError=true
+        await expect(searchEmbed.trigger(HostEvent.DrillDown, {})).rejects.toThrow('DrillDown requires a valid points object');
+        expect(handleErrorSpy).toHaveBeenCalledWith(expect.objectContaining({
+            data: expect.objectContaining({ code: EmbedErrorCodes.HOST_EVENT_VALIDATION }),
+        }));
+    });
 });
 describe('PreRender replaceExistingPreRender scenarios', () => {
     beforeAll(() => {
@@ -3731,6 +3808,9 @@ describe('PreRender replaceExistingPreRender scenarios', () => {
             authType: AuthType.None,
         });
     });
+    beforeEach(() => {
+        document.body.innerHTML = getDocumentBody();
+    });
     afterEach(() => {
         const rootEle = document.getElementById('myRoot');
         rootEle === null || rootEle === void 0 ? void 0 : rootEle.remove();
@@ -3838,6 +3918,40 @@ describe('Fullscreen change handler behavior', () => {
             expect(mockProcessTrigger).not.toHaveBeenCalledWith(expect.any(Object), HostEvent.ExitPresentMode, expect.any(String), expect.any(Object));
         });
     });
+    test('disableFullscreenPresentation undefined defaults to true — no fullscreenchange listener registered', () => {
+        init({
+            thoughtSpotHost: 'tshost',
+            authType: AuthType.None,
+            // disableFullscreenPresentation not set → defaults to true via ?? true
+        });
+        const embed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        const addEventListenerSpy = jest.spyOn(document, 'addEventListener');
+        embed['setupFullscreenChangeHandler']();
+        expect(addEventListenerSpy).not.toHaveBeenCalledWith('fullscreenchange', expect.any(Function));
+        addEventListenerSpy.mockRestore();
+        // Restore for other tests in this describe
+        init({ thoughtSpotHost: 'tshost', authType: AuthType.None, disableFullscreenPresentation: false });
+    });
+    test('fullscreenchange fires but iFrame.contentWindow is null — trigger NOT called, debug log emitted', () => {
+        const embed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        // Give the embed a fake iFrame with null contentWindow
+        embed.iFrame = { contentWindow: null };
+        const addEventListenerSpy = jest.spyOn(document, 'addEventListener');
+        const loggerDebugSpy = jest.spyOn(logger, 'debug').mockImplementation(() => { });
+        const triggerSpy = jest.spyOn(embed, 'trigger').mockImplementation(() => Promise.resolve(null));
+        embed['setupFullscreenChangeHandler']();
+        // Capture the registered handler directly instead of dispatching to document
+        const fullscreenCall = addEventListenerSpy.mock.calls.find((c) => c[0] === 'fullscreenchange');
+        expect(fullscreenCall).toBeTruthy();
+        const handler = fullscreenCall[1];
+        Object.defineProperty(document, 'fullscreenElement', { value: null, writable: true, configurable: true });
+        handler(new Event('fullscreenchange'));
+        expect(triggerSpy).not.toHaveBeenCalled();
+        expect(loggerDebugSpy).toHaveBeenCalledWith(expect.stringContaining('Skipping ExitPresentMode'));
+        addEventListenerSpy.mockRestore();
+        loggerDebugSpy.mockRestore();
+        triggerSpy.mockRestore();
+    });
 });
 describe('ShowPreRender with UpdateEmbedParams', () => {
     const setupPreRenderTest = async (preRenderId, initialConfig) => {
@@ -4294,6 +4408,38 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
             expect(placeholderEle.parentElement).not.toBeNull();
             embed.destroy();
         });
+        // showPreRender located the stale placeholder with a subtree-wide
+        // querySelector but removed it with hostElement.removeChild(), which
+        // only accepts direct children. With fullHeight the placeholder can be
+        // nested deeper than a direct child, so removeChild threw
+        // "NotFoundError: Failed to execute 'removeChild' on 'Node'".
+        it('showPreRender removes a placeholder nested below a direct child without throwing', async () => {
+            createRootEleForEmbed();
+            const embed = new LiveboardEmbed('#tsEmbedDiv', {
+                preRenderId: 'ph-nested-test',
+                liveboardId: 'lb-id',
+                fullHeight: true,
+            });
+            await embed.preRender();
+            await waitFor(() => !!document.querySelector('#tsEmbed-pre-render-child-ph-nested-test'));
+            const hostElement = document.querySelector('#tsEmbedDiv');
+            const placeHolderId = 'tsEmbed-pre-render-placeholder-ph-nested-test';
+            // Simulate the fullHeight layout where the placeholder ends up as
+            // a grandchild of the host element rather than a direct child.
+            const intermediateWrapper = document.createElement('div');
+            const staleNestedPlaceholder = document.createElement('div');
+            staleNestedPlaceholder.id = placeHolderId;
+            intermediateWrapper.appendChild(staleNestedPlaceholder);
+            hostElement.appendChild(intermediateWrapper);
+            expect(hostElement.querySelector(`#${placeHolderId}`)).toBe(staleNestedPlaceholder);
+            // Before the fix this threw NotFoundError.
+            await expect(embed.showPreRender()).resolves.toBeDefined();
+            // The stale nested placeholder is gone; the fresh one is a direct child.
+            expect(staleNestedPlaceholder.isConnected).toBe(false);
+            const currentPlaceholder = embed.getPreRenderPlaceHolderElement();
+            expect(currentPlaceholder.parentElement).toBe(hostElement);
+            embed.destroy();
+        });
     });
 });
 //# sourceMappingURL=ts-embed.spec.js.map