@thoughtspot/visual-embed-sdk 1.45.0 → 1.45.2

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

@@ -1,7 +1,7 @@
 import { resetValueFromWindow } from '../utils';
 import { ERROR_MESSAGE } from '../errors';
 import { resetCachedAuthToken } from '../authToken';
-import { AuthType, init, EmbedEvent, SearchEmbed, PinboardEmbed, AppEmbed, LiveboardEmbed, SageEmbed, AnswerService, } from '../index';
+import { AuthType, init, EmbedEvent, SearchEmbed, PinboardEmbed, AppEmbed, LiveboardEmbed, SageEmbed, AnswerService, SpotterEmbed, } from '../index';
 import { Action, HomeLeftNavItem, RuntimeFilterOp, HomepageModule, HostEvent, ContextMenuTriggerOptions, CustomActionTarget, CustomActionsPosition, ErrorDetailsTypes, EmbedErrorCodes, } from '../types';
 import { executeAfterWait, getDocumentBody, getIFrameEl, getIFrameSrc, getRootEl, postMessageToParent, defaultParamsForPinboardEmbed, waitFor, expectUrlMatchesWithParams, expectUrlToHaveParamsWithValues, mockMessageChannel, createRootEleForEmbed, expectUrlMatch, fixedEncodeURI, } from '../test/test-utils';
 import * as config from '../config';
@@ -20,6 +20,7 @@ import { UIPassthroughEvent } from './hostEventClient/contracts';
 import * as sessionInfoService from '../utils/sessionInfoService';
 import * as authToken from '../authToken';
 import * as apiIntercept from '../api-intercept';
+import * as processData from '../utils/processData';
 jest.mock('../utils/processTrigger');
 const mockProcessTrigger = processTrigger;
 const mockHandleInterceptEvent = jest.spyOn(apiIntercept, 'handleInterceptEvent');
@@ -136,7 +137,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 +149,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 +161,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 () => {
@@ -1116,7 +1117,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 () => {
@@ -1219,28 +1220,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 () => {
@@ -2326,7 +2327,7 @@ describe('Unit test case for ts embed', () => {
             jest.clearAllMocks();
             document.body.innerHTML = getDocumentBody();
             mockPort.postMessage.mockClear();
-            jest.spyOn(authToken, 'getAuthenticationToken').mockResolvedValue('test-token');
+            jest.spyOn(authToken, 'getAuthenticationToken').mockResolvedValue('mock-test-token-placeholder');
             jest.spyOn(baseInstance, 'handleAuth').mockImplementation(() => Promise.resolve(true));
             jest.spyOn(baseInstance, 'notifyAuthFailure').mockImplementation(() => { });
         });
@@ -2350,7 +2351,7 @@ describe('Unit test case for ts embed', () => {
                 expect(baseInstance.handleAuth).toHaveBeenCalledTimes(1);
                 expect(mockPort.postMessage).toHaveBeenCalledWith({
                     type: EmbedEvent.AuthExpire,
-                    data: { authToken: 'test-token' },
+                    data: { authToken: 'mock-test-token-placeholder' },
                 });
             });
         });
@@ -2379,7 +2380,7 @@ describe('Unit test case for ts embed', () => {
                 expect(baseInstance.handleAuth).toHaveBeenCalledTimes(1);
                 expect(mockPort.postMessage).toHaveBeenCalledWith({
                     type: EmbedEvent.AuthExpire,
-                    data: { authToken: 'test-token' },
+                    data: { authToken: 'mock-test-token-placeholder' },
                 });
             });
         });
@@ -2423,6 +2424,83 @@ describe('Unit test case for ts embed', () => {
             expect(baseInstance.notifyAuthFailure).toHaveBeenCalledWith(authInstance.AuthFailureType.EXPIRY);
         });
     });
