@thoughtspot/visual-embed-sdk 1.26.1 → 1.26.2

package/src/auth.ts

@@ -4,16 +4,15 @@ import {
     AuthType, DOMSelector, EmbedConfig, EmbedEvent, Param,
 } from './types';
 import { getDOMNode, getRedirectUrl } from './utils';
-// eslint-disable-next-line import/no-cycle
 import {
     fetchSessionInfoService,
-    fetchAuthTokenService,
     fetchAuthService,
     fetchBasicAuthService,
     fetchLogoutService,
     fetchAuthPostService,
-    verifyTokenService,
+    EndPoints,
 } from './utils/authService';
+import { getAuthenticationToken, resetCachedAuthToken } from './authToken';
 
 // eslint-disable-next-line import/no-mutable-exports
 export let loggedInStatus = false;
@@ -30,18 +29,6 @@ let releaseVersion = '';
 
 export const SSO_REDIRECTION_MARKER_GUID = '5e16222e-ef02-43e9-9fbd-24226bf3ce5b';
 
-export const EndPoints = {
-    AUTH_VERIFICATION: '/callosum/v1/session/info',
-    SAML_LOGIN_TEMPLATE: (targetUrl: string) => `/callosum/v1/saml/login?targetURLPath=${targetUrl}`,
-    OIDC_LOGIN_TEMPLATE: (targetUrl: string) => `/callosum/v1/oidc/login?targetURLPath=${targetUrl}`,
-    TOKEN_LOGIN: '/callosum/v1/session/login/token',
-    BASIC_LOGIN: '/callosum/v1/session/login',
-    LOGOUT: '/callosum/v1/session/logout',
-    EXECUTE_TML: '/api/rest/2.0/metadata/tml/import',
-    EXPORT_TML: '/api/rest/2.0/metadata/tml/export',
-    IS_ACTIVE: '/callosum/v1/session/isactive',
-};
-
 interface sessionInfoInterface {
     userGUID: any;
     isPublicUser: any;
@@ -270,22 +257,6 @@ export function getSessionInfo(): Promise<sessionInfoInterface> {
     return sessionInfoPromise;
 }
 
-const DUPLICATE_TOKEN_ERR = 'Duplicate token, please issue a new token every time getAuthToken callback is called.'
-    + 'See https://developers.thoughtspot.com/docs/?pageid=embed-auth#trusted-auth-embed for more details.';
-let prevAuthToken: string = null;
-/**
- *
- * @param authtoken
- */
-function alertForDuplicateToken(authtoken: string) {
-    if (prevAuthToken === authtoken) {
-        // eslint-disable-next-line no-alert
-        alert(DUPLICATE_TOKEN_ERR);
-        throw new Error(DUPLICATE_TOKEN_ERR);
-    }
-    prevAuthToken = authtoken;
-}
-
 /**
  * Check if we are stuck at the SSO redirect URL
  */
@@ -305,19 +276,6 @@ function removeSSORedirectUrlMarker(): void {
     window.location.hash = window.location.hash.replace(SSO_REDIRECTION_MARKER_GUID, '');
 }
 
-export const getAuthenticationToken = async (embedConfig: EmbedConfig): Promise<any> => {
-    const { authEndpoint, getAuthToken } = embedConfig;
-    let authToken = null;
-    if (getAuthToken) {
-        authToken = await getAuthToken();
-        alertForDuplicateToken(authToken);
-    } else {
-        const response = await fetchAuthTokenService(authEndpoint);
-        authToken = await response.text();
-    }
-    return authToken;
-};
-
 /**
  * Perform token based authentication
  *
@@ -360,15 +318,17 @@ export const doCookielessTokenAuth = async (embedConfig: EmbedConfig): Promise<b
     if (!authEndpoint && !getAuthToken) {
         throw new Error('Either auth endpoint or getAuthToken function must be provided');
     }
+    let authSuccess = false;
     try {
         const authToken = await getAuthenticationToken(embedConfig);
-        const response = await verifyTokenService(embedConfig.thoughtSpotHost, authToken);
-        if (!response.ok) return false;
-    } catch (e) {
-        return false;
+        if (authToken) {
+            authSuccess = true;
+        }
+    } catch {
+        authSuccess = false;
     }
 
-    return true;
+    return authSuccess;
 };
 
 /**
@@ -462,11 +422,7 @@ const doSSOAuth = async (embedConfig: EmbedConfig, ssoEndPoint: string): Promise
 
     const ssoURL = `${thoughtSpotHost}${ssoEndPoint}`;
     if (embedConfig.inPopup) {
-        await samlPopupFlow(
-            ssoURL,
-            embedConfig.authTriggerContainer,
-            embedConfig.authTriggerText,
-        );
+        await samlPopupFlow(ssoURL, embedConfig.authTriggerContainer, embedConfig.authTriggerText);
         loggedInStatus = await isLoggedIn(thoughtSpotHost);
         return;
     }
@@ -514,7 +470,8 @@ export const doOIDCAuth = async (embedConfig: EmbedConfig) => {
 
 export const logout = async (embedConfig: EmbedConfig): Promise<boolean> => {
     const { thoughtSpotHost } = embedConfig;
-    const response = await fetchLogoutService(thoughtSpotHost);
+    await fetchLogoutService(thoughtSpotHost);
+    resetCachedAuthToken();
     loggedInStatus = false;
     return loggedInStatus;
 };

package/src/authToken.ts

@@ -0,0 +1,66 @@
+import { EmbedConfig } from './types';
+import { fetchAuthTokenService, verifyTokenService } from './utils/authService/authService';
+
+const DUPLICATE_TOKEN_ERR = 'Duplicate token, please issue a new token every time getAuthToken callback is called.'
+    + 'See https://developers.thoughtspot.com/docs/?pageid=embed-auth#trusted-auth-embed for more details.';
+
+const INVALID_TOKEN_ERR = 'Invalid token received form token callback or authToken endpoint.';
+
+let cachedAuthToken: string | null = null;
+
+// This method can be used to get the authToken using the embedConfig
+export const getAuthenticationToken = async (embedConfig: EmbedConfig): Promise<string> => {
+    if (cachedAuthToken) {
+        let isCachedTokenStillValid;
+        try {
+            isCachedTokenStillValid = await validateAuthToken(embedConfig, cachedAuthToken, true);
+        } catch {
+            isCachedTokenStillValid = false;
+        }
+
+        if (isCachedTokenStillValid) return cachedAuthToken;
+    }
+
+    const { authEndpoint, getAuthToken } = embedConfig;
+
+    let authToken = null;
+    if (getAuthToken) {
+        authToken = await getAuthToken();
+    } else {
+        const response = await fetchAuthTokenService(authEndpoint);
+        authToken = await response.text();
+    }
+
+    // this will throw error if the token is not valid
+    await validateAuthToken(embedConfig, authToken);
+
+    cachedAuthToken = authToken;
+    return authToken;
+};
+
+const validateAuthToken = async (
+    embedConfig: EmbedConfig,
+    authToken: string,
+    suppressAlert?: boolean,
+): Promise<boolean> => {
+    try {
+        const isTokenValid = await verifyTokenService(embedConfig.thoughtSpotHost, authToken);
+        if (isTokenValid) return true;
+    } catch {
+        return false;
+    }
+
+    if (cachedAuthToken && cachedAuthToken === authToken) {
+        if (!embedConfig.suppressErrorAlerts && !suppressAlert) {
+            // eslint-disable-next-line no-alert
+            alert(DUPLICATE_TOKEN_ERR);
+        }
+        throw new Error(DUPLICATE_TOKEN_ERR);
+    } else {
+        throw new Error(INVALID_TOKEN_ERR);
+    }
+};
+
+export const resetCachedAuthToken = (): void => {
+    cachedAuthToken = null;
+};

package/src/embed/base.spec.ts

@@ -3,16 +3,20 @@
 import EventEmitter from 'eventemitter3';
 import { EmbedConfig } from '../index';
 import * as auth from '../auth';
+import * as authService from '../utils/authService/authService';
+import * as authTokenService from '../authToken';
 import * as index from '../index';
 import * as base from './base';
+import * as embedConfigInstance from './embedConfig';
+
 import {
     executeAfterWait,
     getAllIframeEl,
     getDocumentBody,
     getRootEl,
-    getRootEl2,
     getIFrameSrc,
 } from '../test/test-utils';
+import * as tokenizedFetchInstance from '../tokenizedFetch';
 
 const thoughtSpotHost = 'tshost';
 let authEE: EventEmitter;
@@ -107,7 +111,7 @@ describe('Base TS Embed', () => {
         };
         await index.executeTML(data);
         expect(window.fetch).toHaveBeenCalledWith(
-            `http://${thoughtSpotHost}${auth.EndPoints.EXECUTE_TML}`,
+            `http://${thoughtSpotHost}${authService.EndPoints.EXECUTE_TML}`,
             {
                 credentials: 'include',
                 headers: {
@@ -121,32 +125,29 @@ describe('Base TS Embed', () => {
     });
 
     test('should call the executeTML API and import TML for cookiless auth', async () => {
-        jest.spyOn(window, 'fetch').mockResolvedValue({
+        jest.spyOn(authTokenService, 'getAuthenticationToken').mockResolvedValue('mockAuthToken');
+        jest.spyOn(tokenizedFetchInstance, 'tokenizedFetch').mockResolvedValueOnce({
             ok: true,
             json: jest.fn().mockResolvedValue({}),
-            text: jest.fn().mockResolvedValue('mockAuthToken'),
         });
         index.init({
             thoughtSpotHost,
             authType: index.AuthType.TrustedAuthTokenCookieless,
             autoLogin: true,
         });
-        const embedConfig = base.getEmbedConfig();
-        const authToken = await auth.getAuthenticationToken(embedConfig);
         const data: base.executeTMLInput = {
             metadata_tmls: ['{"liveboard":{"name":"Parameters Liveboard"}}'],
             import_policy: 'PARTIAL',
             create_new: false,
         };
         await index.executeTML(data);
-        expect(window.fetch).toHaveBeenCalledWith(
-            `http://${thoughtSpotHost}${auth.EndPoints.EXECUTE_TML}`,
+        expect(tokenizedFetchInstance.tokenizedFetch).toHaveBeenCalledWith(
+            `http://${thoughtSpotHost}${authService.EndPoints.EXECUTE_TML}`,
             {
                 credentials: 'include',
                 headers: expect.objectContaining({
                     'Content-Type': 'application/json',
                     'x-requested-by': 'ThoughtSpot',
-                    Authorization: `Bearer ${authToken}`,
                 }),
                 body: JSON.stringify(data),
                 method: 'POST',
@@ -193,7 +194,7 @@ describe('Base TS Embed', () => {
     });
 
     test('should call the exportTML API and export TML', async () => {
-        jest.spyOn(window, 'fetch').mockResolvedValue({
+        jest.spyOn(tokenizedFetchInstance, 'tokenizedFetch').mockResolvedValueOnce({
             ok: true,
             json: jest.fn().mockResolvedValue({}),
         });
@@ -209,8 +210,8 @@ describe('Base TS Embed', () => {
             edoc_format: 'YAML',
         };
         await index.exportTML(data);
-        expect(window.fetch).toHaveBeenCalledWith(
-            `http://${thoughtSpotHost}${auth.EndPoints.EXPORT_TML}`,
+        expect(tokenizedFetchInstance.tokenizedFetch).toHaveBeenCalledWith(
+            `http://${thoughtSpotHost}${authService.EndPoints.EXPORT_TML}`,
             {
                 credentials: 'include',
                 headers: {
@@ -341,7 +342,7 @@ describe('Base TS Embed', () => {
     });
 
     test('Logout method should disable autoLogin', () => {
-        jest.spyOn(window, 'fetch').mockResolvedValue({
+        jest.spyOn(window, 'fetch').mockResolvedValueOnce({
             type: 'opaque',
         });
         index.init({
@@ -351,7 +352,7 @@ describe('Base TS Embed', () => {
         });
         index.logout();
         expect(window.fetch).toHaveBeenCalledWith(
-            `http://${thoughtSpotHost}${auth.EndPoints.LOGOUT}`,
+            `http://${thoughtSpotHost}${authService.EndPoints.LOGOUT}`,
             {
                 credentials: 'include',
                 headers: {
@@ -360,7 +361,7 @@ describe('Base TS Embed', () => {
                 method: 'POST',
             },
         );
-        expect(base.getEmbedConfig().autoLogin).toBe(false);
+        expect(embedConfigInstance.getEmbedConfig().autoLogin).toBe(false);
     });
 
     test('config sanity, no ts host', () => {
@@ -395,7 +396,7 @@ describe('Base TS Embed', () => {
             thoughtSpotHost,
             noRedirect: true,
         });
-        expect(base.getEmbedConfig().inPopup).toBe(true);
+        expect(embedConfigInstance.getEmbedConfig().inPopup).toBe(true);
     });
     test('config backward compat, should not override inPopup with noRedirect', () => {
         index.init({
@@ -404,7 +405,7 @@ describe('Base TS Embed', () => {
             noRedirect: true,
             inPopup: false,
         });
-        expect(base.getEmbedConfig().inPopup).toBe(false);
+        expect(embedConfigInstance.getEmbedConfig().inPopup).toBe(false);
     });
 });
 

package/src/embed/base.ts

@@ -10,6 +10,8 @@
  */
 import EventEmitter from 'eventemitter3';
 import uniq from 'lodash/uniq';
+import { tokenizedFetch } from '../tokenizedFetch';
+import { EndPoints } from '../utils/authService/authService';
 import { getThoughtSpotHost } from '../config';
 import { AuthType, EmbedConfig, PrefetchFeatures } from '../types';
 import {
@@ -24,12 +26,10 @@ import {
     notifyLogout,
     setAuthEE,
     AuthEventEmitter,
-    EndPoints,
-    getAuthenticationToken,
 } from '../auth';
 import { uploadMixpanelEvent, MIXPANEL_EVENT } from '../mixpanel-service';
+import { getEmbedConfig, setEmbedConfig } from './embedConfig';
 
-let config = {} as EmbedConfig;
 const CONFIG_DEFAULTS: Partial<EmbedConfig> = {
     loginFailedMessage: 'Not logged in',
     authTriggerText: 'Authorize',
@@ -53,14 +53,6 @@ export interface exportTMLInput {
 }
 
 export let authPromise: Promise<boolean>;
-/**
- * Gets the configuration embed was initialized with.
- *
- * @returns {@link EmbedConfig} The configuration embed was initialized with.
- * @version SDK: 1.19.0 | ThoughtSpot: *
- * @group Global methods
- */
-export const getEmbedConfig = (): EmbedConfig => config;
 
 export const getAuthPromise = (): Promise<boolean> => authPromise;
 
@@ -72,7 +64,7 @@ export {
  * Perform authentication on the ThoughtSpot app as applicable.
  */
 export const handleAuth = (): Promise<boolean> => {
-    authPromise = authenticate(config);
+    authPromise = authenticate(getEmbedConfig());
     authPromise.then(
         (isLoggedIn) => {
             if (!isLoggedIn) {
@@ -111,7 +103,7 @@ export const prefetch = (url?: string, prefetchFeatures?: PrefetchFeatures[]): v
         console.warn('The prefetch method does not have a valid URL');
     } else {
         const features = prefetchFeatures || [PrefetchFeatures.FullApp];
-        let hostUrl = url || config.thoughtSpotHost;
+        let hostUrl = url || getEmbedConfig().thoughtSpotHost;
         hostUrl = hostUrl[hostUrl.length - 1] === '/' ? hostUrl : `${hostUrl}/`;
         uniq(features.map((feature) => hostUrlToFeatureUrl[feature](hostUrl))).forEach(
             (prefetchUrl, index) => {
@@ -182,17 +174,18 @@ function backwardCompat(embedConfig: EmbedConfig): EmbedConfig {
  */
 export const init = (embedConfig: EmbedConfig): AuthEventEmitter => {
     sanity(embedConfig);
-    config = {
-        ...CONFIG_DEFAULTS,
-        ...embedConfig,
-        thoughtSpotHost: getThoughtSpotHost(embedConfig),
-    };
-    config = backwardCompat(config);
+    setEmbedConfig(
+        backwardCompat({
+            ...CONFIG_DEFAULTS,
+            ...embedConfig,
+            thoughtSpotHost: getThoughtSpotHost(embedConfig),
+        }),
+    );
     const authEE = new EventEmitter<AuthStatus | AuthEvent>();
     setAuthEE(authEE);
     handleAuth();
 
-    const { password, ...configToTrack } = config;
+    const { password, ...configToTrack } = getEmbedConfig();
     uploadMixpanelEvent(MIXPANEL_EVENT.VISUAL_SDK_CALLED_INIT, {
         ...configToTrack,
         usedCustomizationSheet: embedConfig.customizations?.style?.customCSSUrl != null,
@@ -203,8 +196,8 @@ export const init = (embedConfig: EmbedConfig): AuthEventEmitter => {
         usedCustomizationIconSprite: !!embedConfig.customizations?.iconSpriteUrl,
     });
 
-    if (config.callPrefetch) {
-        prefetch(config.thoughtSpotHost);
+    if (getEmbedConfig().callPrefetch) {
+        prefetch(getEmbedConfig().thoughtSpotHost);
     }
     return authEE as AuthEventEmitter;
 };
@@ -213,7 +206,7 @@ export const init = (embedConfig: EmbedConfig): AuthEventEmitter => {
  *
  */
 export function disableAutoLogin(): void {
-    config.autoLogin = false;
+    getEmbedConfig().autoLogin = false;
 }
 
 /**
@@ -232,7 +225,7 @@ export const logout = (doNotDisableAutoLogin = false): Promise<boolean> => {
     if (!doNotDisableAutoLogin) {
         disableAutoLogin();
     }
-    return _logout(config).then((isLoggedIn) => {
+    return _logout(getEmbedConfig()).then((isLoggedIn) => {
         notifyLogout();
         return isLoggedIn;
     });
@@ -247,13 +240,13 @@ let renderQueue: Promise<any> = Promise.resolve();
  * @param fn The function being registered
  */
 export const renderInQueue = (fn: (next?: (val?: any) => void) => Promise<any>): Promise<any> => {
-    const { queueMultiRenders = false } = config;
+    const { queueMultiRenders = false } = getEmbedConfig();
     if (queueMultiRenders) {
         renderQueue = renderQueue.then(() => new Promise((res) => fn(res)));
         return renderQueue;
     }
     // Sending an empty function to keep it consistent with the above usage.
-    return fn(() => { }); // eslint-disable-line @typescript-eslint/no-empty-function
+    return fn(() => {}); // eslint-disable-line @typescript-eslint/no-empty-function
 };
 
 /**
@@ -280,32 +273,24 @@ export const renderInQueue = (fn: (next?: (val?: any) => void) => Promise<any>):
  * @group Global methods
  */
 export const executeTML = async (data: executeTMLInput): Promise<any> => {
-    const { thoughtSpotHost, authType } = config;
     try {
-        sanity(config);
+        sanity(getEmbedConfig());
     } catch (err) {
         return Promise.reject(err);
     }
-    let authToken = '';
-    if (authType === AuthType.TrustedAuthTokenCookieless) {
-        authToken = await getAuthenticationToken(config);
-    }
 
+    const { thoughtSpotHost, authType } = getEmbedConfig();
     const headers: Record<string, string | undefined> = {
         'Content-Type': 'application/json',
         'x-requested-by': 'ThoughtSpot',
     };
 
-    if (authToken) {
-        headers.Authorization = `Bearer ${authToken}`;
-    }
-
     const payload = {
         metadata_tmls: data.metadata_tmls,
         import_policy: data.import_policy || 'PARTIAL',
         create_new: data.create_new || false,
     };
-    return fetch(`${thoughtSpotHost}${EndPoints.EXECUTE_TML}`, {
+    return tokenizedFetch(`${thoughtSpotHost}${EndPoints.EXECUTE_TML}`, {
         method: 'POST',
         headers,
         body: JSON.stringify(payload),
@@ -351,14 +336,13 @@ export const executeTML = async (data: executeTMLInput): Promise<any> => {
     console.error(error);
   });
  * ```
- *
  * @version SDK: 1.23.0 | ThoughtSpot: 9.4.0.cl
  * @group Global methods
  */
 export const exportTML = async (data: exportTMLInput): Promise<any> => {
-    const { thoughtSpotHost, authType } = config;
+    const { thoughtSpotHost, authType } = getEmbedConfig();
     try {
-        sanity(config);
+        sanity(getEmbedConfig());
     } catch (err) {
         return Promise.reject(err);
     }
@@ -369,21 +353,12 @@ export const exportTML = async (data: exportTMLInput): Promise<any> => {
         edoc_format: data.edoc_format || 'YAML',
     };
 
-    let authToken = '';
-    if (authType === AuthType.TrustedAuthTokenCookieless) {
-        authToken = await getAuthenticationToken(config);
-    }
-
     const headers: Record<string, string | undefined> = {
         'Content-Type': 'application/json',
         'x-requested-by': 'ThoughtSpot',
     };
 
-    if (authToken) {
-        headers.Authorization = `Bearer ${authToken}`;
-    }
-
-    return fetch(`${thoughtSpotHost}${EndPoints.EXPORT_TML}`, {
+    return tokenizedFetch(`${thoughtSpotHost}${EndPoints.EXPORT_TML}`, {
         method: 'POST',
         headers,
         body: JSON.stringify(payload),
@@ -407,7 +382,7 @@ export const exportTML = async (data: exportTMLInput): Promise<any> => {
  *
  */
 export function reset(): void {
-    config = {} as any;
+    setEmbedConfig({} as any);
     setAuthEE(null);
     authPromise = null;
 }

package/src/embed/embedConfig.ts

@@ -0,0 +1,23 @@
+import { EmbedConfig } from '../types';
+
+let config = {} as EmbedConfig;
+
+/**
+ * Gets the configuration embed was initialized with.
+ *
+ * @returns {@link EmbedConfig} The configuration embed was initialized with.
+ * @version SDK: 1.19.0 | ThoughtSpot: *
+ * @group Global methods
+ */
+export const getEmbedConfig = (): EmbedConfig => config;
+
+/**
+ * Sets the configuration embed was initialized with.
+ *
+ * @param newConfig The configuration to set.
+ * @version SDK: 1.27.0 | ThoughtSpot: *
+ * @group Global methods
+ */
+export const setEmbedConfig = (newConfig: EmbedConfig) => {
+    config = newConfig;
+};

package/src/embed/search.ts

@@ -8,12 +8,7 @@
  */
 
 import {
-    DataSourceVisualMode,
-    DOMSelector,
-    Param,
-    Action,
-    ViewConfig,
-    RuntimeFilter,
+    DataSourceVisualMode, DOMSelector, Param, Action, ViewConfig,
 } from '../types';
 import {
     getQueryParamString,
@@ -22,10 +17,10 @@ import {
     getRuntimeParameters,
 } from '../utils';
 import { TsEmbed } from './ts-embed';
-import { version } from '../../package.json';
 import { ERROR_MESSAGE } from '../errors';
-import { getAuthPromise, getEmbedConfig } from './base';
+import { getAuthPromise } from './base';
 import { getReleaseVersion } from '../auth';
+import { getEmbedConfig } from './embedConfig';
 
 /**
  * Configuration for search options
@@ -52,7 +47,11 @@ export interface SearchOptions {
 export interface SearchViewConfig
     extends Omit<
         ViewConfig,
-        'hiddenHomepageModules' | 'hiddenHomeLeftNavItems' | 'hiddenTabs' | 'visibleTabs' | 'reorderedHomepageModules'
+        | 'hiddenHomepageModules'
+        | 'hiddenHomeLeftNavItems'
+        | 'hiddenTabs'
+        | 'visibleTabs'
+        | 'reorderedHomepageModules'
     > {
     /**
      * If set to true, the data sources panel is collapsed on load,
@@ -274,7 +273,8 @@ export class SearchEmbed extends TsEmbed {
             if (
                 checkReleaseVersionInBeta(
                     getReleaseVersion(),
-                    getEmbedConfig().suppressSearchEmbedBetaWarning,
+                    getEmbedConfig().suppressSearchEmbedBetaWarning
+                        || getEmbedConfig().suppressErrorAlerts,
                 )
             ) {
                 alert(ERROR_MESSAGE.SEARCHEMBED_BETA_WRANING_MESSAGE);

package/src/embed/searchEmbed-basic-auth.spec.ts

@@ -3,6 +3,7 @@ import * as baseInstance from './base';
 import * as authService from '../utils/authService';
 import * as authInstance from '../auth';
 import * as config from '../config';
+import * as embedConfigInstance from './embedConfig';
 
 import { init } from '../index';
 import { AuthType } from '../types';
@@ -86,7 +87,7 @@ describe('Search embed tests when authType is Basic', () => {
     test('Alert should not appear when suppressSearchEmbedBetaWarning is true and releaseVersion is ts7.dec.cl', async () => {
         setupVersion('ts7.dec.cl');
         jest.spyOn(config, 'getThoughtSpotHost').mockImplementation(() => 'http://tshost');
-        jest.spyOn(baseInstance, 'getEmbedConfig').mockReturnValue({
+        jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValue({
             suppressSearchEmbedBetaWarning: true,
         });
         const mockAlert = jest.spyOn(window, 'alert');
@@ -98,7 +99,7 @@ describe('Search embed tests when authType is Basic', () => {
     test('Alert should not appear when suppressSearchEmbedBetaWarning is true and releaseVersion is 8.4.0.sw', async () => {
         setupVersion('8.4.0.sw');
         jest.spyOn(config, 'getThoughtSpotHost').mockImplementation(() => 'http://tshost');
-        jest.spyOn(baseInstance, 'getEmbedConfig').mockReturnValue({
+        jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValue({
             suppressSearchEmbedBetaWarning: true,
         });
         const mockAlert = jest.spyOn(window, 'alert');