@thoughtspot/visual-embed-sdk 1.44.1 → 1.44.3

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

@@ -2,7 +2,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 { Action, HomeLeftNavItem, RuntimeFilterOp, HomepageModule, HostEvent, ContextMenuTriggerOptions, CustomActionTarget, CustomActionsPosition, } from '../types';
+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';
 import * as embedConfig from './embedConfig';
@@ -40,7 +40,7 @@ export const defaultParams = `&${defaultParamsWithoutHiddenActions}&hideAction=[
 const hideBydefault = `&hideAction=${fixedEncodeURI(JSON.stringify([Action.ReportError, ...HiddenActionItemByDefaultForSearchEmbed]))}`;
 const defaultParamsWithHiddenActions = defaultParamsWithoutHiddenActions + hideBydefault;
 beforeAll(() => {
-    spyOn(window, 'alert');
+    jest.spyOn(window, 'alert').mockImplementation(() => { });
 });
 const customisations = {
     style: {
@@ -96,7 +96,7 @@ describe('Unit test case for ts embed', () => {
         resetCachedAuthToken();
     });
     beforeAll(() => {
-        jest.spyOn(authInstance, 'postLoginService').mockResolvedValue(true);
+        jest.spyOn(authInstance, 'postLoginService').mockResolvedValue(undefined);
     });
     describe('Vaidate iframe properties', () => {
         beforeAll(() => {
@@ -204,7 +204,7 @@ describe('Unit test case for ts embed', () => {
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await executeAfterWait(() => {
-                expect(baseInstance.notifyAuthFailure).toBeCalledWith(authInstance.AuthFailureType.EXPIRY);
+                expect(baseInstance.notifyAuthFailure).toHaveBeenCalledWith(authInstance.AuthFailureType.EXPIRY);
                 expect(baseInstance.handleAuth).not.toHaveBeenCalled();
                 expect(mockPort.postMessage).toHaveBeenCalledWith({
                     type: EmbedEvent.AuthExpire,
@@ -236,7 +236,7 @@ describe('Unit test case for ts embed', () => {
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await executeAfterWait(() => {
-                expect(baseInstance.notifyAuthFailure).toBeCalledWith(authInstance.AuthFailureType.EXPIRY);
+                expect(baseInstance.notifyAuthFailure).toHaveBeenCalledWith(authInstance.AuthFailureType.EXPIRY);
                 expect(mockPort.postMessage).not.toHaveBeenCalledWith({
                     type: EmbedEvent.AuthExpire,
                     data: { authToken: 'test_auth_token2' },
@@ -588,7 +588,7 @@ describe('Unit test case for ts embed', () => {
                 expect(iframe.contentWindow.postMessage).toHaveBeenCalledTimes(0);
             }, 1000);
         });
-        test('should remove event listener when called off method', async (done) => {
+        test('should remove event listener when called off method', async () => {
             const mockEmbedEventPayload = {
                 type: EmbedEvent.Save,
                 data: { answerId: '123' },
@@ -606,10 +606,7 @@ describe('Unit test case for ts embed', () => {
                 const iframe = getIFrameEl();
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload);
             });
-            await executeAfterWait(() => {
-                expect(mockFn).toHaveBeenCalledTimes(1);
-                done();
-            }, 100);
+            expect(mockFn).toHaveBeenCalledTimes(1);
         });
     });
     describe('Appinit embedEvent in cookieless authentication authType', () => {
@@ -850,7 +847,7 @@ describe('Unit test case for ts embed', () => {
                 authType: AuthType.TrustedAuthTokenCookieless,
                 getAuthToken: () => Promise.reject(),
             });
-            jest.spyOn(logger, 'error').mockResolvedValue(true);
+            jest.spyOn(logger, 'error').mockImplementation(() => { });
         });
         afterEach(() => {
             jest.clearAllMocks();
@@ -917,14 +914,14 @@ describe('Unit test case for ts embed', () => {
             const mockPort = {
                 postMessage: jest.fn(),
             };
-            const loggerSpy = jest.spyOn(logger, 'error').mockResolvedValueOnce(true);
+            const loggerSpy = jest.spyOn(logger, 'error').mockImplementation(() => { });
             await executeAfterWait(() => {
                 const iframe = getIFrameEl();
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await executeAfterWait(() => {
                 expect(getRootEl().innerHTML).toContain('Not logged in');
-                expect(baseInstance.notifyAuthFailure).toBeCalledWith(authInstance.AuthFailureType.EXPIRY);
+                expect(baseInstance.notifyAuthFailure).toHaveBeenCalledWith(authInstance.AuthFailureType.EXPIRY);
                 expect(loggerSpy).toHaveBeenCalledTimes(1);
             });
             jest.spyOn(authService, 'verifyTokenService').mockClear();
@@ -941,7 +938,7 @@ describe('Unit test case for ts embed', () => {
             const searchEmbed = new SearchEmbed(getRootEl(), { ...defaultViewConfig, preRenderId: 'test' });
             jest.spyOn(baseInstance, 'notifyAuthFailure');
             searchEmbed.preRender();
-            const loggerSpy = jest.spyOn(logger, 'error').mockResolvedValueOnce(true);
+            const loggerSpy = jest.spyOn(logger, 'error').mockImplementation(() => { });
             const mockPort = {
                 postMessage: jest.fn(),
             };
@@ -952,7 +949,7 @@ describe('Unit test case for ts embed', () => {
             const preRenderWrapper = document.getElementById('tsEmbed-pre-render-wrapper-test');
             await executeAfterWait(() => {
                 expect(preRenderWrapper.innerHTML).toContain('Not logged in');
-                expect(baseInstance.notifyAuthFailure).toBeCalledWith(authInstance.AuthFailureType.EXPIRY);
+                expect(baseInstance.notifyAuthFailure).toHaveBeenCalledWith(authInstance.AuthFailureType.EXPIRY);
                 expect(loggerSpy).toHaveBeenCalledTimes(1);
             });
             jest.spyOn(authService, 'verifyTokenService').mockClear();
@@ -982,7 +979,7 @@ describe('Unit test case for ts embed', () => {
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload);
             });
             await executeAfterWait(() => {
-                expect(baseInstance.notifyAuthFailure).toBeCalledWith(authInstance.AuthFailureType.EXPIRY);
+                expect(baseInstance.notifyAuthFailure).toHaveBeenCalledWith(authInstance.AuthFailureType.EXPIRY);
                 expect(baseInstance.handleAuth).toHaveBeenCalled();
             });
         });
@@ -1007,7 +1004,7 @@ describe('Unit test case for ts embed', () => {
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload);
             });
             await executeAfterWait(() => {
-                expect(baseInstance.notifyAuthFailure).toBeCalledWith(authInstance.AuthFailureType.EXPIRY);
+                expect(baseInstance.notifyAuthFailure).toHaveBeenCalledWith(authInstance.AuthFailureType.EXPIRY);
                 expect(baseInstance.handleAuth).not.toHaveBeenCalled();
             });
         });
@@ -1023,9 +1020,7 @@ describe('Unit test case for ts embed', () => {
         const setup = async (isLoggedIn = false) => {
             jest.spyOn(window, 'addEventListener').mockImplementationOnce((event, handler, options) => {
                 handler({
-                    data: {
-                        type: 'xyz',
-                    },
+                    data: { type: 'xyz' },
                     ports: [3000],
                     source: null,
                 });
@@ -1043,8 +1038,8 @@ describe('Unit test case for ts embed', () => {
         };
         test('mixpanel should call with VISUAL_SDK_RENDER_COMPLETE', async () => {
             await setup(true);
-            expect(mockMixPanelEvent).toBeCalledWith(MIXPANEL_EVENT.VISUAL_SDK_RENDER_START);
-            expect(mockMixPanelEvent).toBeCalledWith(MIXPANEL_EVENT.VISUAL_SDK_RENDER_COMPLETE, expect.objectContaining({
+            expect(mockMixPanelEvent).toHaveBeenCalledWith(MIXPANEL_EVENT.VISUAL_SDK_RENDER_START);
+            expect(mockMixPanelEvent).toHaveBeenCalledWith(MIXPANEL_EVENT.VISUAL_SDK_RENDER_COMPLETE, expect.objectContaining({
                 elWidth: 0,
                 elHeight: 0,
             }));
@@ -1054,12 +1049,9 @@ describe('Unit test case for ts embed', () => {
             const prefetchIframe = document.querySelectorAll('.prefetchIframe');
             expect(prefetchIframe.length).toBe(0);
         });
-        test('Should render failure when login fails', async (done) => {
-            setup(false);
-            executeAfterWait(() => {
-                expect(getRootEl().innerHTML).toContain('Failed to Login');
-                done();
-            });
+        test('Should render failure when login fails', async () => {
+            await setup(false);
+            expect(getRootEl().innerHTML).toContain('Failed to Login');
         });
     });
     describe('Trigger infoSuccess event on iframe load', () => {
@@ -1074,9 +1066,7 @@ describe('Unit test case for ts embed', () => {
         const setup = async (isLoggedIn = false, overrideOrgId = undefined) => {
             jest.spyOn(window, 'addEventListener').mockImplementationOnce((event, handler, options) => {
                 handler({
-                    data: {
-                        type: 'xyz',
-                    },
+                    data: { type: 'xyz' },
                     ports: [3000],
                     source: null,
                 });
@@ -1309,19 +1299,19 @@ describe('Unit test case for ts embed', () => {
             const iFrame = document.createElement('div');
             iFrame.contentWindow = null;
             jest.spyOn(document, 'createElement').mockReturnValueOnce(iFrame);
-            spyOn(logger, 'error');
+            jest.spyOn(logger, 'error');
             await tsEmbed.render();
         });
         test('mixpanel should call with VISUAL_SDK_RENDER_FAILED', () => {
-            expect(mockMixPanelEvent).toBeCalledWith(MIXPANEL_EVENT.VISUAL_SDK_RENDER_START);
-            expect(mockMixPanelEvent).toBeCalledWith(MIXPANEL_EVENT.VISUAL_SDK_RENDER_FAILED, {
+            expect(mockMixPanelEvent).toHaveBeenCalledWith(MIXPANEL_EVENT.VISUAL_SDK_RENDER_START);
+            expect(mockMixPanelEvent).toHaveBeenCalledWith(MIXPANEL_EVENT.VISUAL_SDK_RENDER_FAILED, {
                 error: 'false',
             });
         });
     });
     describe('when visible actions are set', () => {
         test('should throw error when there are both visible and hidden actions - pinboard', async () => {
-            spyOn(logger, 'error');
+            jest.spyOn(logger, 'error');
             const pinboardEmbed = new PinboardEmbed(getRootEl(), {
                 hiddenActions: [Action.DownloadAsCsv],
                 visibleActions: [Action.DownloadAsCsv],
@@ -1330,7 +1320,12 @@ describe('Unit test case for ts embed', () => {
             });
             await pinboardEmbed.render();
             expect(pinboardEmbed['isError']).toBe(true);
-            expect(logger.error).toHaveBeenCalledWith('You cannot have both hidden actions and visible actions');
+            expect(logger.error).toHaveBeenCalledWith({
+                errorType: ErrorDetailsTypes.VALIDATION_ERROR,
+                message: ERROR_MESSAGE.CONFLICTING_ACTIONS_CONFIG,
+                code: EmbedErrorCodes.CONFLICTING_ACTIONS_CONFIG,
+                error: ERROR_MESSAGE.CONFLICTING_ACTIONS_CONFIG,
+            });
         });
         test('should not throw error when there are only visible or hidden actions - pinboard', async () => {
             const pinboardEmbed = new PinboardEmbed(getRootEl(), {
@@ -1347,7 +1342,7 @@ describe('Unit test case for ts embed', () => {
          * @param visibleActions
          */
         async function testActionsForLiveboards(hiddenActions, visibleActions) {
-            spyOn(logger, 'error');
+            jest.spyOn(logger, 'error');
             const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
                 hiddenActions,
                 visibleActions,
@@ -1356,7 +1351,12 @@ describe('Unit test case for ts embed', () => {
             });
             await liveboardEmbed.render();
             expect(liveboardEmbed['isError']).toBe(true);
-            expect(logger.error).toHaveBeenCalledWith('You cannot have both hidden actions and visible actions');
+            expect(logger.error).toHaveBeenCalledWith({
+                errorType: ErrorDetailsTypes.VALIDATION_ERROR,
+                message: ERROR_MESSAGE.CONFLICTING_ACTIONS_CONFIG,
+                code: EmbedErrorCodes.CONFLICTING_ACTIONS_CONFIG,
+                error: ERROR_MESSAGE.CONFLICTING_ACTIONS_CONFIG,
+            });
         }
         test('should throw error when there are both visible and hidden action arrays', async () => {
             await testActionsForLiveboards([Action.DownloadAsCsv], [Action.DownloadAsCsv]);
@@ -1388,7 +1388,7 @@ describe('Unit test case for ts embed', () => {
     });
     describe('when visible Tabs are set', () => {
         test('should throw error when there are both visible and hidden Tabs - pinboard', async () => {
-            spyOn(logger, 'error');
+            jest.spyOn(logger, 'error');
             const pinboardEmbed = new PinboardEmbed(getRootEl(), {
                 visibleTabs: [tabId1],
                 hiddenTabs: [tabId2],
@@ -1397,7 +1397,12 @@ describe('Unit test case for ts embed', () => {
             });
             await pinboardEmbed.render();
             expect(pinboardEmbed['isError']).toBe(true);
-            expect(logger.error).toHaveBeenCalledWith('You cannot have both hidden Tabs and visible Tabs');
+            expect(logger.error).toHaveBeenCalledWith({
+                errorType: ErrorDetailsTypes.VALIDATION_ERROR,
+                message: ERROR_MESSAGE.CONFLICTING_TABS_CONFIG,
+                code: EmbedErrorCodes.CONFLICTING_TABS_CONFIG,
+                error: ERROR_MESSAGE.CONFLICTING_TABS_CONFIG,
+            });
         });
         test('should not throw error when there are only visible or hidden Tabs - pinboard', async () => {
             const pinboardEmbed = new PinboardEmbed(getRootEl(), {
@@ -1414,7 +1419,7 @@ describe('Unit test case for ts embed', () => {
          * @param visibleTabs
          */
         async function testTabsForLiveboards(hiddenTabs, visibleTabs) {
-            spyOn(logger, 'error');
+            jest.spyOn(logger, 'error');
             const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
                 hiddenTabs,
                 visibleTabs,
@@ -1423,7 +1428,12 @@ describe('Unit test case for ts embed', () => {
             });
             await liveboardEmbed.render();
             expect(liveboardEmbed['isError']).toBe(true);
-            expect(logger.error).toHaveBeenCalledWith('You cannot have both hidden Tabs and visible Tabs');
+            expect(logger.error).toHaveBeenCalledWith({
+                errorType: ErrorDetailsTypes.VALIDATION_ERROR,
+                message: ERROR_MESSAGE.CONFLICTING_TABS_CONFIG,
+                code: EmbedErrorCodes.CONFLICTING_TABS_CONFIG,
+                error: ERROR_MESSAGE.CONFLICTING_TABS_CONFIG,
+            });
         }
         test('should throw error when there are both visible and hidden Tab arrays', async () => {
             await testTabsForLiveboards([tabId1], [tabId2]);
@@ -1462,11 +1472,16 @@ describe('Unit test case for ts embed', () => {
             });
         });
         test('Error should be true', async () => {
-            spyOn(logger, 'error');
+            jest.spyOn(logger, 'error');
             const tsEmbed = new SearchEmbed(getRootEl(), {});
             await tsEmbed.render();
             expect(tsEmbed['isError']).toBe(true);
-            expect(logger.error).toHaveBeenCalledWith('You need to init the ThoughtSpot SDK module first');
+            expect(logger.error).toHaveBeenCalledWith({
+                errorType: ErrorDetailsTypes.VALIDATION_ERROR,
+                message: ERROR_MESSAGE.INIT_SDK_REQUIRED,
+                code: EmbedErrorCodes.INIT_ERROR,
+                error: ERROR_MESSAGE.INIT_SDK_REQUIRED,
+            });
         });
     });
     describe('V1Embed ', () => {
@@ -1474,7 +1489,7 @@ describe('Unit test case for ts embed', () => {
             jest.spyOn(config, 'getThoughtSpotHost').mockImplementation(() => 'http://tshost');
         });
         test('when isRendered is true than isError will be true', async () => {
-            spyOn(logger, 'warn');
+            jest.spyOn(logger, 'warn');
             const viEmbedIns = new tsEmbedInstance.V1Embed(getRootEl(), defaultViewConfig);
             expect(viEmbedIns['isError']).toBe(false);
             await viEmbedIns.render();
@@ -1518,7 +1533,7 @@ describe('Unit test case for ts embed', () => {
             expectUrlMatchesWithParams(getIFrameSrc(), `http://${thoughtSpotHost}/?embedApp=true&primaryNavHidden=true&profileAndHelpInNavBarHidden=false&${defaultParamsForPinboardEmbed}${defaultParamsPost}#/${path}`);
         });
         test('navigateToPage function use before render', async () => {
-            spyOn(logger, 'log');
+            jest.spyOn(logger, 'log');
             const appEmbed = new AppEmbed(getRootEl(), {
                 frameParams: {
                     width: '100%',
@@ -1722,7 +1737,7 @@ describe('Unit test case for ts embed', () => {
             await appEmbed.render();
             expectUrlMatchesWithParams(getIFrameSrc(), `http://${thoughtSpotHost}/?embedApp=true&primaryNavHidden=true&profileAndHelpInNavBarHidden=false&additionalPendoKey=1234${defaultParamsPost}#/home`);
         });
-        xit('Sets the forceSAMLAutoRedirect param', async (done) => {
+        xit('Sets the forceSAMLAutoRedirect param', async () => {
             jest.spyOn(baseInstance, 'getAuthPromise').mockResolvedValue(true);
             init({
                 thoughtSpotHost: 'tshost',
@@ -1735,11 +1750,8 @@ describe('Unit test case for ts embed', () => {
                 },
             });
             appEmbed.render();
-            await waitFor(() => !!getIFrameEl()).then(() => {
-                expect(getIFrameSrc()).toContain('authType=EmbeddedSSO');
-                expect(getIFrameSrc()).toContain('forceSAMLAutoRedirect=true');
-                done();
-            });
+            expect(getIFrameSrc()).toContain('authType=EmbeddedSSO');
+            expect(getIFrameSrc()).toContain('forceSAMLAutoRedirect=true');
         });
         it('Should set the override locale for number/date and currency format', async () => {
             jest.spyOn(baseInstance, 'getAuthPromise').mockResolvedValue(true);
@@ -1889,8 +1901,7 @@ describe('Unit test case for ts embed', () => {
         beforeAll(() => {
             delete window.location;
             window.location = {
-                hash: '',
-                search: '',
+                assign: jest.fn(),
             };
         });
         beforeEach(() => {
@@ -1960,7 +1971,7 @@ describe('Unit test case for ts embed', () => {
         });
         afterAll(() => {
             const rootEle = document.getElementById('myRoot');
-            rootEle.remove();
+            rootEle === null || rootEle === void 0 ? void 0 : rootEle.remove();
             jest.clearAllMocks();
         });
         it('should preRender and hide the iframe', async () => {
@@ -1994,9 +2005,9 @@ describe('Unit test case for ts embed', () => {
                     };
                 });
             // show preRender
-            const warnSpy = spyOn(logger, 'warn');
+            const warnSpy = jest.spyOn(logger, 'warn');
             libEmbed.showPreRender();
-            expect(warnSpy).toHaveBeenCalledTimes(0);
+            expect(warnSpy).toHaveBeenCalledTimes(1);
             resizeObserverCb([
                 {
                     target: tsEmbedDiv,
@@ -2017,7 +2028,7 @@ describe('Unit test case for ts embed', () => {
         });
         it('preRender called without preRenderId should log error ', () => {
             createRootEleForEmbed();
-            spyOn(logger, 'error');
+            jest.spyOn(logger, 'error');
             const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
                 liveboardId: 'myLiveboardId',
             });
@@ -2044,7 +2055,7 @@ describe('Unit test case for ts embed', () => {
                 preRenderId: 'i-am-preRendered',
                 liveboardId: 'myLiveboardId',
             });
-            spyOn(libEmbed, 'preRender');
+            jest.spyOn(libEmbed, 'preRender');
             libEmbed.hidePreRender();
             expect(libEmbed.preRender).toHaveBeenCalledTimes(0);
         });
@@ -2078,8 +2089,8 @@ describe('Unit test case for ts embed', () => {
             const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
                 liveboardId: 'myLiveboardId',
             });
-            spyOn(libEmbed, 'preRender');
-            spyOn(logger, 'error');
+            jest.spyOn(libEmbed, 'preRender');
+            jest.spyOn(logger, 'error');
             libEmbed.showPreRender();
             expect(libEmbed.preRender).toHaveBeenCalledTimes(0);
             expect(logger.error).toHaveBeenCalledTimes(1);
@@ -2109,7 +2120,7 @@ describe('Unit test case for ts embed', () => {
                 preRenderId: 'test',
             });
             await libEmbed.syncPreRenderStyle();
-            expect(logger.error).toBeCalledWith('PreRender should be called before using syncPreRenderStyle');
+            expect(logger.error).toHaveBeenCalledWith('PreRender should be called before using syncPreRenderStyle');
             logger.error.mockClear();
         });
     });
@@ -2142,7 +2153,7 @@ describe('Unit test case for ts embed', () => {
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await executeAfterWait(() => {
-                expect(baseInstance.notifyAuthFailure).toBeCalledWith(authInstance.AuthFailureType.IDLE_SESSION_TIMEOUT);
+                expect(baseInstance.notifyAuthFailure).toHaveBeenCalledWith(authInstance.AuthFailureType.IDLE_SESSION_TIMEOUT);
                 expect(baseInstance.handleAuth).toHaveBeenCalled();
                 expect(mockPort.postMessage).toHaveBeenCalledWith({
                     type: EmbedEvent.IdleSessionTimeout,
@@ -2168,14 +2179,14 @@ describe('Unit test case for ts embed', () => {
             const mockPort = {
                 postMessage: jest.fn(),
             };
-            const loggerSpy = jest.spyOn(logger, 'error').mockResolvedValueOnce(true);
+            const loggerSpy = jest.spyOn(logger, 'error').mockImplementation(() => { });
             await executeAfterWait(() => {
                 const iframe = getIFrameEl();
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await executeAfterWait(() => {
                 expect(getRootEl().innerHTML).toContain('Not logged in');
-                expect(baseInstance.notifyAuthFailure).toBeCalledWith(authInstance.AuthFailureType.IDLE_SESSION_TIMEOUT);
+                expect(baseInstance.notifyAuthFailure).toHaveBeenCalledWith(authInstance.AuthFailureType.IDLE_SESSION_TIMEOUT);
                 expect(loggerSpy).toHaveBeenCalledTimes(1);
             });
             jest.spyOn(authService, 'verifyTokenService').mockClear();
@@ -2200,13 +2211,13 @@ describe('Unit test case for ts embed', () => {
             const mockPort = {
                 postMessage: jest.fn(),
             };
-            const loggerSpy = jest.spyOn(logger, 'error').mockResolvedValueOnce(true);
+            const loggerSpy = jest.spyOn(logger, 'error').mockImplementation(() => { });
             await executeAfterWait(() => {
                 const iframe = getIFrameEl();
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await executeAfterWait(() => {
-                expect(baseInstance.notifyAuthFailure).toBeCalledWith(authInstance.AuthFailureType.IDLE_SESSION_TIMEOUT);
+                expect(baseInstance.notifyAuthFailure).toHaveBeenCalledWith(authInstance.AuthFailureType.IDLE_SESSION_TIMEOUT);
                 expect(loggerSpy).toHaveBeenCalledTimes(0);
             });
             jest.spyOn(authService, 'verifyTokenService').mockClear();
@@ -2214,7 +2225,7 @@ describe('Unit test case for ts embed', () => {
         });
     });
     describe('Renders should wait for init to completed', () => {
-        const errorSpy = jest.spyOn(logger, 'error').mockResolvedValue(true);
+        const errorSpy = jest.spyOn(logger, 'error').mockImplementation(() => { });
         beforeEach(() => {
             errorSpy.mockClear();
             resetValueFromWindow('initFlagKey');
@@ -2858,7 +2869,7 @@ describe('Unit test case for ts embed', () => {
         });
         test('should execute callbacks through executeEvent function', async () => {
             let capturedExecuteEvent;
-            mockHandleInterceptEvent.mockImplementation((params) => {
+            mockHandleInterceptEvent.mockImplementation(async (params) => {
                 capturedExecuteEvent = params.executeEvent;
             });
             const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
@@ -2891,7 +2902,7 @@ describe('Unit test case for ts embed', () => {
         });
         test('should call triggerUIPassThrough through getUnsavedAnswerTml function', async () => {
             let capturedGetUnsavedAnswerTml;
-            mockHandleInterceptEvent.mockImplementation((params) => {
+            mockHandleInterceptEvent.mockImplementation(async (params) => {
                 capturedGetUnsavedAnswerTml = params.getUnsavedAnswerTml;
             });
             const mockTmlResponse = { tml: 'test-tml-content' };
@@ -3041,7 +3052,7 @@ describe('Unit test case for ts embed', () => {
         });
         test('should pass eventPort to executeCallbacks', async () => {
             let capturedExecuteEvent;
-            mockHandleInterceptEvent.mockImplementation((params) => {
+            mockHandleInterceptEvent.mockImplementation(async (params) => {
                 capturedExecuteEvent = params.executeEvent;
             });
             const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
@@ -3074,7 +3085,7 @@ describe('Unit test case for ts embed', () => {
         });
         test('should handle getUnsavedAnswerTml with empty response', async () => {
             let capturedGetUnsavedAnswerTml;
-            mockHandleInterceptEvent.mockImplementation((params) => {
+            mockHandleInterceptEvent.mockImplementation(async (params) => {
                 capturedGetUnsavedAnswerTml = params.getUnsavedAnswerTml;
             });
             mockProcessTrigger.mockResolvedValue([]);
@@ -3132,4 +3143,257 @@ describe('Unit test case for ts embed', () => {
         });
     });
 });
+describe('Additional Coverage Tests', () => {
+    beforeAll(() => {
+        init({
+            thoughtSpotHost: 'tshost',
+            authType: AuthType.None,
+        });
+    });
+    test('should handle getAuthTokenForCookielessInit with non-cookieless auth', async () => {
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        const token = await searchEmbed['getAuthTokenForCookielessInit']();
+        expect(token).toBe('');
+    });
+    test('should call setIFrameHeight', async () => {
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        await searchEmbed.render();
+        await executeAfterWait(() => {
+            searchEmbed['setIFrameHeight'](500);
+            expect(getIFrameEl().style.height).toBe('500px');
+        });
+    });
+    test('should test getIframeCenter calculation', async () => {
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        await searchEmbed.render();
+        await executeAfterWait(() => {
+            const center = searchEmbed['getIframeCenter']();
+            expect(center).toHaveProperty('iframeCenter');
+            expect(center).toHaveProperty('iframeHeight');
+            expect(center).toHaveProperty('viewPortHeight');
+        });
+    });
+    test('should handle preRender with replaceExistingPreRender=true', async () => {
+        createRootEleForEmbed();
+        const embed1 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'test-replace',
+            liveboardId: 'lb1',
+        });
+        await embed1.preRender();
+        const embed2 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'test-replace',
+            liveboardId: 'lb2',
+        });
+        await embed2.preRender(false, true);
+        expect(document.getElementById('tsEmbed-pre-render-wrapper-test-replace')).toBeTruthy();
+    });
+    test('should test getIframeSrc base implementation', () => {
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        expect(searchEmbed.getIframeSrc()).toBe('');
+    });
+    test('should handle createEmbedEventResponder with OnBeforeGetVizDataIntercept', async () => {
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        const mockPort = { postMessage: jest.fn() };
+        const responder = searchEmbed['createEmbedEventResponder'](mockPort, EmbedEvent.OnBeforeGetVizDataIntercept);
+        responder({ data: 'test' });
+        expect(mockPort.postMessage).toHaveBeenCalled();
+    });
+    test('should clean up message event listeners', async () => {
+        const removeEventListenerSpy = jest.spyOn(window, 'removeEventListener');
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        await searchEmbed.render();
+        searchEmbed['unsubscribeToMessageEvents']();
+        expect(removeEventListenerSpy).toHaveBeenCalledWith('message', expect.any(Function));
+    });
+});
+describe('Trigger method edge cases', () => {
+    beforeAll(() => {
+        init({
+            thoughtSpotHost: 'tshost',
+            authType: AuthType.None,
+        });
+    });
+    beforeEach(() => {
+        document.body.innerHTML = getDocumentBody();
+    });
+    test('should handle error when trigger is called with undefined messageType', async () => {
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        jest.spyOn(logger, 'error');
+        await searchEmbed.render();
+        await executeAfterWait(async () => {
+            const result = await searchEmbed.trigger(undefined);
+            expect(result).toBeNull();
+            expect(logger.error).toHaveBeenCalledWith(expect.objectContaining({
+                errorType: ErrorDetailsTypes.VALIDATION_ERROR,
+                code: EmbedErrorCodes.HOST_EVENT_TYPE_UNDEFINED,
+            }));
+        });
+    });
+    test('should return null when trigger is called before iframe is ready', async () => {
+        jest.spyOn(baseInstance, 'getAuthPromise').mockRejectedValueOnce(new Error('Auth failed'));
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        jest.spyOn(logger, 'debug');
+        await searchEmbed.render();
+        await executeAfterWait(async () => {
+            const result = await searchEmbed.trigger(HostEvent.Reload);
+            expect(result).toBeNull();
+        });
+    });
+});
+describe('PreRender replaceExistingPreRender scenarios', () => {
+    beforeAll(() => {
+        init({
+            thoughtSpotHost: 'tshost',
+            authType: AuthType.None,
+        });
+    });
+    afterEach(() => {
+        const rootEle = document.getElementById('myRoot');
+        rootEle === null || rootEle === void 0 ? void 0 : rootEle.remove();
+    });
+    test('should skip re-rendering when preRender already exists and replaceExistingPreRender is false', async () => {
+        createRootEleForEmbed();
+        const embed1 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'no-replace-test',
+            liveboardId: 'lb1',
+        });
+        await embed1.preRender();
+        await waitFor(() => !!getIFrameEl());
+        const embed2 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'no-replace-test',
+            liveboardId: 'lb2',
+        });
+        const result = await embed2.preRender(false, false);
+        expect(result).toBe(embed2);
+        // The original iframe should still have lb1
+        const iframe = getIFrameEl();
+        expect(iframe.src).toContain('lb1');
+    });
+});
+describe('Destroy error handling', () => {
+    beforeAll(() => {
+        init({
+            thoughtSpotHost: 'tshost',
+            authType: AuthType.None,
+        });
+    });
+    beforeEach(() => {
+        document.body.innerHTML = getDocumentBody();
+    });
+    test('should handle error gracefully when destroy fails', async () => {
+        const appEmbed = new AppEmbed(getRootEl(), {
+            frameParams: { width: '100%', height: '100%' },
+        });
+        await appEmbed.render();
+        const logSpy = jest.spyOn(logger, 'log').mockImplementation(() => { });
+        jest.spyOn(Node.prototype, 'removeChild').mockImplementationOnce(() => {
+            throw new Error('Remove failed');
+        });
+        expect(() => {
+            appEmbed.destroy();
+        }).not.toThrow();
+        expect(logSpy).toHaveBeenCalledWith('Error destroying TS Embed', expect.any(Error));
+        logSpy.mockRestore();
+    });
+});
+describe('Fullscreen change handler behavior', () => {
+    beforeAll(() => {
+        init({
+            thoughtSpotHost: 'tshost',
+            authType: AuthType.None,
+            disableFullscreenPresentation: false,
+        });
+    });
+    beforeEach(() => {
+        document.body.innerHTML = getDocumentBody();
+    });
+    test('should trigger ExitPresentMode when exiting fullscreen', async () => {
+        const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            liveboardId: 'test-lb',
+        });
+        await liveboardEmbed.render();
+        await executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            expect(iframe).toBeTruthy();
+        });
+        mockProcessTrigger.mockResolvedValue({});
+        liveboardEmbed['setupFullscreenChangeHandler']();
+        Object.defineProperty(document, 'fullscreenElement', {
+            value: null,
+            writable: true,
+            configurable: true,
+        });
+        const event = new Event('fullscreenchange');
+        document.dispatchEvent(event);
+        await executeAfterWait(() => {
+            expect(mockProcessTrigger).toHaveBeenCalledWith(expect.any(Object), HostEvent.ExitPresentMode, expect.any(String), expect.any(Object));
+        });
+    });
+    test('should not trigger ExitPresentMode when entering fullscreen', async () => {
+        const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            liveboardId: 'test-lb-fullscreen',
+        });
+        await liveboardEmbed.render();
+        await executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            expect(iframe).toBeTruthy();
+        });
+        mockProcessTrigger.mockClear();
+        mockProcessTrigger.mockResolvedValue({});
+        liveboardEmbed['setupFullscreenChangeHandler']();
+        Object.defineProperty(document, 'fullscreenElement', {
+            value: getIFrameEl(),
+            writable: true,
+            configurable: true,
+        });
+        const event = new Event('fullscreenchange');
+        document.dispatchEvent(event);
+        await executeAfterWait(() => {
+            expect(mockProcessTrigger).not.toHaveBeenCalledWith(expect.any(Object), HostEvent.ExitPresentMode, expect.any(String), expect.any(Object));
+        });
+    });
+});
+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 () => {
+        createRootEleForEmbed();
+        mockMessageChannel();
+        window.ResizeObserver = window.ResizeObserver
+            || jest.fn().mockImplementation(() => ({
+                disconnect: jest.fn(),
+                observe: jest.fn(),
+                unobserve: jest.fn(),
+            }));
+        const embed1 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'update-params-test',
+            liveboardId: 'original-lb',
+        });
+        await embed1.preRender();
+        await waitFor(() => !!getIFrameEl());
+        embed1.isEmbedContainerLoaded = true;
+        mockProcessTrigger.mockClear();
+        mockProcessTrigger.mockResolvedValue({});
+        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({
+                liveboardId: 'updated-lb',
+            }));
+        });
+    });
+});
 //# sourceMappingURL=ts-embed.spec.js.map