+    describe('AutoLogin behavior in tokenRefresh', () => {
+        const mockPort = { postMessage: jest.fn() };
+        const mockEmbedEventPayload = { type: EmbedEvent.RefreshAuthToken, data: {} };
+        beforeEach(() => {
+            jest.clearAllMocks();
+            document.body.innerHTML = getDocumentBody();
+            mockPort.postMessage.mockClear();
+            jest.spyOn(authToken, 'getAuthenticationToken').mockResolvedValue('mock-test-token-placeholder');
+            jest.spyOn(processData, 'processAuthFailure').mockImplementation(() => ({}));
+            jest.spyOn(logger, 'error').mockImplementation(() => { });
+        });
+        const renderAndTriggerRefreshAuthToken = async () => {
+            const spotterEmbed = new SpotterEmbed(getRootEl(), {
+                worksheetId: 'test-worksheet',
+                searchOptions: {
+                    searchQuery: 'test query',
+                },
+            });
+            await spotterEmbed.render();
+            await executeAfterWait(() => {
+                const iframe = getIFrameEl();
+                postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
+            });
+        };
+        test('Cookieless with autoLogin undefined should default to true and refresh token', async () => {
+            init({
+                thoughtSpotHost: 'tshost',
+                authType: AuthType.TrustedAuthTokenCookieless,
+                // autoLogin undefined
+            });
+            await renderAndTriggerRefreshAuthToken();
+            await executeAfterWait(() => {
+                expect(authToken.getAuthenticationToken).toHaveBeenCalledWith(expect.any(Object), true);
+            });
+        });
+        test('Cookieless with autoLogin true should refresh token', async () => {
+            init({
+                thoughtSpotHost: 'tshost',
+                authType: AuthType.TrustedAuthTokenCookieless,
+                autoLogin: true,
+            });
+            await renderAndTriggerRefreshAuthToken();
+            await executeAfterWait(() => {
+                expect(authToken.getAuthenticationToken).toHaveBeenCalledWith(expect.any(Object), true);
+            });
+        });
+        test('Cookieless with autoLogin false should not refresh token', async () => {
+            init({
+                thoughtSpotHost: 'tshost',
+                authType: AuthType.TrustedAuthTokenCookieless,
+                autoLogin: false,
+            });
+            await renderAndTriggerRefreshAuthToken();
+            await executeAfterWait(() => {
+                expect(authToken.getAuthenticationToken).not.toHaveBeenCalled();
+                expect(mockPort.postMessage).not.toHaveBeenCalled();
+            });
+        });
+        test('Should handle error when getAuthenticationToken fails', async () => {
+            const error = new Error('Token fetch failed');
+            jest.spyOn(authToken, 'getAuthenticationToken').mockRejectedValue(error);
+            init({
+                thoughtSpotHost: 'tshost',
+                authType: AuthType.TrustedAuthTokenCookieless,
+                autoLogin: true,
+            });
+            await renderAndTriggerRefreshAuthToken();
+            await executeAfterWait(() => {
+                expect(authToken.getAuthenticationToken).toHaveBeenCalledWith(expect.any(Object), true);
+                // Check that logger.error was called with the token refresh error
+                const errorCalls = logger.error.mock.calls.filter((call) => { var _a, _b; return ((_a = call[0]) === null || _a === void 0 ? void 0 : _a.includes(ERROR_MESSAGE.INVALID_TOKEN_ERROR)) && ((_b = call[0]) === null || _b === void 0 ? void 0 : _b.includes('Token fetch failed')); });
+                expect(errorCalls.length).toBeGreaterThan(0);
+                expect(processData.processAuthFailure).toHaveBeenCalledWith(error, expect.any(Element));
+                expect(mockPort.postMessage).not.toHaveBeenCalled();
+            });
+        });
+    });
     describe('Fullscreen Change Handler', () => {
         beforeEach(() => {
             document.body.innerHTML = getDocumentBody();
@@ -2610,6 +2688,47 @@ describe('Unit test case for ts embed', () => {
             searchEmbed['executeAfterEmbedContainerLoaded'](callback3);
             expect(callback3).toHaveBeenCalledTimes(1);
         });
+        describe('getCurrentContext', () => {
+            const mockContext = {
+                stack: [
+                    {
+                        name: 'Liveboard',
+                        type: 'Liveboard',
+                        objectIds: { liveboardId: 'lb-123' },
+                    },
+                ],
+                currentContext: {
+                    name: 'Liveboard',
+                    type: 'Liveboard',
+                    objectIds: { liveboardId: 'lb-123' },
+                },
+            };
+            test('should return context when embed container is already loaded', async () => {
+                const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+                searchEmbed.isEmbedContainerLoaded = true;
+                const triggerSpy = jest.spyOn(searchEmbed, 'trigger')
+                    .mockResolvedValue(mockContext);
+                const context = await searchEmbed.getCurrentContext();
+                expect(context).toEqual(mockContext);
+                expect(triggerSpy).toHaveBeenCalledWith(HostEvent.GetPageContext, {});
+            });
+            test('should wait for embed container to load before returning context', async () => {
+                const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+                searchEmbed.isEmbedContainerLoaded = false;
+                const triggerSpy = jest.spyOn(searchEmbed, 'trigger')
+                    .mockResolvedValue(mockContext);
+                const contextPromise = searchEmbed.getCurrentContext();
+                // Context should not be resolved yet
+                await executeAfterWait(() => {
+                    expect(triggerSpy).not.toHaveBeenCalled();
+                }, 10);
+                // Simulate embed container becoming ready
+                searchEmbed['executeEmbedContainerReadyCallbacks']();
+                const context = await contextPromise;
+                expect(context).toEqual(mockContext);
+                expect(triggerSpy).toHaveBeenCalledWith(HostEvent.GetPageContext, {});
+            });
+        });
         test('should register embed container event handlers during construction', () => {
             const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
             // Check that the event handlers are registered
@@ -3324,7 +3443,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', () => {
@@ -3358,7 +3477,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 () => {
@@ -3425,9 +3544,9 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
         });
         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 () => {
@@ -3451,7 +3570,7 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
         });
         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: 'original-lb',
                 visibleVizs: ['viz-1'],
                 runtimeFilters: [
@@ -3466,7 +3585,7 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
                         values: ['North'],
                     },
                 ],
-            }));
+            }), undefined);
         });
     });
     test('should trigger UpdateEmbedParams with updated config', async () => {
@@ -3494,7 +3613,7 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
         });
         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: 'original-lb',
                 visibleVizs: ['viz-1', 'viz-2'],
                 runtimeFilters: [
@@ -3504,7 +3623,7 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
                         values: ['North'],
                     },
                 ],
-            }));
+            }), undefined);
         });
     });
     test('should handle error when getUpdateEmbedParamsObject fails during showPreRender', async () => {