@thoughtspot/visual-embed-sdk 1.29.0-alpha.7 → 1.29.0-alpha.SCAL-205893-1

package/src/auth.spec.ts

@@ -1,12 +1,14 @@
 import * as authInstance from './auth';
-import * as authService from './utils/authService/authService';
-import * as tokenAuthService from './utils/authService/tokenizedAuthService';
-import * as checkReleaseVersionInBetaInstance from './utils';
-import * as mixPanelService from './mixpanel-service';
+import * as authTokenService from './authToken';
 import * as EmbedConfig from './embed/embedConfig';
-import { AuthType, EmbedEvent } from './types';
+import * as mixPanelService from './mixpanel-service';
 import { executeAfterWait } from './test/test-utils';
-import { resetCachedAuthToken } from './authToken';
+import { AuthType, EmbedEvent } from './types';
+import * as checkReleaseVersionInBetaInstance from './utils';
+import * as authService from './utils/authService/authService';
+import * as tokenAuthService from './utils/authService/tokenizedAuthService';
+import { logger } from './utils/logger';
+import * as SessionService from './utils/sessionInfoService';
 
 const thoughtSpotHost = 'http://localhost:3000';
 const username = 'tsuser';
@@ -18,7 +20,7 @@ export const embedConfig: any = {
         thoughtSpotHost,
         username,
         authEndpoint: 'auth',
-        authType: AuthType.AuthServer,
+        authType: AuthType.TrustedAuthToken,
         getAuthToken: jest.fn(() => Promise.resolve(token)),
     }),
     doTokenAuthWithCookieDetect: {
@@ -112,31 +114,47 @@ export const mockSessionInfo = {
     },
 };
 
