@thoughtspot/visual-embed-sdk 1.51.2 → 1.52.1

package/lib/src/embed/liveboard.spec.js

@@ -705,7 +705,7 @@ describe('Liveboard/viz embed tests', () => {
         });
         const spySetIFrameHeight = jest.spyOn(myObject, 'setIFrameHeight');
         myObject.render();
-        myObject.setIframeHeightForNonEmbedLiveboard({
+        myObject.fullHeightController.handleRouteChange({
             data: { currentPath: '/embed/viz/' },
             type: 'Route',
         });
@@ -720,7 +720,7 @@ describe('Liveboard/viz embed tests', () => {
         });
         const spySetIFrameHeight = jest.spyOn(myObject, 'setIFrameHeight');
         myObject.render();
-        myObject.setIframeHeightForNonEmbedLiveboard({
+        myObject.fullHeightController.handleRouteChange({
             data: { currentPath: '/embed/insights/viz/' },
             type: 'Route',
         });
@@ -737,7 +737,7 @@ describe('Liveboard/viz embed tests', () => {
             .spyOn(myObject, 'setIFrameHeight')
             .mockImplementation(jest.fn());
         myObject.render();
-        myObject.setIframeHeightForNonEmbedLiveboard({
+        myObject.fullHeightController.handleRouteChange({
             data: { currentPath: '/some/other/path/' },
             type: 'Route',
         });
@@ -1020,12 +1020,12 @@ describe('Liveboard/viz embed tests', () => {
             expect(onSpy).toHaveBeenCalledWith(HostEvent.Navigate, 'embed/viz/lb1/viz1');
         }, 1002);
     });
-    test('navigateToLiveboard should call preRender when preRenderConfig.preRenderId is set', () => {
+    test('navigateToLiveboard should call preRender when preRenderConfig.id is set', () => {
         const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
             ...defaultViewConfig,
             liveboardId,
             preRenderConfig: {
-                preRenderId: 'config-pre-render-id',
+                id: 'config-pre-render-id',
             },
         });
         const preRenderSpy = jest
@@ -1035,13 +1035,13 @@ describe('Liveboard/viz embed tests', () => {
         expect(preRenderSpy).toHaveBeenCalledTimes(1);
         expect(preRenderSpy).toHaveBeenCalledWith(true);
     });
-    test('navigateToLiveboard should prefer preRenderConfig.preRenderId over top-level preRenderId', () => {
+    test('navigateToLiveboard should prefer preRenderConfig.id over top-level preRenderId', () => {
         const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
             ...defaultViewConfig,
             liveboardId,
             preRenderId: 'top-level-id',
             preRenderConfig: {
-                preRenderId: 'config-level-id',
+                id: 'config-level-id',
             },
         });
         const preRenderSpy = jest
@@ -1463,8 +1463,11 @@ describe('Liveboard/viz embed tests', () => {
                 // should render the generic link
                 expect(navigateToLiveboardSpy).toHaveBeenCalledWith(testLiveboardId, 'testVizId', 'testActiveTabId', undefined);
                 expect(iFrame.src).toMatch(/http:\/\/tshost\/.*&isLiveboardEmbed=true.*#$/);
+                // Navigate is held behind this show-cycle's
+                // UpdateEmbedParams, so wait out the settle
+                // window (SCAL-336321).
                 expect(consoleSpy).toHaveBeenCalledTimes(0);
-            });
+            }, 300);
         });
         test('it should navigateToLiveboard with liveboard id is not passed with AuthInit event', async () => {
             mockMessageChannel();
@@ -1510,7 +1513,10 @@ describe('Liveboard/viz embed tests', () => {
                 expect(navigateToLiveboardSpy).toHaveBeenCalledWith(testLiveboardId, 'testVizId', 'testActiveTabId', undefined);
                 expect(iFrame.src).toMatch(/http:\/\/tshost\/.*&isLiveboardEmbed=true.*#$/);
                 expect(consoleSpy).toHaveBeenCalledTimes(0);
-            }, 1005);
+                // 1000ms AuthInit fallback + the 200ms settle
+                // window before Navigate goes out (SCAL-336321),
+                // so 1005 is no longer enough.
+            }, 1305);
         });
         test('should replace existing preRender when replaceExistingPreRender is true', async () => {
             const testPreRenderId = 'testReplacePreRender';
@@ -1611,9 +1617,6 @@ describe('Liveboard/viz embed tests', () => {
                 liveboardId,
                 fullHeight: true,
             });
-            expect(liveboardEmbed.viewConfig.lazyLoadingForFullHeight).toBe(true);
-            expect(liveboardEmbed.viewConfig.enableScrollableContainerLazyLoading).toBe(true);
-            expect(liveboardEmbed.viewConfig.lazyLoadingMargin).toBe('500px 0px');
             await liveboardEmbed.render();
             await executeAfterWait(() => {
                 const iframeSrc = getIFrameSrc();
@@ -1627,9 +1630,13 @@ describe('Liveboard/viz embed tests', () => {
                 ...defaultViewConfig,
                 liveboardId,
             });
-            expect(liveboardEmbed.viewConfig.lazyLoadingForFullHeight).toBeUndefined();
-            expect(liveboardEmbed.viewConfig.enableScrollableContainerLazyLoading).toBeUndefined();
-            expect(liveboardEmbed.viewConfig.lazyLoadingMargin).toBeUndefined();
+            await liveboardEmbed.render();
+            await executeAfterWait(() => {
+                const iframeSrc = getIFrameSrc();
+                expect(iframeSrc).not.toContain('isFullHeightPinboard');
+                expect(iframeSrc).not.toContain('isLazyLoadingForEmbedEnabled');
+                expect(iframeSrc).not.toContain('rootMarginForLazyLoad');
+            }, 100);
         });
         test('should not write the defaults back onto the caller view config', async () => {
             const callerViewConfig = {
@@ -1648,9 +1655,13 @@ describe('Liveboard/viz embed tests', () => {
                 liveboardId,
                 fullHeight: false,
             });
-            expect(liveboardEmbed.viewConfig.lazyLoadingForFullHeight).toBeUndefined();
-            expect(liveboardEmbed.viewConfig.enableScrollableContainerLazyLoading).toBeUndefined();
-            expect(liveboardEmbed.viewConfig.lazyLoadingMargin).toBeUndefined();
+            await liveboardEmbed.render();
+            await executeAfterWait(() => {
+                const iframeSrc = getIFrameSrc();
+                expect(iframeSrc).not.toContain('isFullHeightPinboard');
+                expect(iframeSrc).not.toContain('isLazyLoadingForEmbedEnabled');
+                expect(iframeSrc).not.toContain('rootMarginForLazyLoad');
+            }, 100);
         });
         test('should default lazyLoadingMargin when lazyLoadingForFullHeight is set explicitly', async () => {
             const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
@@ -1659,10 +1670,9 @@ describe('Liveboard/viz embed tests', () => {
                 fullHeight: true,
                 lazyLoadingForFullHeight: true,
             });
-            expect(liveboardEmbed.viewConfig.lazyLoadingMargin).toBe(DEFAULT_LAZY_LOADING_MARGIN);
             await liveboardEmbed.render();
             await executeAfterWait(() => {
-                expect(getIFrameSrc()).toContain('rootMarginForLazyLoad=500px%200px');
+                expect(getIFrameSrc()).toContain(`rootMarginForLazyLoad=${encodeURIComponent(DEFAULT_LAZY_LOADING_MARGIN)}`);
             }, 100);
         });
         test('should let an explicit lazyLoadingMargin win over the default', async () => {
@@ -1843,7 +1853,7 @@ describe('Liveboard/viz embed tests', () => {
             const mockTrigger = jest.spyOn(liveboardEmbed, 'trigger');
             await liveboardEmbed.render();
             // Trigger the lazy load data calculation
-            liveboardEmbed.sendFullHeightLazyLoadData();
+            liveboardEmbed.fullHeightController.sendVisibleCoordinates();
             expect(mockTrigger).toHaveBeenCalledWith(HostEvent.VisibleEmbedCoordinates, {
                 top: 0,
                 height: 500,
@@ -1861,7 +1871,7 @@ describe('Liveboard/viz embed tests', () => {
             const mockTrigger = jest.spyOn(liveboardEmbed, 'trigger');
             await liveboardEmbed.render();
             // Trigger the lazy load data calculation
-            liveboardEmbed.sendFullHeightLazyLoadData();
+            liveboardEmbed.fullHeightController.sendVisibleCoordinates();
             expect(mockTrigger).toHaveBeenCalledWith(HostEvent.VisibleEmbedCoordinates, {
                 top: 0,
                 height: 500,
@@ -1888,7 +1898,7 @@ describe('Liveboard/viz embed tests', () => {
             const mockTrigger = jest.spyOn(liveboardEmbed, 'trigger');
             await liveboardEmbed.render();
             // Trigger the lazy load data calculation
-            liveboardEmbed.sendFullHeightLazyLoadData();
+            liveboardEmbed.fullHeightController.sendVisibleCoordinates();
             expect(mockTrigger).toHaveBeenCalledWith(HostEvent.VisibleEmbedCoordinates, {
                 top: 50,
                 height: 700,
@@ -1977,7 +1987,7 @@ describe('Liveboard/viz embed tests', () => {
             // Create a mock responder function
             const mockResponder = jest.fn();
             // Trigger the handler directly
-            liveboardEmbed.requestVisibleEmbedCoordinatesHandler({}, mockResponder);
+            liveboardEmbed.fullHeightController.handleRequestVisibleCoordinates({}, mockResponder);
             // Verify the responder was called with the correct data
             expect(mockResponder).toHaveBeenCalledWith({
                 type: EmbedEvent.RequestVisibleEmbedCoordinates,
@@ -2012,6 +2022,20 @@ describe('Liveboard/viz embed tests', () => {
         beforeEach(() => {
             document.body.innerHTML = getDocumentBody();
         });
+        // beforePrerenderVisible() no longer navigates
+        // synchronously: Navigate is held until this show-cycle's
+        // UpdateEmbedParams has been posted and given
+        // UPDATE_EMBED_PARAMS_SETTLE_MS (200ms) to apply
+        // (SCAL-336321). These tests must wait that window out
+        // rather than read the spy inline.
+        const waitForPreRenderNavigate = () => new Promise((resolve) => {
+            setTimeout(resolve, 300);
+        });
+        // A home hop waits twice: params settle, then home settle. Generous
+        // margin over the two windows so a slow run does not flake.
+        const waitForHomeHopNavigate = () => new Promise((resolve) => {
+            setTimeout(resolve, 900);
+        });
         test('should call navigateToLiveboard after embed container is loaded in beforePrerenderVisible', async () => {
             const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
                 liveboardId,
@@ -2029,16 +2053,168 @@ describe('Liveboard/viz embed tests', () => {
             // Simulate embed container becoming ready
             liveboardEmbed.isEmbedContainerLoaded = true;
             liveboardEmbed['executeEmbedContainerReadyCallbacks']();
+            await waitForPreRenderNavigate();
             // Now navigateToLiveboard should be called
             expect(navigateToLiveboardSpy).toHaveBeenCalledWith(liveboardId, vizId, activeTabId, undefined);
         });
-        test('should update currentLiveboardState for prerender object when embed container loads', async () => {
+        test('should route via home when the pre-render is already on this route', async () => {
+            const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+                liveboardId,
+                vizId,
+                activeTabId,
+                ...defaultViewConfig,
+            });
+            // Navigate to the route it is already on is a no-op, so the
+            // liveboard keeps its state. Home unmounts the container.
+            jest.spyOn(liveboardEmbed, 'getPreRenderObj').mockReturnValue({
+                currentLiveboardState: {
+                    liveboardId,
+                    vizId,
+                    activeTabId,
+                    personalizedViewId: undefined,
+                },
+            });
+            const triggerSpy = jest
+                .spyOn(liveboardEmbed, 'trigger')
+                .mockImplementation(() => Promise.resolve(undefined));
+            const navigateToLiveboardSpy = jest
+                .spyOn(liveboardEmbed, 'navigateToLiveboard')
+                .mockImplementation(() => Promise.resolve(undefined));
+            liveboardEmbed.isEmbedContainerLoaded = false;
+            liveboardEmbed['beforePrerenderVisible']();
+            liveboardEmbed.isEmbedContainerLoaded = true;
+            liveboardEmbed['executeEmbedContainerReadyCallbacks']();
+            await waitForHomeHopNavigate();
+            expect(triggerSpy).toHaveBeenCalledWith(HostEvent.Navigate, 'home');
+            expect(navigateToLiveboardSpy).toHaveBeenCalledWith(liveboardId, vizId, activeTabId, undefined);
+            // Home first, or we would clear what we just asked for.
+            expect(triggerSpy.mock.invocationCallOrder[0]).toBeLessThan(navigateToLiveboardSpy.mock.invocationCallOrder[0]);
+        });
+        test('should not wait for the container to acknowledge the home hop', async () => {
+            const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+                liveboardId,
+                vizId,
+                activeTabId,
+                ...defaultViewConfig,
+            });
+            jest.spyOn(liveboardEmbed, 'getPreRenderObj').mockReturnValue({
+                currentLiveboardState: {
+                    liveboardId,
+                    vizId,
+                    activeTabId,
+                    personalizedViewId: undefined,
+                },
+            });
+            // A real home hop never settles until the 30s trigger timeout.
+            // Awaiting it parked the liveboard on home for that long.
+            jest.spyOn(liveboardEmbed, 'trigger').mockImplementation((event, payload) => (event === HostEvent.Navigate && payload === 'home'
+                ? new Promise(() => { })
+                : Promise.resolve(undefined)));
+            const navigateToLiveboardSpy = jest
+                .spyOn(liveboardEmbed, 'navigateToLiveboard')
+                .mockImplementation(() => Promise.resolve(undefined));
+            liveboardEmbed.isEmbedContainerLoaded = false;
+            liveboardEmbed['beforePrerenderVisible']();
+            liveboardEmbed.isEmbedContainerLoaded = true;
+            liveboardEmbed['executeEmbedContainerReadyCallbacks']();
+            await waitForHomeHopNavigate();
+            expect(navigateToLiveboardSpy).toHaveBeenCalledWith(liveboardId, vizId, activeTabId, undefined);
+        });
+        test('should not route via home when the embed is showing itself again', async () => {
+            const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+                liveboardId,
+                vizId,
+                activeTabId,
+                ...defaultViewConfig,
+            });
+            // A hide/show of one embed, not a hand-over: the state is this
+            // user's own, so clearing it would lose their session.
+            jest.spyOn(liveboardEmbed, 'getPreRenderObj').mockReturnValue(liveboardEmbed);
+            const triggerSpy = jest
+                .spyOn(liveboardEmbed, 'trigger')
+                .mockImplementation(() => Promise.resolve(undefined));
+            const navigateToLiveboardSpy = jest
+                .spyOn(liveboardEmbed, 'navigateToLiveboard')
+                .mockImplementation(() => Promise.resolve(undefined));
+            liveboardEmbed.isEmbedContainerLoaded = false;
+            liveboardEmbed['beforePrerenderVisible']();
+            liveboardEmbed.isEmbedContainerLoaded = true;
+            liveboardEmbed['executeEmbedContainerReadyCallbacks']();
+            await waitForPreRenderNavigate();
+            expect(triggerSpy).not.toHaveBeenCalledWith(HostEvent.Navigate, 'home');
+            expect(navigateToLiveboardSpy).toHaveBeenCalled();
+        });
+        test('should not route via home when the pre-render is on another liveboard', async () => {
+            const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+                liveboardId,
+                vizId,
+                activeTabId,
+                ...defaultViewConfig,
+            });
+            jest.spyOn(liveboardEmbed, 'getPreRenderObj').mockReturnValue({
+                currentLiveboardState: {
+                    liveboardId: 'a-different-liveboard',
+                    vizId,
+                    activeTabId,
+                    personalizedViewId: undefined,
+                },
+            });
+            const triggerSpy = jest
+                .spyOn(liveboardEmbed, 'trigger')
+                .mockImplementation(() => Promise.resolve(undefined));
+            const navigateToLiveboardSpy = jest
+                .spyOn(liveboardEmbed, 'navigateToLiveboard')
+                .mockImplementation(() => Promise.resolve(undefined));
+            liveboardEmbed.isEmbedContainerLoaded = false;
+            liveboardEmbed['beforePrerenderVisible']();
+            liveboardEmbed.isEmbedContainerLoaded = true;
+            liveboardEmbed['executeEmbedContainerReadyCallbacks']();
+            await waitForPreRenderNavigate();
+            // A real route change unmounts the liveboard by itself.
+            expect(triggerSpy).not.toHaveBeenCalledWith(HostEvent.Navigate, 'home');
+            expect(navigateToLiveboardSpy).toHaveBeenCalledWith(liveboardId, vizId, activeTabId, undefined);
+        });
+        test('should not route via home for the same liveboard on a different tab', async () => {
+            const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+                liveboardId,
+                vizId,
+                activeTabId,
+                ...defaultViewConfig,
+            });
+            // Same liveboard, different tab — a real navigation.
+            jest.spyOn(liveboardEmbed, 'getPreRenderObj').mockReturnValue({
+                currentLiveboardState: {
+                    liveboardId,
+                    vizId,
+                    activeTabId: 'another-tab',
+                    personalizedViewId: undefined,
+                },
+            });
+            const triggerSpy = jest
+                .spyOn(liveboardEmbed, 'trigger')
+                .mockImplementation(() => Promise.resolve(undefined));
+            const navigateToLiveboardSpy = jest
+                .spyOn(liveboardEmbed, 'navigateToLiveboard')
+                .mockImplementation(() => Promise.resolve(undefined));
+            liveboardEmbed.isEmbedContainerLoaded = false;
+            liveboardEmbed['beforePrerenderVisible']();
+            liveboardEmbed.isEmbedContainerLoaded = true;
+            liveboardEmbed['executeEmbedContainerReadyCallbacks']();
+            await waitForPreRenderNavigate();
+            expect(triggerSpy).not.toHaveBeenCalledWith(HostEvent.Navigate, 'home');
+            expect(navigateToLiveboardSpy).toHaveBeenCalled();
+        });
+        test('should update currentLiveboardState on the embed showing when the container loads', async () => {
             const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
                 liveboardId,
                 vizId,
                 activeTabId,
                 ...defaultViewConfig,
             });
+            // The state is written on the embed that is being shown, which is
+            // also the one the pre-render wrapper ends up pointing at. Writing
+            // it on the predecessor left "current" naming a liveboard that
+            // stopped being current one hand-over ago.
             const mockPreRenderObj = {
                 currentLiveboardState: {},
             };
@@ -2051,12 +2227,15 @@ describe('Liveboard/viz embed tests', () => {
             // Simulate embed container becoming ready
             liveboardEmbed.isEmbedContainerLoaded = true;
             liveboardEmbed['executeEmbedContainerReadyCallbacks']();
-            // Check that currentLiveboardState was updated
-            expect(mockPreRenderObj.currentLiveboardState).toEqual({
+            await waitForPreRenderNavigate();
+            expect(liveboardEmbed.currentLiveboardState).toEqual({
                 liveboardId,
                 vizId,
                 activeTabId,
+                personalizedViewId: undefined,
             });
+            // and NOT on the instance it took the pre-render over from
+            expect(mockPreRenderObj.currentLiveboardState).toEqual({});
         });
         test('should handle beforePrerenderVisible when embed container is already loaded', async () => {
             const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
@@ -2070,7 +2249,8 @@ describe('Liveboard/viz embed tests', () => {
             liveboardEmbed.isEmbedContainerLoaded = true;
             // Call beforePrerenderVisible
             liveboardEmbed['beforePrerenderVisible']();
-            // navigateToLiveboard should be called immediately
+            await waitForPreRenderNavigate();
+            // navigateToLiveboard should be called once the params have settled
             expect(navigateToLiveboardSpy).toHaveBeenCalledWith(liveboardId, vizId, activeTabId, undefined);
         });
         test('should handle beforePrerenderVisible without prerender object', async () => {
@@ -2089,6 +2269,7 @@ describe('Liveboard/viz embed tests', () => {
             // Simulate embed container becoming ready
             liveboardEmbed.isEmbedContainerLoaded = true;
             liveboardEmbed['executeEmbedContainerReadyCallbacks']();
+            await waitForPreRenderNavigate();
             // navigateToLiveboard should still be called
             expect(navigateToLiveboardSpy).toHaveBeenCalledWith(liveboardId, vizId, activeTabId, undefined);
         });
@@ -2107,6 +2288,7 @@ describe('Liveboard/viz embed tests', () => {
             liveboardEmbed.isEmbedContainerLoaded = true;
             // Call beforePrerenderVisible
             liveboardEmbed['beforePrerenderVisible']();
+            await waitForPreRenderNavigate();
             // Check that all parameters are passed correctly
             expect(navigateToLiveboardSpy).toHaveBeenCalledWith(customLiveboardId, customVizId, customActiveTabId, undefined);
         });
@@ -2120,6 +2302,7 @@ describe('Liveboard/viz embed tests', () => {
             liveboardEmbed.isEmbedContainerLoaded = true;
             // Call beforePrerenderVisible
             liveboardEmbed['beforePrerenderVisible']();
+            await waitForPreRenderNavigate();
             // Check that undefined parameters are passed correctly
             expect(navigateToLiveboardSpy).toHaveBeenCalledWith(liveboardId, undefined, undefined, undefined);
         });
@@ -2134,7 +2317,7 @@ describe('Liveboard/viz embed tests', () => {
                 minimumHeight: 800,
             });
             await liveboardEmbed.render();
-            expect(liveboardEmbed['defaultHeight']).toBe(800);
+            expect(liveboardEmbed['fullHeightController'].minimumHeight).toBe(800);
         });
         test('should set default height to 700 when default height is provided', async () => {
             const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
@@ -2144,7 +2327,7 @@ describe('Liveboard/viz embed tests', () => {
                 defaultHeight: 700,
             });
             await liveboardEmbed.render();
-            expect(liveboardEmbed['defaultHeight']).toBe(700);
+            expect(liveboardEmbed['fullHeightController'].minimumHeight).toBe(700);
         });
         test('should set default height to 800 when minimum height is provided but default height is not', async () => {
             const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
@@ -2154,7 +2337,7 @@ describe('Liveboard/viz embed tests', () => {
                 minimumHeight: 800,
             });
             await liveboardEmbed.render();
-            expect(liveboardEmbed['defaultHeight']).toBe(800);
+            expect(liveboardEmbed['fullHeightController'].minimumHeight).toBe(800);
         });
         test('should set default height to 500 when neither default height nor minimum height is provided', async () => {
             const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
@@ -2163,7 +2346,7 @@ describe('Liveboard/viz embed tests', () => {
                 fullHeight: true,
             });
             await liveboardEmbed.render();
-            expect(liveboardEmbed['defaultHeight']).toBe(500);
+            expect(liveboardEmbed['fullHeightController'].minimumHeight).toBe(500);
         });
     });
 });