@thoughtspot/visual-embed-sdk 1.44.3 → 1.44.4-HE-beta.1

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

@@ -136,7 +136,7 @@ describe('Unit test case for ts embed', () => {
                 expect(mockProcessTrigger).toHaveBeenCalledWith(getIFrameEl(), HostEvent.UIPassthrough, 'http://tshost', {
                     parameters: payload,
                     type: UIPassthroughEvent.PinAnswerToLiveboard,
-                });
+                }, undefined);
             });
         });
         test('Host event with empty param', async () => {
@@ -148,7 +148,7 @@ describe('Unit test case for ts embed', () => {
             mockProcessTrigger.mockResolvedValue({ session: 'test' });
             await executeAfterWait(async () => {
                 await liveboardEmbed.trigger(HostEvent.Save);
-                expect(mockProcessTrigger).toHaveBeenCalledWith(getIFrameEl(), HostEvent.Save, 'http://tshost', {});
+                expect(mockProcessTrigger).toHaveBeenCalledWith(getIFrameEl(), HostEvent.Save, 'http://tshost', {}, undefined);
             });
         });
         test('Host event with falsy param', async () => {
@@ -160,7 +160,7 @@ describe('Unit test case for ts embed', () => {
             mockProcessTrigger.mockResolvedValue({ session: 'test' });
             await executeAfterWait(async () => {
                 await liveboardEmbed.trigger(HostEvent.Save, false);
-                expect(mockProcessTrigger).toHaveBeenCalledWith(getIFrameEl(), HostEvent.Save, 'http://tshost', false);
+                expect(mockProcessTrigger).toHaveBeenCalledWith(getIFrameEl(), HostEvent.Save, 'http://tshost', false, undefined);
             });
         });
         test('should set proper height, width and min-height to iframe', async () => {
@@ -1115,7 +1115,7 @@ describe('Unit test case for ts embed', () => {
             const { mockPreauthInfoFetch, iFrame, } = await setup(true);
             expect(mockPreauthInfoFetch).toHaveBeenCalledTimes(1);
             await executeAfterWait(() => {
-                expect(mockProcessTrigger).toHaveBeenCalledWith(iFrame, HostEvent.InfoSuccess, 'http://tshost', expect.objectContaining({ info: expect.any(Object) }));
+                expect(mockProcessTrigger).toHaveBeenCalledWith(iFrame, HostEvent.InfoSuccess, 'http://tshost', expect.objectContaining({ info: expect.any(Object) }), undefined);
             });
         });
         test('should not call InfoSuccess Event if overrideOrgId is true', async () => {
@@ -1218,28 +1218,28 @@ describe('Unit test case for ts embed', () => {
             const { mockGetPreauthInfo } = await setupPreauthTest('AppEmbed', undefined);
             await executeAfterWait(() => {
                 expect(mockGetPreauthInfo).toHaveBeenCalledTimes(1);
-                expect(mockProcessTrigger).toHaveBeenCalledWith(expect.any(Object), HostEvent.InfoSuccess, 'http://tshost', expect.objectContaining({ info: expect.any(Object) }));
+                expect(mockProcessTrigger).toHaveBeenCalledWith(expect.any(Object), HostEvent.InfoSuccess, 'http://tshost', expect.objectContaining({ info: expect.any(Object) }), undefined);
             });
         });
         test('should enable preauth cache for FullAppEmbed with showPrimaryNavbar = false', async () => {
             const { mockGetPreauthInfo } = await setupPreauthTest('AppEmbed', false);
             await executeAfterWait(() => {
                 expect(mockGetPreauthInfo).toHaveBeenCalledTimes(1);
-                expect(mockProcessTrigger).toHaveBeenCalledWith(expect.any(Object), HostEvent.InfoSuccess, 'http://tshost', expect.objectContaining({ info: expect.any(Object) }));
+                expect(mockProcessTrigger).toHaveBeenCalledWith(expect.any(Object), HostEvent.InfoSuccess, 'http://tshost', expect.objectContaining({ info: expect.any(Object) }), undefined);
             });
         });
         test('should enable preauth cache for SearchEmbed regardless of showPrimaryNavbar', async () => {
             const { mockGetPreauthInfo } = await setupPreauthTest('SearchEmbed', true);
             await executeAfterWait(() => {
                 expect(mockGetPreauthInfo).toHaveBeenCalledTimes(1);
-                expect(mockProcessTrigger).toHaveBeenCalledWith(expect.any(Object), HostEvent.InfoSuccess, 'http://tshost', expect.objectContaining({ info: expect.any(Object) }));
+                expect(mockProcessTrigger).toHaveBeenCalledWith(expect.any(Object), HostEvent.InfoSuccess, 'http://tshost', expect.objectContaining({ info: expect.any(Object) }), undefined);
             });
         });
         test('should enable preauth cache for SearchEmbed (verifies fix for embed type regression)', async () => {
             const { mockGetPreauthInfo } = await setupPreauthTest('SearchEmbed', false);
             await executeAfterWait(() => {
                 expect(mockGetPreauthInfo).toHaveBeenCalledTimes(1);
-                expect(mockProcessTrigger).toHaveBeenCalledWith(expect.any(Object), HostEvent.InfoSuccess, 'http://tshost', expect.objectContaining({ info: expect.any(Object) }));
+                expect(mockProcessTrigger).toHaveBeenCalledWith(expect.any(Object), HostEvent.InfoSuccess, 'http://tshost', expect.objectContaining({ info: expect.any(Object) }), undefined);
             });
         });
         test('should disable preauth cache for FullAppEmbed with overrideOrgId (combined condition)', async () => {
@@ -2059,6 +2059,36 @@ describe('Unit test case for ts embed', () => {
             libEmbed.hidePreRender();
             expect(libEmbed.preRender).toHaveBeenCalledTimes(0);
         });
+        it('should set overflow:hidden when hidePreRender and remove when showPreRender', async () => {
+            createRootEleForEmbed();
+            window.ResizeObserver = window.ResizeObserver
+                || jest.fn().mockImplementation(() => ({
+                    disconnect: jest.fn(),
+                    observe: jest.fn(),
+                    unobserve: jest.fn(),
+                }));
+            const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
+                preRenderId: 'overflow-test',
+                liveboardId: 'myLiveboardId',
+            });
+            await libEmbed.preRender();
+            await waitFor(() => !!getIFrameEl());
+            const preRenderIds = libEmbed.getPreRenderIds();
+            const preRenderWrapper = document.getElementById(preRenderIds.wrapper);
+            // After preRender (calls hidePreRender by default)
+            // should have overflow:hidden
+            expect(preRenderWrapper.style.overflow).toBe('hidden');
+            expect(preRenderWrapper.style.opacity).toBe('0');
+            // After showPreRender, overflow should be removed
+            // to inherit from CSS
+            libEmbed.showPreRender();
+            expect(preRenderWrapper.style.overflow).toBe('');
+            expect(preRenderWrapper.style.opacity).toBe('');
+            // After hidePreRender again, overflow should be hidden
+            libEmbed.hidePreRender();
+            expect(preRenderWrapper.style.overflow).toBe('hidden');
+            expect(preRenderWrapper.style.opacity).toBe('0');
+        });
         it('it should connect with another object', async () => {
             createRootEleForEmbed();
             mockMessageChannel();
@@ -3293,7 +3323,7 @@ describe('Destroy error handling', () => {
             appEmbed.destroy();
         }).not.toThrow();
         expect(logSpy).toHaveBeenCalledWith('Error destroying TS Embed', expect.any(Error));
-        logSpy.mockRestore();
+        logSpy.mockReset();
     });
 });
 describe('Fullscreen change handler behavior', () => {
@@ -3327,7 +3357,7 @@ describe('Fullscreen change handler behavior', () => {
         const event = new Event('fullscreenchange');
         document.dispatchEvent(event);
         await executeAfterWait(() => {
-            expect(mockProcessTrigger).toHaveBeenCalledWith(expect.any(Object), HostEvent.ExitPresentMode, expect.any(String), expect.any(Object));
+            expect(mockProcessTrigger).toHaveBeenLastCalledWith(expect.any(Object), HostEvent.ExitPresentMode, expect.any(String), expect.any(Object), undefined);
         });
     });
     test('should not trigger ExitPresentMode when entering fullscreen', async () => {
@@ -3356,17 +3386,7 @@ describe('Fullscreen change handler behavior', () => {
     });
 });
 describe('ShowPreRender with UpdateEmbedParams', () => {
-    beforeAll(() => {
-        init({
-            thoughtSpotHost: 'tshost',
-            authType: AuthType.None,
-        });
-    });
-    afterEach(() => {
-        const rootEle = document.getElementById('myRoot');
-        rootEle === null || rootEle === void 0 ? void 0 : rootEle.remove();
-    });
-    test('should trigger UpdateEmbedParams when showPreRender connects to existing prerendered component', async () => {
+    const setupPreRenderTest = async (preRenderId, initialConfig) => {
         createRootEleForEmbed();
         mockMessageChannel();
         window.ResizeObserver = window.ResizeObserver
@@ -3376,24 +3396,136 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
                 unobserve: jest.fn(),
             }));
         const embed1 = new LiveboardEmbed('#tsEmbedDiv', {
-            preRenderId: 'update-params-test',
-            liveboardId: 'original-lb',
+            preRenderId,
+            ...initialConfig,
         });
         await embed1.preRender();
         await waitFor(() => !!getIFrameEl());
         embed1.isEmbedContainerLoaded = true;
         mockProcessTrigger.mockClear();
         mockProcessTrigger.mockResolvedValue({});
+        return embed1;
+    };
+    beforeAll(() => {
+        init({
+            thoughtSpotHost: 'tshost',
+            authType: AuthType.None,
+        });
+    });
+    afterEach(() => {
+        const rootEle = document.getElementById('myRoot');
+        rootEle === null || rootEle === void 0 ? void 0 : rootEle.remove();
+    });
+    test('should trigger UpdateEmbedParams when showPreRender connects to existing prerendered component', async () => {
+        await setupPreRenderTest('update-params-test', { liveboardId: 'original-lb' });
         const embed2 = new LiveboardEmbed('#tsEmbedDiv', {
             preRenderId: 'update-params-test',
             liveboardId: 'updated-lb',
         });
         embed2.showPreRender();
         await executeAfterWait(() => {
-            expect(mockProcessTrigger).toHaveBeenCalledWith(expect.any(Object), HostEvent.UpdateEmbedParams, expect.any(String), expect.objectContaining({
+            expect(mockProcessTrigger).toHaveBeenLastCalledWith(expect.any(Object), HostEvent.UpdateEmbedParams, expect.any(String), expect.objectContaining({
                 liveboardId: 'updated-lb',
+            }), undefined);
+        });
+    });
+    test('should trigger UpdateEmbedParams with runtime filters and visible vizs', async () => {
+        await setupPreRenderTest('url-param-test', { liveboardId: 'original-lb' });
+        const embed2 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'url-param-test',
+            liveboardId: 'original-lb',
+            visibleVizs: ['viz-1'],
+            runtimeFilters: [
+                {
+                    columnName: 'Color',
+                    operator: RuntimeFilterOp.IN,
+                    values: ['red', 'blue'],
+                },
+                {
+                    columnName: 'Region',
+                    operator: RuntimeFilterOp.EQ,
+                    values: ['North'],
+                },
+            ],
+        });
+        embed2.showPreRender();
+        await executeAfterWait(() => {
+            expect(mockProcessTrigger).toHaveBeenLastCalledWith(expect.any(Object), HostEvent.UpdateEmbedParams, expect.any(String), expect.objectContaining({
+                liveboardId: 'original-lb',
+                visibleVizs: ['viz-1'],
+                runtimeFilters: [
+                    {
+                        columnName: 'Color',
+                        operator: RuntimeFilterOp.IN,
+                        values: ['red', 'blue'],
+                    },
+                    {
+                        columnName: 'Region',
+                        operator: RuntimeFilterOp.EQ,
+                        values: ['North'],
+                    },
+                ],
+            }), undefined);
+        });
+    });
+    test('should trigger UpdateEmbedParams with updated config', async () => {
+        await setupPreRenderTest('preserve-config-test', {
+            liveboardId: 'original-lb',
+            runtimeFilters: [
+                {
+                    columnName: 'Color',
+                    operator: RuntimeFilterOp.IN,
+                    values: ['red', 'blue'],
+                },
+            ],
+        });
+        const embed2 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'preserve-config-test',
+            liveboardId: 'original-lb',
+            visibleVizs: ['viz-1', 'viz-2'],
+            runtimeFilters: [
+                {
+                    columnName: 'Region',
+                    operator: RuntimeFilterOp.EQ,
+                    values: ['North'],
+                },
+            ],
+        });
+        embed2.showPreRender();
+        await executeAfterWait(() => {
+            expect(mockProcessTrigger).toHaveBeenLastCalledWith(expect.any(Object), HostEvent.UpdateEmbedParams, expect.any(String), expect.objectContaining({
+                liveboardId: 'original-lb',
+                visibleVizs: ['viz-1', 'viz-2'],
+                runtimeFilters: [
+                    {
+                        columnName: 'Region',
+                        operator: RuntimeFilterOp.EQ,
+                        values: ['North'],
+                    },
+                ],
+            }), undefined);
+        });
+    });
+    test('should handle error when getUpdateEmbedParamsObject fails during showPreRender', async () => {
+        await setupPreRenderTest('error-test', { liveboardId: 'original-lb' });
+        const handleErrorSpy = jest.spyOn(LiveboardEmbed.prototype, 'handleError');
+        const embed2 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'error-test',
+            liveboardId: 'updated-lb',
+        });
+        const mockError = new Error('Failed to get params');
+        jest.spyOn(embed2, 'getUpdateEmbedParamsObject').mockRejectedValue(mockError);
+        embed2.showPreRender();
+        await executeAfterWait(() => {
+            expect(handleErrorSpy).toHaveBeenCalledWith(expect.objectContaining({
+                errorType: ErrorDetailsTypes.API,
+                message: 'Failed to get params',
+                code: EmbedErrorCodes.UPDATE_PARAMS_FAILED,
+                error: 'Failed to get params',
             }));
+            expect(mockProcessTrigger).not.toHaveBeenCalledWith(expect.any(Object), HostEvent.UpdateEmbedParams, expect.any(String), expect.any(Object));
         });
+        handleErrorSpy.mockRestore();
     });
 });
 //# sourceMappingURL=ts-embed.spec.js.map