@thoughtspot/visual-embed-sdk 1.44.1-test → 1.44.2

package/src/auth.spec.ts

@@ -145,20 +145,20 @@ describe('Unit test for auth', () => {
 
     test('Disable mixpanel when disableSDKTracking flag is set', () => {
         jest.spyOn(mixPanelService, 'initMixpanel');
-        jest.spyOn(SessionService, 'getSessionInfo').mockReturnValue(mockSessionInfo);
-        jest.spyOn(EmbedConfig, 'getEmbedConfig').mockReturnValue({ disableSDKTracking: true });
+        jest.spyOn(SessionService, 'getSessionInfo').mockReturnValue(mockSessionInfo as any);
+        jest.spyOn(EmbedConfig, 'getEmbedConfig').mockReturnValue({ disableSDKTracking: true } as any);
         authInstance.postLoginService();
-        expect(mixPanelService.initMixpanel).not.toBeCalled();
+        expect(mixPanelService.initMixpanel).not.toHaveBeenCalled();
     });
 
     test('Log error is postLogin faild', async () => {
         jest.spyOn(mixPanelService, 'initMixpanel');
         jest.spyOn(SessionService, 'getSessionInfo').mockRejectedValueOnce(mockSessionInfo);
-        jest.spyOn(EmbedConfig, 'getEmbedConfig').mockReturnValue({ disableSDKTracking: true });
-        jest.spyOn(logger, 'error').mockResolvedValue(true);
+        jest.spyOn(EmbedConfig, 'getEmbedConfig').mockReturnValue({ disableSDKTracking: true } as any);
+        jest.spyOn(logger, 'error').mockImplementation(() => {});
         await authInstance.postLoginService();
-        expect(mixPanelService.initMixpanel).not.toBeCalled();
-        expect(logger.error).toBeCalled();
+        expect(mixPanelService.initMixpanel).not.toHaveBeenCalled();
+        expect(logger.error).toHaveBeenCalled();
     });
 
     test('doCookielessTokenAuth: when authEndpoint and getAuthToken are not there, it throw error', async () => {
@@ -187,7 +187,7 @@ describe('Unit test for auth', () => {
         const getAuthenticationTokenMock = jest.spyOn(authTokenService, 'getAuthenticationToken');
         jest.spyOn(tokenAuthService, 'isActiveService').mockImplementation(async () => true);
         await authInstance.doTokenAuth(embedConfig.doTokenAuthSuccess('authToken'));
-        expect(authTokenService.getAuthenticationToken).not.toBeCalled();
+        expect(authTokenService.getAuthenticationToken).not.toHaveBeenCalled();
         expect(authInstance.loggedInStatus).toBe(true);
         getAuthenticationTokenMock.mockRestore();
     });
@@ -200,7 +200,7 @@ describe('Unit test for auth', () => {
         }));
         jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(true);
         await authInstance.doTokenAuth(embedConfig.doTokenAuthSuccess('authToken2'));
-        expect(authService.fetchAuthService).toBeCalledWith(
+        expect(authService.fetchAuthService).toHaveBeenCalledWith(
             thoughtSpotHost,
             username,
             'authToken2',
@@ -212,17 +212,17 @@ describe('Unit test for auth', () => {
         jest.spyOn(tokenAuthService, 'isActiveService').mockImplementation(async () => false);
         jest.spyOn(authService, 'fetchAuthTokenService').mockImplementation(() => ({
             text: () => Promise.resolve('abc'),
-        }));
+        } as any));
         jest.spyOn(authService, 'fetchAuthService').mockImplementation(() => Promise.resolve({
             status: 200,
             ok: true,
         }));
         jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(true);
         await authInstance.doTokenAuth(embedConfig.doTokenAuthFailureWithoutGetAuthToken);
-        expect(authService.fetchAuthTokenService).toBeCalledWith('auth');
+        expect(authService.fetchAuthTokenService).toHaveBeenCalledWith('auth');
         await executeAfterWait(() => {
             expect(authInstance.loggedInStatus).toBe(true);
-            expect(authService.fetchAuthService).toBeCalledWith(thoughtSpotHost, username, 'abc');
+            expect(authService.fetchAuthService).toHaveBeenCalledWith(thoughtSpotHost, username, 'abc');
         });
     });
 
@@ -250,7 +250,7 @@ describe('Unit test for auth', () => {
         }
         await executeAfterWait(() => {
             expect(authInstance.loggedInStatus).toBe(false);
-            expect(window.alert).toBeCalled();
+            expect(window.alert).toHaveBeenCalled();
             expect(authService.fetchAuthService).toHaveBeenCalledTimes(1);
         });
     });
@@ -263,7 +263,7 @@ describe('Unit test for auth', () => {
             .mockClear();
         jest.spyOn(authService, 'fetchAuthTokenService').mockImplementation(() => ({
             text: () => Promise.resolve('abc'),
-        }));
+        } as any));
         jest.spyOn(authService, 'fetchAuthService').mockImplementation(() => Promise.resolve({
             status: 200,
             ok: true,
@@ -278,10 +278,10 @@ describe('Unit test for auth', () => {
 
     test('doTokenAuth: when user is not loggedIn & fetchAuthPostService failed than fetchAuthService should call', async () => {
         jest.spyOn(window, 'alert').mockImplementation(() => undefined);
-        jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => false);
+        jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => Promise.resolve(false));
         jest.spyOn(authService, 'fetchAuthTokenService').mockImplementation(() => ({
             text: () => Promise.resolve('abc'),
-        }));
+        } as any));
         jest.spyOn(authService, 'fetchAuthPostService').mockImplementation(() =>
             // eslint-disable-next-line prefer-promise-reject-errors, implicit-arrow-linebreak
             Promise.reject({
@@ -295,12 +295,12 @@ describe('Unit test for auth', () => {
         expect(await authInstance.doTokenAuth(embedConfig.doTokenAuthSuccess('authToken2'))).toBe(
             true,
         );
-        expect(authService.fetchAuthPostService).toBeCalledWith(
+        expect(authService.fetchAuthPostService).toHaveBeenCalledWith(
             thoughtSpotHost,
             username,
             'authToken2',
         );
-        expect(authService.fetchAuthService).toBeCalledWith(
+        expect(authService.fetchAuthService).toHaveBeenCalledWith(
             thoughtSpotHost,
             username,
             'authToken2',
@@ -323,11 +323,11 @@ describe('Unit test for auth', () => {
             jest.spyOn(authService, 'fetchBasicAuthService').mockImplementation(() => ({
                 status: 200,
                 ok: true,
-            }));
+            } as any));
 
             await authInstance.doBasicAuth(embedConfig.doBasicAuth);
-            // expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
-            expect(authService.fetchBasicAuthService).toBeCalled();
+            // expect(tokenAuthService.fetchSessionInfoService).toHaveBeenCalled();
+            expect(authService.fetchBasicAuthService).toHaveBeenCalled();
             expect(authInstance.loggedInStatus).toBe(true);
         });
     });
@@ -341,7 +341,7 @@ describe('Unit test for auth', () => {
         });
 
         it('when user is loggedIn & isAtSSORedirectUrl is true', async () => {
-            spyOn(checkReleaseVersionInBetaInstance, 'checkReleaseVersionInBeta');
+            jest.spyOn(checkReleaseVersionInBetaInstance, 'checkReleaseVersionInBeta');
             Object.defineProperty(window, 'location', {
                 value: {
                     href: `asd.com#?tsSSOMarker=${authInstance.SSO_REDIRECTION_MARKER_GUID}`,
@@ -354,7 +354,7 @@ describe('Unit test for auth', () => {
                     status: 200,
                 }),
             );
-            jest.spyOn(tokenAuthService, 'isActiveService').mockReturnValue(true);
+            jest.spyOn(tokenAuthService, 'isActiveService').mockReturnValue(Promise.resolve(true));
             await authInstance.doSamlAuth(embedConfig.doSamlAuth);
             expect(window.location.hash).toBe('');
             expect(authInstance.loggedInStatus).toBe(true);
@@ -399,7 +399,7 @@ describe('Unit test for auth', () => {
                     hash: '',
                 },
             });
-            spyOn(authInstance, 'samlCompletionPromise').and.returnValue(Promise.resolve(false));
+            (authInstance as any).samlCompletionPromise = Promise.resolve(false);
              const emitSpy = jest.fn();
             const mockEventEmitter = { 
                 emit: emitSpy,
@@ -408,8 +408,8 @@ describe('Unit test for auth', () => {
             };
             authInstance.setAuthEE(mockEventEmitter as any);
             jest.spyOn(tokenAuthService, 'isActiveService')
-                .mockReturnValueOnce(false)
-                .mockReturnValueOnce(true);
+                .mockReturnValueOnce(Promise.resolve(false))
+                .mockReturnValueOnce(Promise.resolve(true));
             expect(
                 await authInstance.doSamlAuth({
                     ...embedConfig.doSamlAuthNoRedirect,
@@ -431,11 +431,11 @@ describe('Unit test for auth', () => {
                     hash: '',
                 },
             });
-            spyOn(authInstance, 'samlCompletionPromise');
+            (authInstance as any).samlCompletionPromise = Promise.resolve();
             global.window.open = jest.fn();
             jest.spyOn(tokenAuthService, 'isActiveService')
-                .mockReturnValueOnce(false)
-                .mockReturnValueOnce(true);
+                .mockReturnValueOnce(Promise.resolve(false))
+                .mockReturnValueOnce(Promise.resolve(true));
             expect(await authInstance.samlCompletionPromise).not.toBe(null);
             expect(
                 await authInstance.doSamlAuth({
@@ -489,42 +489,42 @@ describe('Unit test for auth', () => {
         jest.spyOn(authInstance, 'doSamlAuth');
         await authInstance.authenticate(embedConfig.SSOAuth);
         expect(window.location.hash).toBe('');
-        expect(authInstance.doSamlAuth).toBeCalled();
+        expect(authInstance.doSamlAuth).toHaveBeenCalled();
     });
 
     it('authenticate: when authType is SMAL', async () => {
         jest.spyOn(authInstance, 'doSamlAuth');
         await authInstance.authenticate(embedConfig.SAMLAuth);
         expect(window.location.hash).toBe('');
-        expect(authInstance.doSamlAuth).toBeCalled();
+        expect(authInstance.doSamlAuth).toHaveBeenCalled();
     });
 
     it('authenticate: when authType is OIDC', async () => {
         jest.spyOn(authInstance, 'doOIDCAuth');
         await authInstance.authenticate(embedConfig.OIDCAuth);
         expect(window.location.hash).toBe('');
-        expect(authInstance.doOIDCAuth).toBeCalled();
+        expect(authInstance.doOIDCAuth).toHaveBeenCalled();
     });
 
     it('authenticate: when authType is AuthServer', async () => {
-        spyOn(authInstance, 'doTokenAuth');
+        jest.spyOn(authInstance, 'doTokenAuth').mockReturnValue(Promise.resolve(true) as any);
         await authInstance.authenticate(embedConfig.authServerFailure);
         expect(window.location.hash).toBe('');
-        expect(authInstance.doTokenAuth).toBeCalled();
+        expect(authInstance.doTokenAuth).toHaveBeenCalled();
     });
 
     it('authenticate: when authType is AuthServerCookieless', async () => {
-        spyOn(authInstance, 'doCookielessTokenAuth');
+        jest.spyOn(authInstance, 'doCookielessTokenAuth').mockReturnValue(Promise.resolve(true) as any);
         await authInstance.authenticate(embedConfig.authServerCookielessFailure);
         expect(window.location.hash).toBe('');
-        expect(authInstance.doCookielessTokenAuth).toBeCalled();
+        expect(authInstance.doCookielessTokenAuth).toHaveBeenCalled();
     });
 
     it('authenticate: when authType is Basic', async () => {
         jest.spyOn(authInstance, 'doBasicAuth');
         jest.spyOn(authService, 'fetchBasicAuthService').mockImplementation(() => Promise.resolve({ status: 200, ok: true }));
         await authInstance.authenticate(embedConfig.basicAuthSuccess);
-        expect(authInstance.doBasicAuth).toBeCalled();
+        expect(authInstance.doBasicAuth).toHaveBeenCalled();
         expect(authInstance.loggedInStatus).toBe(true);
     });
 
@@ -540,7 +540,7 @@ describe('Unit test for auth', () => {
 
     it('doCookielessTokenAuth should resolve to true if valid token is passed', async () => {
         jest.clearAllMocks();
-        jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(true);
+        jest.spyOn(authInstance, 'doCookielessTokenAuth').mockReturnValue(Promise.resolve(true) as any);
         const isLoggedIn = await authInstance.doCookielessTokenAuth(
             embedConfig.doCookielessAuth('testToken'),
         );
@@ -548,6 +548,7 @@ describe('Unit test for auth', () => {
     });
 
     it('doCookielessTokenAuth should resolve to false if valid token is not passed', async () => {
+        jest.restoreAllMocks();
         jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(false);
         const isLoggedIn = await authInstance.doCookielessTokenAuth(
             embedConfig.doCookielessAuth('testToken'),
@@ -563,17 +564,18 @@ describe('Unit test for auth', () => {
         jest.clearAllMocks();
         jest.restoreAllMocks();
 
-        jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockReturnValue({
-            userGUID: '1234',
-            releaseVersion: '1',
+        const devMockResponse = {
+            ...mockSessionInfoApiResponse,
             configInfo: {
+                ...mockSessionInfoApiResponse.configInfo,
                 mixpanelConfig: {
-                    devSdkKey: 'devKey',
-                    prodSdkKey: 'prodKey',
+                    ...mockSessionInfoApiResponse.configInfo.mixpanelConfig,
                     production: false,
                 },
             },
-        });
+        };
+
+        jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockReturnValue(Promise.resolve(devMockResponse));
         const details = await SessionService.getSessionInfo();
         expect(details).toEqual(
             expect.objectContaining({
@@ -589,7 +591,7 @@ describe('Unit test for auth', () => {
                     production: true,
                 },
             },
-        });
+        } as any);
 
         SessionService.resetCachedSessionInfo();
         const details2 = await SessionService.getSessionInfo();
@@ -602,13 +604,13 @@ describe('Unit test for auth', () => {
 
     test('notifyAuthSuccess if getSessionInfo returns data', async () => {
         const dummyInfo = { test: 'dummy' };
-        jest.spyOn(SessionService, 'getSessionInfo').mockResolvedValueOnce(dummyInfo);
-        jest.spyOn(logger, 'error').mockResolvedValueOnce(true);
+        jest.spyOn(SessionService, 'getSessionInfo').mockResolvedValueOnce(dummyInfo as any);
+        jest.spyOn(logger, 'error').mockImplementation(() => {});
         const emitSpy = jest.fn();
         authInstance.setAuthEE({ emit: emitSpy } as any);
         await authInstance.notifyAuthSuccess();
-        expect(logger.error).not.toBeCalled();
-        expect(emitSpy).toBeCalledWith(authInstance.AuthStatus.SUCCESS, dummyInfo);
+        expect(logger.error).not.toHaveBeenCalled();
+        expect(emitSpy).toHaveBeenCalledWith(authInstance.AuthStatus.SUCCESS, dummyInfo);
         authInstance.setAuthEE(null);
     });
 
@@ -620,8 +622,8 @@ describe('Unit test for auth', () => {
         const emitSpy = jest.fn();
         authInstance.setAuthEE({ emit: emitSpy } as any);
         await authInstance.notifyAuthSuccess();
-        expect(logger.error).toBeCalled();
-        expect(emitSpy).not.toBeCalled();
+        expect(logger.error).toHaveBeenCalled();
+        expect(emitSpy).not.toHaveBeenCalled();
         authInstance.setAuthEE(null);
     });
 });

package/src/authToken.spec.ts

@@ -15,13 +15,13 @@ describe('AuthToken Unit tests', () => {
         } as EmbedConfig);
 
         expect(token).toBe('abc3');
-        expect(authServiceInstance.verifyTokenService).not.toBeCalled();
+        expect(authServiceInstance.verifyTokenService).not.toHaveBeenCalled();
     });
 
     test('getAuthenticationToken: When verification is enabled', async () => {
         resetCachedAuthToken();
         jest.clearAllMocks();
-        jest.spyOn(authServiceInstance, 'verifyTokenService').mockImplementation(() => true);
+        jest.spyOn(authServiceInstance, 'verifyTokenService').mockImplementation(() => Promise.resolve(true));
         const token = await getAuthenticationToken({
             thoughtSpotHost: 'test',
             getAuthToken: async () => 'abc2',
@@ -29,7 +29,7 @@ describe('AuthToken Unit tests', () => {
         } as EmbedConfig);
 
         expect(token).toBe('abc2');
-        expect(authServiceInstance.verifyTokenService).toBeCalledWith('test', 'abc2');
+        expect(authServiceInstance.verifyTokenService).toHaveBeenCalledWith('test', 'abc2');
     });
 
     test('validateAuthToken : When token is invalid by type number', async () => {

package/src/embed/app.spec.ts

@@ -43,7 +43,7 @@ beforeAll(() => {
         thoughtSpotHost,
         authType: AuthType.None,
     });
-    jest.spyOn(auth, 'postLoginService').mockImplementation(() => Promise.resolve({}));
+    jest.spyOn(auth, 'postLoginService').mockImplementation(() => Promise.resolve(undefined));
     (window as any).ResizeObserver =
         window.ResizeObserver ||
         jest.fn().mockImplementation(() => ({
@@ -1130,13 +1130,13 @@ describe('App embed tests', () => {
         let embedHeightCallback: any = () => { };
         const onSpy = jest.spyOn(AppEmbed.prototype, 'on').mockImplementation((event, callback) => {
             if (event === EmbedEvent.RouteChange) {
-                callback({ data: { currentPath: '/answers' } }, jest.fn());
+                callback({ type: EmbedEvent.RouteChange, data: { currentPath: '/answers' } } as any, jest.fn());
             }
             if (event === EmbedEvent.EmbedHeight) {
                 embedHeightCallback = callback;
             }
             if (event === EmbedEvent.EmbedIframeCenter) {
-                callback({}, jest.fn());
+                callback({ type: EmbedEvent.EmbedIframeCenter, data: {} } as any, jest.fn());
             }
             return null;
         });
@@ -1146,6 +1146,7 @@ describe('App embed tests', () => {
             ...defaultViewConfig,
             fullHeight: true,
             lazyLoadingForFullHeight: true,
+            lazyLoadingMargin: '10px',
         } as AppViewConfig);
 
         // Set the iframe before render
@@ -1227,7 +1228,7 @@ describe('App embed tests', () => {
                 },
             });
             await appEmbed.render();
-            spyOn(logger, 'warn');
+            jest.spyOn(logger, 'warn').mockImplementation(() => {});
             appEmbed.navigateToPage(-1);
             expect(logger.warn).toHaveBeenCalledWith(
                 'Path can only by a string when triggered without noReload',
@@ -1235,7 +1236,7 @@ describe('App embed tests', () => {
         });
 
         test('navigateToPage function use before render', async () => {
-            spyOn(logger, 'log');
+            jest.spyOn(logger, 'log').mockImplementation(() => {});
             const appEmbed = new AppEmbed(getRootEl(), {
                 frameParams: {
                     width: '100%',
@@ -1317,6 +1318,7 @@ describe('App embed tests', () => {
                 ...defaultViewConfig,
                 fullHeight: true,
                 lazyLoadingForFullHeight: true,
+                lazyLoadingMargin: '10px',
             } as AppViewConfig);
 
             // Set the iframe before render
@@ -1393,6 +1395,7 @@ describe('App embed tests', () => {
                 ...defaultViewConfig,
                 fullHeight: true,
                 lazyLoadingForFullHeight: true,
+                lazyLoadingMargin: '10px',
             } as AppViewConfig);
 
             const mockTrigger = jest.spyOn(appEmbed, 'trigger');
@@ -1425,6 +1428,7 @@ describe('App embed tests', () => {
                 ...defaultViewConfig,
                 fullHeight: true,
                 lazyLoadingForFullHeight: true,
+                lazyLoadingMargin: '10px',
             } as AppViewConfig);
 
             const mockTrigger = jest.spyOn(appEmbed, 'trigger');
@@ -1449,6 +1453,7 @@ describe('App embed tests', () => {
                 ...defaultViewConfig,
                 fullHeight: true,
                 lazyLoadingForFullHeight: true,
+                lazyLoadingMargin: '10px',
             } as AppViewConfig);
 
             await appEmbed.render();
@@ -1469,6 +1474,7 @@ describe('App embed tests', () => {
                 ...defaultViewConfig,
                 fullHeight: true,
                 lazyLoadingForFullHeight: true,
+                lazyLoadingMargin: '10px',
             } as AppViewConfig);
 
             await appEmbed.render();
@@ -1496,6 +1502,7 @@ describe('App embed tests', () => {
                 ...defaultViewConfig,
                 fullHeight: true,
                 lazyLoadingForFullHeight: true,
+                lazyLoadingMargin: '10px',
             } as AppViewConfig);
 
             // Set the iframe before render

package/src/embed/app.ts

@@ -9,7 +9,7 @@
  */
 
 import { logger } from '../utils/logger';
-import { calculateVisibleElementData, getQueryParamString, isUndefined } from '../utils';
+import { calculateVisibleElementData, getQueryParamString, isUndefined, isValidCssMargin } from '../utils';
 import {
     Param,
     DOMSelector,
@@ -761,7 +761,9 @@ export class AppEmbed extends V1Embed {
             params[Param.fullHeight] = true;
             if (this.viewConfig.lazyLoadingForFullHeight) {
                 params[Param.IsLazyLoadingForEmbedEnabled] = true;
-                params[Param.RootMarginForLazyLoad] = this.viewConfig.lazyLoadingMargin;
+                if (isValidCssMargin(this.viewConfig.lazyLoadingMargin)) {
+                    params[Param.RootMarginForLazyLoad] = this.viewConfig.lazyLoadingMargin;
+                }
             }
         }
 

package/src/embed/base.spec.ts

@@ -32,14 +32,14 @@ describe('Base TS Embed', () => {
             thoughtSpotHost,
             authType: index.AuthType.None,
         }) as EventEmitter;
-        jest.spyOn(auth, 'postLoginService').mockImplementation(() => Promise.resolve({}));
+        jest.spyOn(auth, 'postLoginService').mockImplementation(() => Promise.resolve(undefined));
     });
 
     beforeEach(() => {
         document.body.innerHTML = getDocumentBody();
     });
 
-    test('Should show an alert when third party cookie access is blocked', (done) => {
+    test('Should show an alert when third party cookie access is blocked', () => {
         const tsEmbed = new index.SearchEmbed(getRootEl(), {});
         const iFrame: any = document.createElement('div');
         iFrame.contentWindow = null;
@@ -59,18 +59,17 @@ describe('Base TS Embed', () => {
         jest.spyOn(window, 'alert').mockImplementation(() => undefined);
         authEE.on(auth.AuthStatus.FAILURE, (reason) => {
             expect(reason).toEqual(auth.AuthFailureType.NO_COOKIE_ACCESS);
-            expect(window.alert).toBeCalledWith(
+            expect(window.alert).toHaveBeenCalledWith(
                 'Third-party cookie access is blocked on this browser. Please allow third-party cookies for this to work properly. \nYou can use `suppressNoCookieAccessAlert` to suppress this message.',
             );
-            done();
         });
     });
 
-    test('Should ignore cookie blocked alert if ignoreNoCookieAccess is true', async (done) => {
+    test('Should ignore cookie blocked alert if ignoreNoCookieAccess is true', async () => {
         jest.spyOn(window, 'fetch').mockResolvedValue({
             ok: true,
             json: jest.fn().mockResolvedValue({}),
-        });
+        } as any);
         const authEE = index.init({
             thoughtSpotHost,
             authType: index.AuthType.None,
@@ -96,7 +95,6 @@ describe('Base TS Embed', () => {
         authEE.on(auth.AuthStatus.FAILURE, (reason) => {
             expect(reason).toEqual(auth.AuthFailureType.NO_COOKIE_ACCESS);
             expect(window.alert).not.toHaveBeenCalled();
-            done();
         });
     });
 
@@ -104,7 +102,7 @@ describe('Base TS Embed', () => {
         jest.spyOn(window, 'fetch').mockResolvedValue({
             ok: true,
             json: jest.fn().mockResolvedValue({}),
-        });
+        } as any);
         index.init({
             thoughtSpotHost,
             authType: index.AuthType.None,
@@ -161,7 +159,7 @@ describe('Base TS Embed', () => {
         jest.spyOn(tokenizedFetchInstance, 'tokenizedFetch').mockResolvedValueOnce({
             ok: true,
             json: jest.fn().mockResolvedValue({}),
-        });
+        } as any);
         index.init({
             thoughtSpotHost,
             authType: index.AuthType.TrustedAuthTokenCookieless,
@@ -229,7 +227,7 @@ describe('Base TS Embed', () => {
         jest.spyOn(tokenizedFetchInstance, 'tokenizedFetch').mockResolvedValueOnce({
             ok: true,
             json: jest.fn().mockResolvedValue({}),
-        });
+        } as any);
         index.init({
             thoughtSpotHost,
             authType: index.AuthType.None,
@@ -388,7 +386,7 @@ describe('Base TS Embed', () => {
         });
     });
 
-    test('handleAuth notifies for SDK auth failure', (done) => {
+    test('handleAuth notifies for SDK auth failure', () => {
         jest.spyOn(auth, 'authenticate').mockResolvedValue(false);
         const authEmitter = index.init({
             thoughtSpotHost,
@@ -398,11 +396,10 @@ describe('Base TS Embed', () => {
         });
         authEmitter.on(auth.AuthStatus.FAILURE, (reason) => {
             expect(reason).toBe(auth.AuthFailureType.SDK);
-            done();
         });
     });
 
-    test('handleAuth notifies for SDK auth success', (done) => {
+    test('handleAuth notifies for SDK auth success', () => {
         jest.spyOn(auth, 'authenticate').mockResolvedValue(true);
         const failureCallback = jest.fn();
         const authEmitter = index.init({
@@ -414,16 +411,15 @@ describe('Base TS Embed', () => {
 
         authEmitter.on(auth.AuthStatus.FAILURE, failureCallback);
         authEmitter.on(auth.AuthStatus.SDK_SUCCESS, (...args) => {
-            expect(failureCallback).not.toBeCalled();
+            expect(failureCallback).not.toHaveBeenCalled();
             expect(args.length).toBe(0);
-            done();
         });
     });
 
     test('Logout method should disable autoLogin', () => {
         jest.spyOn(window, 'fetch').mockResolvedValueOnce({
             type: 'opaque',
-        });
+        } as any);
         index.init({
             thoughtSpotHost,
             authType: index.AuthType.None,
@@ -461,7 +457,7 @@ describe('Base TS Embed', () => {
             index.init({
                 authType: index.AuthType.None,
             } as EmbedConfig);
-        }).toThrowError();
+        }).toThrow();
     });
 
     test('config sanity, no username in trusted auth', () => {
@@ -470,7 +466,7 @@ describe('Base TS Embed', () => {
                 authType: index.AuthType.TrustedAuthToken,
                 thoughtSpotHost,
             } as EmbedConfig);
-        }).toThrowError();
+        }).toThrow();
     });
 
     test('config sanity, no authEndpoint and getAuthToken', () => {
@@ -480,7 +476,7 @@ describe('Base TS Embed', () => {
                 thoughtSpotHost,
                 username: 'test',
             });
-        }).toThrowError();
+        }).toThrow();
     });
     test('config backward compat, should assign inPopup when noRedirect is set', () => {
         index.init({
@@ -532,6 +528,6 @@ describe('Init tests', () => {
             thoughtSpotHost,
             authType: index.AuthType.None,
         });
-        expect(resetService.resetAllCachedServices).toBeCalled();
+        expect(resetService.resetAllCachedServices).toHaveBeenCalled();
     });
 });

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

@@ -22,8 +22,8 @@ describe('SpotterAgentEmbed', () => {
             thoughtSpotHost,
             authType: AuthType.None,
         });
-        jest.spyOn(authInstance, 'postLoginService').mockImplementation(() => Promise.resolve({}));
-        spyOn(window, 'alert');
+        jest.spyOn(authInstance, 'postLoginService').mockImplementation(() => Promise.resolve(undefined));
+        jest.spyOn(window, 'alert').mockImplementation(() => undefined);
         document.body.innerHTML = getDocumentBody();
     });
 

package/src/embed/conversation.spec.ts

@@ -19,8 +19,8 @@ beforeAll(() => {
         thoughtSpotHost,
         authType: AuthType.None,
     });
-    jest.spyOn(authInstance, 'postLoginService').mockImplementation(() => Promise.resolve({}));
-    spyOn(window, 'alert');
+    jest.spyOn(authInstance, 'postLoginService').mockImplementation(() => Promise.resolve(undefined));
+    jest.spyOn(window, 'alert');
     document.body.innerHTML = getDocumentBody();
 });