@thoughtspot/visual-embed-sdk 1.44.1 → 1.44.3

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

@@ -29,6 +29,8 @@ import {
     CustomActionTarget,
     CustomActionsPosition,
     DefaultAppInitData,
+    ErrorDetailsTypes,
+    EmbedErrorCodes,
 } from '../types';
 import {
     executeAfterWait,
@@ -87,7 +89,7 @@ const hideBydefault = `&hideAction=${fixedEncodeURI(
 const defaultParamsWithHiddenActions = defaultParamsWithoutHiddenActions + hideBydefault;
 
 beforeAll(() => {
-    spyOn(window, 'alert');
+    jest.spyOn(window, 'alert').mockImplementation(() => {});
 });
 
 const customisations = {
@@ -150,7 +152,7 @@ describe('Unit test case for ts embed', () => {
     });
 
     beforeAll(() => {
-        jest.spyOn(authInstance, 'postLoginService').mockResolvedValue(true);
+        jest.spyOn(authInstance, 'postLoginService').mockResolvedValue(undefined);
     });
 
     describe('Vaidate iframe properties', () => {
@@ -291,7 +293,7 @@ describe('Unit test case for ts embed', () => {
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await executeAfterWait(() => {
-                expect(baseInstance.notifyAuthFailure).toBeCalledWith(
+                expect(baseInstance.notifyAuthFailure).toHaveBeenCalledWith(
                     authInstance.AuthFailureType.EXPIRY,
                 );
                 expect(baseInstance.handleAuth).not.toHaveBeenCalled();
@@ -328,7 +330,7 @@ describe('Unit test case for ts embed', () => {
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await executeAfterWait(() => {
-                expect(baseInstance.notifyAuthFailure).toBeCalledWith(
+                expect(baseInstance.notifyAuthFailure).toHaveBeenCalledWith(
                     authInstance.AuthFailureType.EXPIRY,
                 );
                 expect(mockPort.postMessage).not.toHaveBeenCalledWith({
@@ -723,7 +725,7 @@ describe('Unit test case for ts embed', () => {
             }, 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' },
@@ -743,10 +745,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);
         });
     });
 
@@ -1011,7 +1010,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(() => {
@@ -1087,14 +1086,14 @@ describe('Unit test case for ts embed', () => {
             const mockPort: any = {
                 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(
+                expect(baseInstance.notifyAuthFailure).toHaveBeenCalledWith(
                     authInstance.AuthFailureType.EXPIRY,
                 );
                 expect(loggerSpy).toHaveBeenCalledTimes(1);
@@ -1116,7 +1115,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: any = {
                 postMessage: jest.fn(),
             };
@@ -1127,7 +1126,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(
+                expect(baseInstance.notifyAuthFailure).toHaveBeenCalledWith(
                     authInstance.AuthFailureType.EXPIRY,
                 );
                 expect(loggerSpy).toHaveBeenCalledTimes(1);
@@ -1161,7 +1160,7 @@ describe('Unit test case for ts embed', () => {
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload);
             });
             await executeAfterWait(() => {
-                expect(baseInstance.notifyAuthFailure).toBeCalledWith(
+                expect(baseInstance.notifyAuthFailure).toHaveBeenCalledWith(
                     authInstance.AuthFailureType.EXPIRY,
                 );
                 expect(baseInstance.handleAuth).toHaveBeenCalled();
@@ -1188,7 +1187,7 @@ describe('Unit test case for ts embed', () => {
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload);
             });
             await executeAfterWait(() => {
-                expect(baseInstance.notifyAuthFailure).toBeCalledWith(
+                expect(baseInstance.notifyAuthFailure).toHaveBeenCalledWith(
                     authInstance.AuthFailureType.EXPIRY,
                 );
                 expect(baseInstance.handleAuth).not.toHaveBeenCalled();
@@ -1208,13 +1207,11 @@ describe('Unit test case for ts embed', () => {
         const setup = async (isLoggedIn = false) => {
             jest.spyOn(window, 'addEventListener').mockImplementationOnce(
                 (event, handler, options) => {
-                    handler({
-                        data: {
-                            type: 'xyz',
-                        },
+                    (handler as EventListener)({
+                        data: { type: 'xyz' },
                         ports: [3000],
                         source: null,
-                    });
+                    } as any);
                 },
             );
             const iFrame: any = document.createElement('div');
@@ -1224,7 +1221,7 @@ describe('Unit test case for ts embed', () => {
             tsEmbed.on(EmbedEvent.CustomAction, jest.fn());
             jest.spyOn(iFrame, 'addEventListener').mockImplementationOnce(
                 (event, handler, options) => {
-                    handler({});
+                    (handler as EventListener)({} as Event);
                 },
             );
             jest.spyOn(document, 'createElement').mockReturnValueOnce(iFrame);
@@ -1233,8 +1230,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(
+            expect(mockMixPanelEvent).toHaveBeenCalledWith(MIXPANEL_EVENT.VISUAL_SDK_RENDER_START);
+            expect(mockMixPanelEvent).toHaveBeenCalledWith(
                 MIXPANEL_EVENT.VISUAL_SDK_RENDER_COMPLETE,
                 expect.objectContaining({
                     elWidth: 0,
@@ -1249,12 +1246,9 @@ describe('Unit test case for ts embed', () => {
             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');
         });
     });
 
@@ -1271,13 +1265,11 @@ describe('Unit test case for ts embed', () => {
         const setup = async (isLoggedIn = false, overrideOrgId: number | undefined = undefined) => {
             jest.spyOn(window, 'addEventListener').mockImplementationOnce(
                 (event, handler, options) => {
-                    handler({
-                        data: {
-                            type: 'xyz',
-                        },
+                    (handler as EventListener)({
+                        data: { type: 'xyz' },
                         ports: [3000],
                         source: null,
-                    });
+                    } as any);
                 },
             );
             mockProcessTrigger.mockResolvedValueOnce({ session: 'test' });
@@ -1313,7 +1305,7 @@ describe('Unit test case for ts embed', () => {
             tsEmbed.on(EmbedEvent.CustomAction, jest.fn());
             jest.spyOn(iFrame, 'addEventListener').mockImplementationOnce(
                 (event, handler, options) => {
-                    handler({});
+                    (handler as EventListener)({} as Event);
                 },
             );
             jest.spyOn(document, 'createElement').mockReturnValueOnce(iFrame);
@@ -1375,11 +1367,11 @@ describe('Unit test case for ts embed', () => {
         ) => {
             jest.spyOn(window, 'addEventListener').mockImplementationOnce(
                 (event, handler, options) => {
-                    handler({
+                    (handler as EventListener)({
                         data: { type: 'xyz' },
                         ports: [3000],
                         source: null,
-                    });
+                    } as any);
                 },
             );
             mockProcessTrigger.mockResolvedValueOnce({ session: 'test' });
@@ -1396,7 +1388,7 @@ describe('Unit test case for ts embed', () => {
                     .mockImplementation(jest.fn());
             } else {
                 mockGetPreauthInfo = jest.spyOn(sessionInfoService, 'getPreauthInfo')
-                    .mockResolvedValue({ info: { test: 'data' } });
+                 .mockResolvedValue({ info: { test: 'data' } } as any);
             }
 
             const mockPreauthInfoFetch = jest.spyOn(authService, 'fetchPreauthInfoService')
@@ -1441,7 +1433,7 @@ describe('Unit test case for ts embed', () => {
             };
             jest.spyOn(iFrame, 'addEventListener').mockImplementationOnce(
                 (event, handler, options) => {
-                    handler({});
+                    (handler as EventListener)({} as Event);
                 },
             );
             jest.spyOn(document, 'createElement').mockReturnValueOnce(iFrame);
@@ -1590,13 +1582,13 @@ describe('Unit test case for ts embed', () => {
             const iFrame: any = 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',
             });
         });
@@ -1604,7 +1596,7 @@ describe('Unit test case for ts embed', () => {
 
     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],
@@ -1613,9 +1605,12 @@ describe('Unit test case for ts embed', () => {
             } as LiveboardViewConfig);
             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(), {
@@ -1636,7 +1631,7 @@ describe('Unit test case for ts embed', () => {
             hiddenActions: Array<Action>,
             visibleActions: Array<Action>,
         ) {
-            spyOn(logger, 'error');
+            jest.spyOn(logger, 'error');
             const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
                 hiddenActions,
                 visibleActions,
@@ -1645,9 +1640,12 @@ describe('Unit test case for ts embed', () => {
             } as LiveboardViewConfig);
             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]);
@@ -1681,7 +1679,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],
@@ -1690,9 +1688,12 @@ describe('Unit test case for ts embed', () => {
             } as LiveboardViewConfig);
             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(), {
@@ -1713,7 +1714,7 @@ describe('Unit test case for ts embed', () => {
             hiddenTabs: Array<string>,
             visibleTabs: Array<string>,
         ) {
-            spyOn(logger, 'error');
+            jest.spyOn(logger, 'error');
             const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
                 hiddenTabs,
                 visibleTabs,
@@ -1722,9 +1723,12 @@ describe('Unit test case for ts embed', () => {
             } as LiveboardViewConfig);
             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]);
@@ -1766,13 +1770,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,
+            });
         });
     });
 
@@ -1782,7 +1789,7 @@ describe('Unit test case for ts embed', () => {
         });
 
         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();
@@ -1840,7 +1847,7 @@ describe('Unit test case for ts embed', () => {
         });
 
         test('navigateToPage function use before render', async () => {
-            spyOn(logger, 'log');
+            jest.spyOn(logger, 'log');
             const appEmbed = new AppEmbed(getRootEl(), {
                 frameParams: {
                     width: '100%',
@@ -2075,7 +2082,7 @@ describe('Unit test case for ts embed', () => {
                 `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',
@@ -2089,11 +2096,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 () => {
@@ -2291,8 +2295,7 @@ describe('Unit test case for ts embed', () => {
         beforeAll(() => {
             delete window.location;
             (window as any).location = {
-                hash: '',
-                search: '',
+                assign: jest.fn(),
             };
         });
 
@@ -2369,7 +2372,7 @@ describe('Unit test case for ts embed', () => {
 
         afterAll(() => {
             const rootEle = document.getElementById('myRoot');
-            rootEle.remove();
+            rootEle?.remove();
             jest.clearAllMocks();
         });
 
@@ -2412,9 +2415,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([
                 {
@@ -2442,7 +2445,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',
             });
@@ -2475,7 +2478,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);
         });
@@ -2514,8 +2517,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);
@@ -2552,7 +2555,7 @@ describe('Unit test case for ts embed', () => {
                 preRenderId: 'test',
             });
             await libEmbed.syncPreRenderStyle();
-            expect(logger.error).toBeCalledWith(
+            expect(logger.error).toHaveBeenCalledWith(
                 'PreRender should be called before using syncPreRenderStyle',
             );
             (logger.error as any).mockClear();
@@ -2590,7 +2593,7 @@ describe('Unit test case for ts embed', () => {
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
             });
             await executeAfterWait(() => {
-                expect(baseInstance.notifyAuthFailure).toBeCalledWith(
+                expect(baseInstance.notifyAuthFailure).toHaveBeenCalledWith(
                     authInstance.AuthFailureType.IDLE_SESSION_TIMEOUT,
                 );
                 expect(baseInstance.handleAuth).toHaveBeenCalled();
@@ -2620,14 +2623,14 @@ describe('Unit test case for ts embed', () => {
             const mockPort: any = {
                 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(
+                expect(baseInstance.notifyAuthFailure).toHaveBeenCalledWith(
                     authInstance.AuthFailureType.IDLE_SESSION_TIMEOUT,
                 );
                 expect(loggerSpy).toHaveBeenCalledTimes(1);
@@ -2657,13 +2660,13 @@ describe('Unit test case for ts embed', () => {
             const mockPort: any = {
                 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(
+                expect(baseInstance.notifyAuthFailure).toHaveBeenCalledWith(
                     authInstance.AuthFailureType.IDLE_SESSION_TIMEOUT,
                 );
                 expect(loggerSpy).toHaveBeenCalledTimes(0);
@@ -2675,7 +2678,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');
@@ -3490,7 +3493,7 @@ describe('Unit test case for ts embed', () => {
 
         test('should execute callbacks through executeEvent function', async () => {
             let capturedExecuteEvent: any;
-            mockHandleInterceptEvent.mockImplementation((params) => {
+            mockHandleInterceptEvent.mockImplementation(async (params) => {
                 capturedExecuteEvent = params.executeEvent;
             });
 
@@ -3531,7 +3534,7 @@ describe('Unit test case for ts embed', () => {
 
         test('should call triggerUIPassThrough through getUnsavedAnswerTml function', async () => {
             let capturedGetUnsavedAnswerTml: any;
-            mockHandleInterceptEvent.mockImplementation((params) => {
+            mockHandleInterceptEvent.mockImplementation(async (params) => {
                 capturedGetUnsavedAnswerTml = params.getUnsavedAnswerTml;
             });
 
@@ -3715,7 +3718,7 @@ describe('Unit test case for ts embed', () => {
 
         test('should pass eventPort to executeCallbacks', async () => {
             let capturedExecuteEvent: any;
-            mockHandleInterceptEvent.mockImplementation((params) => {
+            mockHandleInterceptEvent.mockImplementation(async (params) => {
                 capturedExecuteEvent = params.executeEvent;
             });
 
@@ -3756,7 +3759,7 @@ describe('Unit test case for ts embed', () => {
 
         test('should handle getUnsavedAnswerTml with empty response', async () => {
             let capturedGetUnsavedAnswerTml: any;
-            mockHandleInterceptEvent.mockImplementation((params) => {
+            mockHandleInterceptEvent.mockImplementation(async (params) => {
                 capturedGetUnsavedAnswerTml = params.getUnsavedAnswerTml;
             });
 
@@ -3829,3 +3832,333 @@ 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: any = { 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 as any);
+            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?.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?.remove();
+    });
+
+    test('should trigger UpdateEmbedParams when showPreRender connects to existing prerendered component', async () => {
+        createRootEleForEmbed();
+        mockMessageChannel();
+
+        (window as any).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',
+                }),
+            );
+        });
+    });
+});