+export const mockSessionInfoApiResponse = {
+    userGUID: '1234',
+    releaseVersion: 'test',
+    configInfo: {
+        isPublicUser: false,
+        mixpanelConfig: {
+            production: true,
+            devSdkKey: 'devKey',
+            prodSdkKey: 'prodKey',
+        },
+    },
+};
+
 describe('Unit test for auth', () => {
     beforeEach(() => {
+        jest.resetAllMocks();
         global.fetch = window.fetch;
     });
     afterEach(() => {
-        resetCachedAuthToken();
+        authTokenService.resetCachedAuthToken();
+        SessionService.resetCachedSessionInfo();
     });
     test('endpoints, SAML_LOGIN_TEMPLATE', () => {
         const ssoTemplateUrl = authService.EndPoints.SAML_LOGIN_TEMPLATE(thoughtSpotHost);
         expect(ssoTemplateUrl).toBe(`/callosum/v1/saml/login?targetURLPath=${thoughtSpotHost}`);
     });
 
-    test('when session info giving response', async () => {
-        jest.spyOn(mixPanelService, 'initMixpanel').mockImplementation(() => Promise.resolve());
-        authInstance.initSession(mockSessionInfo);
-        const sessionInfo = await authInstance.getSessionInfo();
-        expect(sessionInfo).toStrictEqual(mockSessionInfo);
+    test('when session info giving response, it is cached', async () => {
+        jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockResolvedValueOnce(mockSessionInfoApiResponse);
+        const sessionInfo = await SessionService.getSessionInfo();
+        expect(sessionInfo.mixpanelToken).toEqual('prodKey');
+        expect(sessionInfo.isPublicUser).toEqual(false);
+        await SessionService.getSessionInfo();
+        expect(tokenAuthService.fetchSessionInfoService).toHaveBeenCalledTimes(1);
     });
 
     test('Disable mixpanel when disableSDKTracking flag is set', () => {
-        jest.clearAllMocks();
-        jest.resetAllMocks();
         jest.spyOn(mixPanelService, 'initMixpanel');
+        jest.spyOn(SessionService, 'getSessionInfo').mockReturnValue(mockSessionInfo);
         jest.spyOn(EmbedConfig, 'getEmbedConfig').mockReturnValue({ disableSDKTracking: true });
-        authInstance.initSession(mockSessionInfo);
+        authInstance.postLoginService();
         expect(mixPanelService.initMixpanel).not.toBeCalled();
     });
 
@@ -163,28 +181,22 @@ describe('Unit test for auth', () => {
     });
 
     test('doTokenAuth: when user is loggedIn', async () => {
-        jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(async () => ({
-            json: () => mockSessionInfo,
-            status: 200,
-        }));
-        jest.spyOn(authInstance, 'getSessionDetails').mockReturnValue(mockSessionInfo);
-        jest.spyOn(authInstance, 'initSession').mockReturnValue(null);
+        const getAuthenticationTokenMock = jest.spyOn(authTokenService, 'getAuthenticationToken');
+        jest.spyOn(tokenAuthService, 'isActiveService').mockImplementation(async () => true);
         await authInstance.doTokenAuth(embedConfig.doTokenAuthSuccess('authToken'));
-        expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
+        expect(authTokenService.getAuthenticationToken).not.toBeCalled();
         expect(authInstance.loggedInStatus).toBe(true);
+        getAuthenticationTokenMock.mockRestore();
     });
 
     test('doTokenAuth: when user is not loggedIn & getAuthToken have response', async () => {
-        jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => false);
-        jest.spyOn(authService, 'fetchAuthTokenService').mockImplementation(() => ({
-            text: () => Promise.resolve('abc'),
-        }));
+        jest.spyOn(tokenAuthService, 'isActiveService').mockImplementation(async () => false);
         jest.spyOn(authService, 'fetchAuthService').mockImplementation(() => Promise.resolve({
             status: 200,
+            ok: true,
         }));
         jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(true);
         await authInstance.doTokenAuth(embedConfig.doTokenAuthSuccess('authToken2'));
-        expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
         expect(authService.fetchAuthService).toBeCalledWith(
             thoughtSpotHost,
             username,
@@ -193,26 +205,25 @@ describe('Unit test for auth', () => {
     });
 
     test('doTokenAuth: when user is not loggedIn & getAuthToken not present, isLoggedIn should called', async () => {
-        jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => false);
-        jest.spyOn(authService, 'fetchAuthTokenService').mockImplementation(() => Promise.resolve({ text: () => Promise.resolve('abc') }));
+        jest.spyOn(tokenAuthService, 'isActiveService').mockImplementation(async () => false);
+        jest.spyOn(authService, 'fetchAuthTokenService').mockImplementation(() => ({
+            text: () => Promise.resolve('abc'),
+        }));
         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');
         await executeAfterWait(() => {
             expect(authInstance.loggedInStatus).toBe(true);
-            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
-            expect(authService.fetchAuthService).toBeCalledWith(
-                thoughtSpotHost,
-                username,
-                'authToken2',
-            );
+            expect(authService.fetchAuthService).toBeCalledWith(thoughtSpotHost, username, 'abc');
         });
     });
 
     test('doTokenAuth: Should raise error when duplicate token is used', async () => {
+        jest.spyOn(tokenAuthService, 'isActiveService').mockImplementation(async () => false);
         jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockResolvedValue({
             status: 401,
         });
@@ -254,8 +265,10 @@ describe('Unit test for auth', () => {
             ok: true,
         }));
         jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(true);
+        jest.spyOn(tokenAuthService, 'isActiveService').mockResolvedValueOnce(false);
+        jest.spyOn(tokenAuthService, 'isActiveService').mockResolvedValueOnce(false);
         const isLoggedIn = await authInstance.doTokenAuth(embedConfig.doTokenAuthWithCookieDetect);
-        expect(tokenAuthService.fetchSessionInfoService).toHaveBeenCalledTimes(2);
+        expect(tokenAuthService.isActiveService).toHaveBeenCalledTimes(2);
         expect(isLoggedIn).toBe(false);
     });
 
@@ -278,7 +291,6 @@ describe('Unit test for auth', () => {
         expect(await authInstance.doTokenAuth(embedConfig.doTokenAuthSuccess('authToken2'))).toBe(
             true,
         );
-        expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
         expect(authService.fetchAuthPostService).toBeCalledWith(
             thoughtSpotHost,
             username,
@@ -297,20 +309,9 @@ describe('Unit test for auth', () => {
         });
 
         it('when user is loggedIn', async () => {
-            spyOn(checkReleaseVersionInBetaInstance, 'checkReleaseVersionInBeta');
-            jest.spyOn(authInstance, 'getSessionDetails').mockReturnValue(mockSessionInfo);
-            jest.spyOn(authInstance, 'initSession').mockReturnValue(null);
-            jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(
-                async () => ({
-                    json: () => mockSessionInfo,
-                    status: 200,
-                }),
-            );
+            jest.spyOn(tokenAuthService, 'isActiveService').mockResolvedValueOnce(true);
             await authInstance.doBasicAuth(embedConfig.doBasicAuth);
-            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(authInstance.loggedInStatus).toBe(true);
-            expect(authInstance.getSessionDetails).toBeCalled();
-            expect(authInstance.initSession).toBeCalled();
         });
 
         it('when user is not loggedIn', async () => {
@@ -321,7 +322,7 @@ describe('Unit test for auth', () => {
             }));
 
             await authInstance.doBasicAuth(embedConfig.doBasicAuth);
-            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
+            // expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(authService.fetchBasicAuthService).toBeCalled();
             expect(authInstance.loggedInStatus).toBe(true);
         });
@@ -349,10 +350,8 @@ describe('Unit test for auth', () => {
                     status: 200,
                 }),
             );
-            jest.spyOn(authInstance, 'getSessionDetails').mockReturnValue(mockSessionInfo);
-            jest.spyOn(authInstance, 'initSession').mockReturnValue(null);
+            jest.spyOn(tokenAuthService, 'isActiveService').mockReturnValue(true);
             await authInstance.doSamlAuth(embedConfig.doSamlAuth);
-            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(window.location.hash).toBe('');
             expect(authInstance.loggedInStatus).toBe(true);
         });
@@ -360,7 +359,6 @@ describe('Unit test for auth', () => {
         it('when user is not loggedIn & isAtSSORedirectUrl is true', async () => {
             jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => Promise.reject());
             await authInstance.doSamlAuth(embedConfig.doSamlAuth);
-            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(window.location.hash).toBe('');
             expect(authInstance.loggedInStatus).toBe(false);
         });
@@ -374,7 +372,6 @@ describe('Unit test for auth', () => {
             });
             jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => Promise.reject());
             await authInstance.doSamlAuth(embedConfig.doSamlAuth);
-            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(global.window.location.href).toBe(samalLoginUrl);
         });
 
@@ -387,14 +384,9 @@ describe('Unit test for auth', () => {
             });
             spyOn(authInstance, 'samlCompletionPromise');
             global.window.open = jest.fn();
-            jest.spyOn(tokenAuthService, 'fetchSessionInfoService')
-                .mockImplementationOnce(() => Promise.reject())
-                .mockImplementationOnce(async () => ({
-                    json: () => mockSessionInfo,
-                    status: 200,
-                }));
-            jest.spyOn(authInstance, 'getSessionDetails').mockReturnValue(mockSessionInfo);
-            jest.spyOn(authInstance, 'initSession').mockReturnValue(null);
+            jest.spyOn(tokenAuthService, 'isActiveService')
+                .mockReturnValueOnce(false)
+                .mockReturnValueOnce(true);
             expect(await authInstance.samlCompletionPromise).not.toBe(null);
             expect(
                 await authInstance.doSamlAuth({
@@ -404,15 +396,13 @@ describe('Unit test for auth', () => {
             document.getElementById('ts-auth-btn').click();
             window.postMessage({ type: EmbedEvent.SAMLComplete }, '*');
             await authInstance.samlCompletionPromise;
-            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
-            expect(authInstance.getSessionDetails).toBeCalled();
-            expect(authInstance.initSession).toBeCalled();
+            expect(authInstance.loggedInStatus).toBe(true);
         });
     });
 
     describe('doOIDCAuth', () => {
         afterEach(() => {
-            resetCachedAuthToken();
+            authTokenService.resetCachedAuthToken();
             delete global.window;
             global.window = Object.create(originalWindow);
             global.window.open = jest.fn();
@@ -422,7 +412,6 @@ describe('Unit test for auth', () => {
         it('when user is not loggedIn & isAtSSORedirectUrl is true', async () => {
             jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => Promise.reject());
             await authInstance.doOIDCAuth(embedConfig.doOidcAuth);
-            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(window.location.hash).toBe('');
             expect(authInstance.loggedInStatus).toBe(false);
         });
@@ -465,6 +454,7 @@ describe('Unit test for auth', () => {
 
     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.loggedInStatus).toBe(true);
@@ -481,6 +471,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);
         const isLoggedIn = await authInstance.doCookielessTokenAuth(
             embedConfig.doCookielessAuth('testToken'),
@@ -500,11 +491,11 @@ describe('Unit test for auth', () => {
         authInstance.setAuthEE(testObject as any);
         expect(authInstance.getAuthEE()).toBe(testObject);
     });
-    it('getSessionDetails returns the correct details given sessionInfo', () => {
+    it('getSessionDetails returns the correct details given sessionInfo', async () => {
         jest.clearAllMocks();
         jest.restoreAllMocks();
 
-        const details = authInstance.getSessionDetails({
+        jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockReturnValue({
             userGUID: '1234',
             releaseVersion: '1',
             configInfo: {
@@ -515,13 +506,14 @@ describe('Unit test for auth', () => {
                 },
             },
         });
+        const details = await SessionService.getSessionInfo();
         expect(details).toEqual(
             expect.objectContaining({
                 mixpanelToken: 'devKey',
             }),
         );
 
-        const details2 = authInstance.getSessionDetails({
+        jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockReturnValue({
             configInfo: {
                 mixpanelConfig: {
                     devSdkKey: 'devKey',
@@ -530,10 +522,38 @@ describe('Unit test for auth', () => {
                 },
             },
         });
+
+        SessionService.resetCachedSessionInfo();
+        const details2 = await SessionService.getSessionInfo();
         expect(details2).toEqual(
             expect.objectContaining({
                 mixpanelToken: 'prodKey',
             }),
         );
     });
+
+    test('notifyAuthSuccess if getSessionInfo returns data', async () => {
+        const dummyInfo = { test: 'dummy' };
+        jest.spyOn(SessionService, 'getSessionInfo').mockResolvedValueOnce(dummyInfo);
+        jest.spyOn(logger, 'error').mockResolvedValueOnce(true);
+        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);
+        authInstance.setAuthEE(null);
+    });
+
+    test('notifyAuthSuccess if getSessionInfo fails', async () => {
+        jest.spyOn(SessionService, 'getSessionInfo').mockImplementation(() => {
+            throw new Error('error');
+        });
+        jest.spyOn(logger, 'error');
+        const emitSpy = jest.fn();
+        authInstance.setAuthEE({ emit: emitSpy } as any);
+        await authInstance.notifyAuthSuccess();
+        expect(logger.error).toBeCalled();
+        expect(emitSpy).not.toBeCalled();
+        authInstance.setAuthEE(null);
+    });
 });

package/src/auth.ts

@@ -1,20 +1,21 @@
 import EventEmitter from 'eventemitter3';
+import { getAuthenticationToken, resetCachedAuthToken } from './authToken';
+import { getEmbedConfig } from './embed/embedConfig';
 import { initMixpanel } from './mixpanel-service';
 import {
-    AuthType, DOMSelector, EmbedConfig, EmbedEvent, Param,
+    AuthType, DOMSelector, EmbedConfig, EmbedEvent,
 } from './types';
 import { getDOMNode, getRedirectUrl } from './utils';
 import {
-    fetchSessionInfoService,
+    EndPoints,
+    fetchAuthPostService,
     fetchAuthService,
     fetchBasicAuthService,
     fetchLogoutService,
-    fetchAuthPostService,
-    EndPoints,
 } from './utils/authService';
-import { getAuthenticationToken, resetCachedAuthToken } from './authToken';
+import { isActiveService } from './utils/authService/tokenizedAuthService';
 import { logger } from './utils/logger';
-import { getEmbedConfig } from './embed/embedConfig';
+import { getSessionInfo } from './utils/sessionInfoService';
 
 // eslint-disable-next-line import/no-mutable-exports
 export let loggedInStatus = false;
@@ -22,22 +23,11 @@ export let loggedInStatus = false;
 export let samlAuthWindow: Window = null;
 // eslint-disable-next-line import/no-mutable-exports
 export let samlCompletionPromise: Promise<void> = null;
-let sessionInfo: sessionInfoInterface = null;
-let sessionInfoResolver: (value: sessionInfoInterface) => void = null;
-const sessionInfoPromise = new Promise((resolve: (value: sessionInfoInterface) => void) => {
-    sessionInfoResolver = resolve;
-});
+
 let releaseVersion = '';
 
 export const SSO_REDIRECTION_MARKER_GUID = '5e16222e-ef02-43e9-9fbd-24226bf3ce5b';
 
-interface sessionInfoInterface {
-    userGUID: any;
-    isPublicUser: any;
-    mixpanelToken: any;
-    [key: string]: any;
-}
-
 /**
  * Enum for auth failure types. This is the parameter passed to the listner
  * of {@link AuthStatus.FAILURE}.
@@ -180,12 +170,17 @@ export function notifyAuthSDKSuccess(): void {
 /**
  *
  */
-export function notifyAuthSuccess(): void {
+export async function notifyAuthSuccess(): Promise<void> {
     if (!authEE) {
         logger.error('SDK not initialized');
         return;
     }
-    authEE.emit(AuthStatus.SUCCESS, sessionInfo);
+    try {
+        const sessionInfo = await getSessionInfo();
+        authEE.emit(AuthStatus.SUCCESS, sessionInfo);
+    } catch (e) {
+        logger.error('Failed to get session info');
+    }
 }
 
 /**
@@ -211,70 +206,46 @@ export function notifyLogout(): void {
     authEE.emit(AuthStatus.LOGOUT);
 }
 
-export const initSession = (sessionDetails: sessionInfoInterface) => {
-    const embedConfig = getEmbedConfig();
-    if (sessionInfo == null) {
-        sessionInfo = sessionDetails;
-        if (!embedConfig.disableSDKTracking) {
-            initMixpanel(sessionInfo);
-        }
-        sessionInfoResolver(sessionInfo);
-    }
-};
-
-export const getSessionDetails = (sessionInfoResp: any): sessionInfoInterface => {
-    const devMixpanelToken = sessionInfoResp.configInfo.mixpanelConfig.devSdkKey;
-    const prodMixpanelToken = sessionInfoResp.configInfo.mixpanelConfig.prodSdkKey;
-    const mixpanelToken = sessionInfoResp.configInfo.mixpanelConfig.production
-        ? prodMixpanelToken
-        : devMixpanelToken;
-    return {
-        userGUID: sessionInfoResp.userGUID,
-        mixpanelToken,
-        isPublicUser: sessionInfoResp.configInfo.isPublicUser,
-        releaseVersion: sessionInfoResp.releaseVersion,
-        clusterId: sessionInfoResp.configInfo.selfClusterId,
-        clusterName: sessionInfoResp.configInfo.selfClusterName,
-        ...sessionInfoResp,
-    };
-};
-
 /**
  * Check if we are logged into the ThoughtSpot cluster
  *
  * @param thoughtSpotHost The ThoughtSpot cluster hostname or IP
  */
 async function isLoggedIn(thoughtSpotHost: string): Promise<boolean> {
-    const authVerificationUrl = `${thoughtSpotHost}${EndPoints.AUTH_VERIFICATION}`;
-    let response = null;
     try {
-        response = await fetchSessionInfoService(authVerificationUrl);
-        const sessionInfoResp = await response.json();
-        const sessionDetails = getSessionDetails(sessionInfoResp);
-        // Store user session details from session info
-        initSession(sessionDetails);
-        releaseVersion = sessionInfoResp.releaseVersion;
+        const response = await isActiveService(thoughtSpotHost);
+        return response;
     } catch (e) {
         return false;
     }
-    return response.status === 200;
 }
 
 /**
- * Return releaseVersion if available
+ * Services to be called after the login is successful,
+ * This should be called after the cookie is set for cookie auth or
+ * after the token is set for cookieless.
+ *
+ * @return {Promise<void>}
+ * @example
+ * ```js
+ * await postLoginService();
+ * ```
+ * @version SDK: 1.28.3 | ThoughtSpot: *
  */
-export function getReleaseVersion() {
-    return releaseVersion;
+export async function postLoginService(): Promise<void> {
+    const sessionInfo = await getSessionInfo();
+    releaseVersion = sessionInfo.releaseVersion;
+    const embedConfig = getEmbedConfig();
+    if (!embedConfig.disableSDKTracking) {
+        initMixpanel(sessionInfo);
+    }
 }
 
 /**
- * Return a promise that resolves with the session information when
- * authentication is successful. And info is available.
- *
- * @group Global methods
+ * Return releaseVersion if available
  */
-export function getSessionInfo(): Promise<sessionInfoInterface> {
-    return sessionInfoPromise;
+export function getReleaseVersion() {
+    return releaseVersion;
 }
 
 /**
@@ -309,8 +280,15 @@ export const doTokenAuth = async (embedConfig: EmbedConfig): Promise<boolean> =>
         throw new Error('Either auth endpoint or getAuthToken function must be provided');
     }
     loggedInStatus = await isLoggedIn(thoughtSpotHost);
+
     if (!loggedInStatus) {
-        const authToken = await getAuthenticationToken(embedConfig);
+        let authToken: string;
+        try {
+            authToken = await getAuthenticationToken(embedConfig);
+        } catch (e) {
+            loggedInStatus = false;
+            throw e;
+        }
         let resp;
         try {
             resp = await fetchAuthPostService(thoughtSpotHost, username, authToken);
@@ -492,7 +470,7 @@ export const logout = async (embedConfig: EmbedConfig): Promise<boolean> => {
     const { thoughtSpotHost } = embedConfig;
     await fetchLogoutService(thoughtSpotHost);
     resetCachedAuthToken();
-    const thoughtspotIframes = document.querySelectorAll('[data-ts-iframe=\'true\']');
+    const thoughtspotIframes = document.querySelectorAll("[data-ts-iframe='true']");
     if (thoughtspotIframes?.length) {
         thoughtspotIframes.forEach((el) => {
             el.parentElement.innerHTML = embedConfig.loginFailedMessage;

package/src/authToken.spec.ts

@@ -0,0 +1,31 @@
+import { getAuthenticationToken, resetCachedAuthToken } from './authToken';
+import * as authServiceInstance from './utils/authService/authService';
+import { EmbedConfig } from './types';
+
+describe('AuthToken Unit tests', () => {
+    test('getAuthenticationToken: When verification is disabled', async () => {
+        jest.spyOn(authServiceInstance, 'verifyTokenService');
+
+        const token = await getAuthenticationToken({
+            getAuthToken: async () => 'abc3',
+            disableTokenVerification: true,
+        } as EmbedConfig);
+
+        expect(token).toBe('abc3');
+        expect(authServiceInstance.verifyTokenService).not.toBeCalled();
+    });
+
+    test.only('getAuthenticationToken: When verification is enabled', async () => {
+        resetCachedAuthToken();
+        jest.clearAllMocks();
+        jest.spyOn(authServiceInstance, 'verifyTokenService').mockImplementation(() => true);
+        const token = await getAuthenticationToken({
+            thoughtSpotHost: 'test',
+            getAuthToken: async () => 'abc2',
+            disableTokenVerification: false,
+        } as EmbedConfig);
+
+        expect(token).toBe('abc2');
+        expect(authServiceInstance.verifyTokenService).toBeCalledWith('test', 'abc2');
+    });
+});

package/src/authToken.ts

@@ -1,5 +1,6 @@
 import { EmbedConfig } from './types';
 import { fetchAuthTokenService, verifyTokenService } from './utils/authService/authService';
+import { logger } from './utils/logger';
 
 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.';
@@ -9,8 +10,10 @@ const INVALID_TOKEN_ERR = 'Invalid token received form token callback or authTok
 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) {
+export async function getAuthenticationToken(embedConfig: EmbedConfig): Promise<string> {
+    // Since we don't have token validation enabled , we cannot tell if the
+    // cached token is valid or not. So we will always fetch a new token.
+    if (cachedAuthToken && !embedConfig.disableTokenVerification) {
         let isCachedTokenStillValid;
         try {
             isCachedTokenStillValid = await validateAuthToken(embedConfig, cachedAuthToken, true);
@@ -31,18 +34,27 @@ export const getAuthenticationToken = async (embedConfig: EmbedConfig): Promise<
         authToken = await response.text();
     }
 
-    // this will throw error if the token is not valid
-    await validateAuthToken(embedConfig, authToken);
+    try {
+        // this will throw error if the token is not valid
+        await validateAuthToken(embedConfig, authToken);
+    } catch (e) {
+        logger.error(`Received invalid token from getAuthToken callback or authToken endpoint. Error : ${e.message}`);
+        throw e;
+    }
 
     cachedAuthToken = authToken;
     return authToken;
-};
+}
 
 const validateAuthToken = async (
     embedConfig: EmbedConfig,
     authToken: string,
     suppressAlert?: boolean,
 ): Promise<boolean> => {
+    if (embedConfig.disableTokenVerification) {
+        logger.info('Token verification is disabled. Assuming token is valid.');
+        return true;
+    }
     try {
         const isTokenValid = await verifyTokenService(embedConfig.thoughtSpotHost, authToken);
         if (isTokenValid) return true;

package/src/embed/app.spec.ts

@@ -24,6 +24,7 @@ import { version } from '../../package.json';
 import * as config from '../config';
 import { TsEmbed, V1Embed } from './ts-embed';
 import { logger } from '../utils/logger';
+import * as auth from '../auth';
 
 const defaultViewConfig = {
     frameParams: {
@@ -40,6 +41,7 @@ beforeAll(() => {
         thoughtSpotHost,
         authType: AuthType.None,
     });
+    jest.spyOn(auth, 'postLoginService').mockImplementation(() => Promise.resolve({}));
     (window as any).ResizeObserver = window.ResizeObserver
             || jest.fn().mockImplementation(() => ({
                 disconnect: jest.fn(),
@@ -72,13 +74,13 @@ describe('App embed tests', () => {
     test('should hide the primary nav bar', async () => {
         const appEmbed = new AppEmbed(getRootEl(), {
             ...defaultViewConfig,
-            showPrimaryNavbar: true,
+            showPrimaryNavbar: false,
         } as AppViewConfig);
         appEmbed.render();
         await executeAfterWait(() => {
             expectUrlMatchesWithParams(
                 getIFrameSrc(),
-                `http://${thoughtSpotHost}/?embedApp=true&primaryNavHidden=false&profileAndHelpInNavBarHidden=false${defaultParams}${defaultParamsPost}#/home`,
+                `http://${thoughtSpotHost}/?embedApp=true&primaryNavHidden=true&profileAndHelpInNavBarHidden=false${defaultParams}${defaultParamsPost}#/home`,
             );
         });
     });

package/src/embed/base.spec.ts

@@ -28,6 +28,7 @@ describe('Base TS Embed', () => {
             thoughtSpotHost,
             authType: index.AuthType.None,
         }) as EventEmitter;
+        jest.spyOn(auth, 'postLoginService').mockImplementation(() => Promise.resolve({}));
     });
 
     beforeEach(() => {