@thoughtspot/visual-embed-sdk 1.32.0-alpha.0 → 1.32.0-alpha.2

package/src/embed/embed.spec.ts

@@ -9,6 +9,7 @@ import {
     getIFrameEl,
     getRootEl,
 } from '../test/test-utils';
+import * as authInstance from '../auth';
 
 const thoughtSpotHost = 'tshost';
 const defaultViewConfig = {
@@ -24,6 +25,7 @@ beforeAll(() => {
         authType: AuthType.None,
     });
     spyOn(window, 'alert');
+    jest.spyOn(authInstance, 'postLoginService').mockResolvedValue(true);
 });
 
 describe('test view config', () => {

package/src/embed/events.spec.ts

@@ -20,6 +20,7 @@ import {
     postMessageToParent,
 } from '../test/test-utils';
 import { LiveboardViewConfig } from './liveboard';
+import * as authInstance from '../auth';
 
 const thoughtSpotHost = 'tshost';
 const defaultViewConfig = {
@@ -36,6 +37,7 @@ beforeAll(() => {
         authType: AuthType.None,
     });
     spyOn(window, 'alert');
+    jest.spyOn(authInstance, 'postLoginService').mockReturnValue(true);
 });
 
 describe('test communication between host app and ThoughtSpot', () => {

package/src/embed/liveboard.spec.ts

@@ -23,6 +23,8 @@ import {
 } from '../test/test-utils';
 import * as tsEmbed from './ts-embed';
 import * as processTriggerInstance from '../utils/processTrigger';
+import * as auth from '../auth';
+import * as previewService from '../utils/graphql/preview-service';
 
 const defaultViewConfig = {
     frameParams: {
@@ -43,6 +45,7 @@ beforeAll(() => {
         thoughtSpotHost,
         authType: AuthType.None,
     });
+    jest.spyOn(auth, 'postLoginService').mockImplementation(() => Promise.resolve({}));
 });
 
 describe('Liveboard/viz embed tests', () => {
@@ -551,6 +554,39 @@ describe('Liveboard/viz embed tests', () => {
             });
         });
 
+        test('Show preview loader should not show the loader if not viz embed or showPreviewLoader is false', async () => {
+            const libEmbed = new LiveboardEmbed(getRootEl(), {
+                liveboardId: '1234',
+            });
+            await libEmbed.render();
+            await executeAfterWait(() => {
+                expect(getRootEl().innerHTML).not.toContain('ts-viz-preview-loader');
+            });
+        });
+
+        test('Show preview loader should show the loader if viz embed and showPreviewLoader is true', async () => {
+            jest.spyOn(previewService, 'getPreview').mockResolvedValue({
+                vizContent: '<div id=test>test</div>',
+            });
+            const libEmbed = new LiveboardEmbed(getRootEl(), {
+                liveboardId: '1234',
+                vizId: '5678',
+                showPreviewLoader: true,
+            });
+            await libEmbed.render();
+            expect(previewService.getPreview).toHaveBeenCalledWith('http://tshost', '5678', '1234');
+            await executeAfterWait(() => {
+                expect(getRootEl().style.position).toEqual('relative');
+                expect(getRootEl().innerHTML).toContain('<div class="ts-viz-preview-loader">');
+                expect(getRootEl().innerHTML).toContain('<div id="test">test</div>');
+            });
+
+            libEmbed.test__executeCallbacks(EmbedEvent.Data, {});
+            await executeAfterWait(() => {
+                expect(getRootEl().innerHTML).not.toContain('ts-viz-preview-loader');
+            });
+        });
+
         test('it should navigateToLiveboard with liveboard id is not passed', async (done) => {
             mockMessageChannel();
             const consoleSpy = jest.spyOn(console, 'error');

package/src/embed/liveboard.ts

@@ -8,6 +8,7 @@
  * @author Ayon Ghosh <ayon.ghosh@thoughtspot.com>
  */
 
+import { getPreview } from '../utils/graphql/preview-service';
 import { ERROR_MESSAGE } from '../errors';
 import {
     EmbedEvent,
@@ -21,6 +22,7 @@ import {
 import { getQueryParamString, isUndefined } from '../utils';
 import { getAuthPromise } from './base';
 import { V1Embed } from './ts-embed';
+import { addPreviewStylesIfNotPresent } from '../utils/global-styles';
 
 /**
  * The configuration for the embedded Liveboard or visualization page view.
@@ -259,6 +261,29 @@ export interface LiveboardViewConfig
      * ```
      */
     enable2ColumnLayout?: boolean;
+    /**
+     * Show a preview image of the visualization before the visualization loads.
+     * Only works for visualizations embeds with a viz id.
+     *
+     * Also, viz snashot should be enabled in the ThoughtSpot instance.
+     * Contact ThoughtSpot support to enable this feature.
+     *
+     * Since, this will show preview images, be careful that it may show
+     * undesired data to the user when using row level security.
+     *
+     * @example
+     * ```js
+     * const embed = new LiveboardEmbed('#embed-container', {
+     *   liveboardId: 'liveboard-id',
+     *   vizId: 'viz-id',
+     *   showPreviewLoader: true,
+     * });
+     * embed.render();
+     * ```
+     *
+     * @version SDK: 1.32.0 | ThoughtSpot: 10.0.0.cl
+     */
+    showPreviewLoader?: boolean;
 }
 
 /**
@@ -431,6 +456,40 @@ export class LiveboardEmbed extends V1Embed {
         }
     }
 
+    private async showPreviewLoader() {
+        if (!this.viewConfig.showPreviewLoader || !this.viewConfig.vizId) {
+            return;
+        }
+
+        try {
+            const preview = await getPreview(
+                this.thoughtSpotHost,
+                this.viewConfig.vizId,
+                this.viewConfig.liveboardId,
+            );
+
+            if (!preview.vizContent) {
+                return;
+            }
+            addPreviewStylesIfNotPresent();
+
+            const div = document.createElement('div');
+            div.innerHTML = `
+                <div class=ts-viz-preview-loader>
+                    ${preview.vizContent}
+                </div>
+                `;
+            const previewDiv = div.firstElementChild as HTMLElement;
+            this.el.appendChild(previewDiv);
+            this.el.style.position = 'relative';
+            this.on(EmbedEvent.Data, () => {
+                previewDiv.remove();
+            });
+        } catch (error) {
+            console.error('Error fetching preview', error);
+        }
+    }
+
     protected beforePrerenderVisible(): void {
         const embedObj = this.insertedDomEl?.[this.embedNodeKey] as LiveboardEmbed;
 
@@ -480,6 +539,7 @@ export class LiveboardEmbed extends V1Embed {
 
         const src = this.getIFrameSrc();
         await this.renderV1Embed(src);
+        this.showPreviewLoader();
 
         return this;
     }
@@ -502,4 +562,4 @@ export class LiveboardEmbed extends V1Embed {
 /**
  * @hidden
  */
-export class PinboardEmbed extends LiveboardEmbed {}
+export class PinboardEmbed extends LiveboardEmbed { }

package/src/embed/pinboard.spec.ts

@@ -13,6 +13,7 @@ import {
     expectUrlMatchesWithParams,
 } from '../test/test-utils';
 import { version } from '../../package.json';
+import * as auth from '../auth';
 
 const defaultViewConfig = {
     frameParams: {
@@ -30,6 +31,7 @@ beforeAll(() => {
         thoughtSpotHost,
         authType: AuthType.None,
     });
+    jest.spyOn(auth, 'postLoginService').mockReturnValue(true);
 });
 
 describe('Pinboard/viz embed tests', () => {

package/src/embed/sage.spec.ts

@@ -9,6 +9,8 @@ import {
     getRootEl,
 } from '../test/test-utils';
 
+import * as authInstance from '../auth';
+
 const defaultConfig: SageViewConfig = {
     disableWorksheetChange: false,
     hideWorksheetSelector: false,
@@ -26,6 +28,7 @@ beforeAll(() => {
         authType: AuthType.None,
     });
     spyOn(window, 'alert');
+    jest.spyOn(authInstance, 'postLoginService').mockResolvedValue(true);
 });
 
 describe('Sage  embed tests', () => {

package/src/embed/search.spec.ts

@@ -36,6 +36,7 @@ beforeAll(() => {
         thoughtSpotHost,
         authType: AuthType.None,
     });
+    jest.spyOn(authInstance, 'postLoginService').mockImplementation(() => Promise.resolve({}));
     spyOn(window, 'alert');
 });
 

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

@@ -8,9 +8,12 @@ import {
     getRootEl,
 } from '../test/test-utils';
 
+import * as authInstance from '../auth';
+
 describe('Trigger', () => {
     beforeEach(() => {
         document.body.innerHTML = getDocumentBody();
+        jest.spyOn(authInstance, 'postLoginService').mockResolvedValue(true);
     });
     test('should trigger the event', async (done) => {
         init({

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

@@ -84,6 +84,10 @@ describe('Unit test case for ts embed', () => {
         resetCachedAuthToken();
     });
 
+    beforeAll(() => {
+        jest.spyOn(authInstance, 'postLoginService').mockResolvedValue(true);
+    });
+
     describe('AuthExpire embedEvent in cookieless authentication authType', () => {
         beforeAll(() => {
             jest.spyOn(authInstance, 'doCookielessTokenAuth').mockResolvedValueOnce(true);
@@ -730,6 +734,7 @@ describe('Unit test case for ts embed', () => {
             const mockPort: any = {
                 postMessage: jest.fn(),
             };
+            const loggerSpy = jest.spyOn(logger, 'error').mockResolvedValueOnce(true);
             await executeAfterWait(() => {
                 const iframe = getIFrameEl();
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
@@ -739,6 +744,7 @@ describe('Unit test case for ts embed', () => {
                 expect(baseInstance.notifyAuthFailure).toBeCalledWith(
                     authInstance.AuthFailureType.EXPIRY,
                 );
+                expect(loggerSpy).toHaveBeenCalledTimes(1);
             });
 
             jest.spyOn(authService, 'verifyTokenService').mockClear();
@@ -757,6 +763,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 mockPort: any = {
                 postMessage: jest.fn(),
             };
@@ -770,6 +777,7 @@ describe('Unit test case for ts embed', () => {
                 expect(baseInstance.notifyAuthFailure).toBeCalledWith(
                     authInstance.AuthFailureType.EXPIRY,
                 );
+                expect(loggerSpy).toHaveBeenCalledTimes(1);
             });
 
             jest.spyOn(authService, 'verifyTokenService').mockClear();
@@ -1100,17 +1108,32 @@ describe('Unit test case for ts embed', () => {
     });
 
     describe('V1Embed ', () => {
+        beforeEach(() => {
+            jest.spyOn(config, 'getThoughtSpotHost').mockImplementation(() => 'http://tshost');
+        });
+
         test('when isRendered is true than isError will be true', () => {
-            spyOn(logger, 'error');
+            spyOn(logger, 'warn');
             const viEmbedIns = new tsEmbedInstance.V1Embed(getRootEl(), defaultViewConfig);
             expect(viEmbedIns['isError']).toBe(false);
             viEmbedIns.render();
             viEmbedIns.on(EmbedEvent.CustomAction, jest.fn()).render();
-            expect(viEmbedIns['isError']).toBe(true);
-            expect(logger.error).toHaveBeenCalledWith(
+            expect(logger.warn).toHaveBeenCalledWith(
                 'Please register event handlers before calling render',
             );
         });
+
+        test('Generates the correct url for V1Embed when V2 shell is enabled', async () => {
+            const v1Embed = new LiveboardEmbed(getRootEl(), {
+                ...defaultViewConfig,
+                liveboardId: '123',
+                enableV2Shell_experimental: true,
+            });
+            await v1Embed.render();
+            await executeAfterWait(() => {
+                expect(getIFrameSrc()).toContain('/v2/?');
+            });
+        });
     });
 
     describe('Navigate to Page API', () => {

package/src/embed/ts-embed.ts

@@ -93,7 +93,7 @@ export class TsEmbed {
     /**
      * The DOM node where the ThoughtSpot app is to be embedded.
      */
-    protected el: Element;
+    protected el: HTMLElement;
 
     /**
      * The key to store the embed instance in the DOM node
@@ -347,6 +347,7 @@ export class TsEmbed {
                     data: { authToken },
                 });
             } catch (e) {
+                logger.error(`Received invalid token. Error : ${e?.message}`);
                 processAuthFailure(e, this.isPreRendered ? this.preRenderWrapper : this.el);
             }
         } else if (autoLogin) {
@@ -368,7 +369,7 @@ export class TsEmbed {
      * @param query
      */
     protected getEmbedBasePath(query: string): string {
-        let queryString = query;
+        let queryString = (query.startsWith('?')) ? query : `?${query}`;
         if (this.shouldEncodeUrlQueryParams) {
             queryString = `?base64UrlEncodedFlags=${getEncodedQueryParamsString(
                 queryString.substr(1),
@@ -901,7 +902,7 @@ export class TsEmbed {
             isRegisteredBySDK,
         });
         if (this.isRendered) {
-            this.handleError('Please register event handlers before calling render');
+            logger.warn('Please register event handlers before calling render');
         }
         const callbacks = this.eventHandlerMap.get(messageType) || [];
         callbacks.push({ options, callback });
@@ -1257,7 +1258,9 @@ export class V1Embed extends TsEmbed {
             const filterQuery = getFilterQuery(runtimeFilters || []);
             queryString = [filterQuery, queryString].filter(Boolean).join('&');
         }
-        return this.getV1EmbedBasePath(queryString);
+        return (this.viewConfig.enableV2Shell_experimental)
+            ? this.getEmbedBasePath(queryString)
+            : this.getV1EmbedBasePath(queryString);
     }
 
     /**
@@ -1285,4 +1288,12 @@ export class V1Embed extends TsEmbed {
         const eventType = this.getCompatibleEventType(messageType);
         return super.on(eventType, callback, options);
     }
+
+    /**
+     * Only for testing purposes.
+     *
+     * @hidden
+     */
+    // eslint-disable-next-line camelcase
+    public test__executeCallbacks = this.executeCallbacks;
 }

package/src/index.ts

@@ -20,8 +20,9 @@ import { PinboardEmbed, LiveboardViewConfig, LiveboardEmbed } from './embed/live
 import { SearchEmbed, SearchViewConfig } from './embed/search';
 import { SearchBarEmbed, SearchBarViewConfig } from './embed/search-bar';
 import {
-    AuthFailureType, AuthStatus, AuthEvent, AuthEventEmitter, getSessionInfo,
+    AuthFailureType, AuthStatus, AuthEvent, AuthEventEmitter,
 } from './auth';
+import { getSessionInfo } from './utils/sessionInfoService';
 import {
     AuthType,
     RuntimeFilter,

package/src/mixpanel-service.spec.ts

@@ -6,6 +6,8 @@ import {
     testResetMixpanel,
 } from './mixpanel-service';
 import { AuthType } from './types';
+import { SessionInfo } from './utils/sessionInfoService';
+import { logger } from './utils/logger';
 
 const config = {
     thoughtSpotHost: 'https://10.87.89.232',
@@ -29,7 +31,7 @@ describe('Unit test for mixpanel', () => {
             mixpanelToken: 'abc123',
             userGUID: '12345',
             isPublicUser: false,
-        };
+        } as SessionInfo;
         initMixpanel(sessionInfo);
         expect(mixpanel.init).toHaveBeenCalledWith(sessionInfo.mixpanelToken, undefined, 'tsEmbed');
         expect(mixpanel.identify).toHaveBeenCalledWith(sessionInfo.userGUID);
@@ -49,7 +51,7 @@ describe('Unit test for mixpanel', () => {
             clusterId: 'newClusterId',
             clusterName: 'newClusterName',
             releaseVersion: 'newReleaseVersion',
-        };
+        } as SessionInfo;
         initMixpanel(sessionInfo);
 
         expect(mixpanel.init).toHaveBeenCalledWith(sessionInfo.mixpanelToken, undefined, 'tsEmbed');
@@ -74,8 +76,15 @@ describe('Unit test for mixpanel', () => {
             mixpanelToken: 'abc123',
             userGUID: '12345',
             isPublicUser: false,
-        };
+        } as SessionInfo;
         initMixpanel(sessionInfo);
         expect(mixpanel.track).toHaveBeenCalledTimes(2);
     });
+
+    test('init mixpanel with no mixpanel token', () => {
+        jest.spyOn(logger, 'error').mockReturnValueOnce(true);
+        initMixpanel({ test: 'dummy' } as any);
+        expect(logger.error).toHaveBeenCalled();
+        expect(mixpanel.register_once).not.toHaveBeenCalled();
+    });
 });

package/src/mixpanel-service.ts

@@ -1,5 +1,6 @@
 import * as mixpanel from 'mixpanel-browser';
 import { logger } from './utils/logger';
+import { SessionInfo } from './utils/sessionInfoService';
 
 export const EndPoints = {
     CONFIG: '/callosum/v1/system/config',
@@ -54,8 +55,9 @@ function emptyQueue() {
  *
  * @param sessionInfo
  */
-export function initMixpanel(sessionInfo: any): void {
+export function initMixpanel(sessionInfo: SessionInfo): void {
     if (!sessionInfo || !sessionInfo.mixpanelToken) {
+        logger.error('Mixpanel token not found in session info');
         return;
     }
     // On a public cluster the user is anonymous, so don't set the identify to

package/src/react/index.spec.tsx

@@ -24,6 +24,9 @@ import {
 
 import { version } from '../../package.json';
 
+import * as auth from '../auth';
+import * as sessionService from '../utils/sessionInfoService';
+
 const thoughtSpotHost = 'localhost';
 
 beforeAll(() => {
@@ -31,6 +34,10 @@ beforeAll(() => {
         thoughtSpotHost,
         authType: AuthType.None,
     });
+    jest.spyOn(auth, 'postLoginService').mockReturnValue(true);
+    jest.spyOn(sessionService, 'getSessionInfo').mockReturnValue({
+        userGUID: 'abcd',
+    });
     spyOn(window, 'alert');
 });
 

package/src/react/index.tsx

@@ -370,4 +370,5 @@ export {
     HomeLeftNavItem,
     HomepageModule,
     LogLevel,
+    getSessionInfo,
 } from '../index';

package/src/tokenizedFetch.ts

@@ -6,8 +6,16 @@ import { AuthType } from './types';
 /**
  * Fetch wrapper that adds the authentication token to the request.
  * Use this to call the ThoughtSpot APIs when using the visual embed sdk.
+ * The interface for this method is the same as Web `Fetch`.
+ *
  * @param input
  * @param init
+ * @example
+ * ```js
+ * tokenizedFetch("<TS_ORIGIN>/api/rest/2.0/auth/session/user", {
+ *   // .. fetch options ..
+ * });
+ *```
  * @version SDK: 1.28.0
  * @group Global methods
  */

package/src/types.ts

@@ -998,6 +998,20 @@ export interface ViewConfig {
      * @version SDK: 1.29.0 | ThoughtSpot: 10.1.0.cl
      */
     excludeRuntimeParametersfromURL?: boolean;
+    /**
+     * Enable the V2 shell. This can provide performance benefits
+     * due to a lighterweight shell.
+     * @example
+     * ```js
+     * const embed = new LiveboardEmbed('#embed', {
+     *   liveboardId: '123',
+     *   enableV2Shell_experimental: true
+     * });
+     * ```
+     * @version SDK: 1.31.2 | ThoughtSpot: 10.0.0.cl
+     */
+    // eslint-disable-next-line camelcase
+    enableV2Shell_experimental?: boolean;
 }
 
 /**
@@ -2086,26 +2100,33 @@ export enum EmbedEvent {
     /**
      * Emitted when user wants to intercept the search execution
      *
-     * Make isOnBeforeGetVizDataEnabled : true to use this embed
-     * event
+     * Set IsOnBeforeGetVizDataInterceptEnabled : true to use
+     * this embed event
      *
      *```js
-     * searchEmbed.on(EmbedEvent.OnBeforeGetVizData, (payload, responder) => {
-     * responder({
-     * data: {
-     * execute: true,
-     * error: {errorText: "My own customised error"}
-     * }})
-     *   })
+     * searchEmbed.on(EmbedEvent.OnBeforeGetVizDataIntercept,
+     * (payload, responder) => {
+     *  responder({
+     *      data: {
+     *          execute: true,
+     *   }})
+     * })
      *```
-     * @version SDK : 1.29.0 | Thoughtspot : 10.1.0.cl
-     */
-     OnBeforeGetVizDataIntercept = 'onBeforeGetVizDataIntercept',
-     /**
-      * Emitted when runtime parameters changes
-      * @version SDK : 1.29.0 | Thoughtspot : 10.1.0.cl
-      */
-     ParameterChanged = 'ParameterChanged'
+     * @version SDK : 1.29.0 | Thoughtspot : 10.2.0.cl
+     */
+    OnBeforeGetVizDataIntercept = 'onBeforeGetVizDataIntercept',
+    /**
+     * Emitted when parameter changes in an answer
+     * or liveboard
+     *
+     * ```js
+     * liveboardEmbed.on(EmbedEvent.ParameterChanged, (payload) => {
+     *     console.log('payload', payload);
+     * })
+     *```
+     * @version SDK : 1.29.0 | Thoughtspot : 10.2.0.cl
+     */
+    ParameterChanged = 'parameterChanged',
 }
 
 /**
@@ -2325,7 +2346,7 @@ export enum HostEvent {
      * sorting, toggling of legends, and data drill down.
      * @example
      * ```js
-     * liveboardEmbed.trigger(HostEvent.getexportrequestforcurrentpinboard).then(
+     * liveboardEmbed.trigger(HostEvent.getExportRequestForCurrentPinboard).then(
      * data=>console.log(data))
      * ```
      * @version SDK: 1.13.0 | ThoughtSpot: 8.5.0.cl, 8.8.1.sw
@@ -2935,15 +2956,6 @@ export enum HostEvent {
      * @version SDK: 1.29.0 | Thoughtspot: 10.1.0.cl
      */
     ResetLiveboardPersonalisedView = 'ResetLiveboardPersonalisedView',
-    /**
-     * Trigger CreateLiveboard for liveboard list page & Pin Modal
-     * @example
-     * ```js
-     * liveboardEmbed.trigger(HostEvent.CreateLiveboard);
-     *
-     * @version SDK: 1.29.0 | Thoughtspot: 10.1.0.cl
-     */
-    CreateLiveboard = 'CreateLiveboard',
     /**
      * Triggers Update RuntimeParameters for answers and liveboard
      * @example
@@ -2959,8 +2971,10 @@ export enum HostEvent {
     /**
      * Triggers GetParameters to fetch the runtime parameters
      * ```js
-     * liveboardEmbed.trigger(HostEvent.GetParameters);
-     *
+     * liveboardEmbed.trigger(HostEvent.GetParameters).then((parameter) => {
+     *  console.log('parameters', parameter);
+     * });
+     *```
      * @version SDK: 1.29.0 | Thoughtspot: 10.1.0.cl
      */
     GetParameters = 'GetParameters',
@@ -3937,6 +3951,18 @@ export enum Action {
      */
     TML = 'tml',
 
+    /**
+     * Action Id for CreateLiveboard for liveboard list page & Pin Modal
+     * @example
+     * ```js
+     * hiddenAction: [Action.CreateLiveboard]
+     * disabledActions: [Action.CreateLiveboard]
+     * ```
+     *
+     * @version SDK: 1.32.0 | Thoughtspot: 10.1.0.cl
+     */
+    CreateLiveboard = 'CreateLiveboard',
+
     /**
      * Action ID for to hide Verified Liveboard Banner
      *  @example

package/src/utils/authService/authService.spec.ts

@@ -26,9 +26,10 @@ describe('Unit test for authService', () => {
             status: 200,
             ok: true,
         }));
-        const response = await fetchSessionInfoService(authVerificationUrl);
-        expect(response.status).toBe(200);
+        const response = await fetchSessionInfoService(thoughtSpotHost);
+        expect(response.success).toBe(true);
         expect(fetch).toHaveBeenCalledTimes(1);
+        expect(fetch).toBeCalledWith(`${thoughtSpotHost}${EndPoints.SESSION_INFO}`, {});
     });
 
     test('fetchAuthTokenService', async () => {
@@ -108,11 +109,15 @@ describe('Unit test for authService', () => {
             status: 500,
             ok: false,
         }));
-        await fetchSessionInfoService(authVerificationUrl);
-        expect(logger.error).toHaveBeenCalledWith('Failure', 'error');
+        try {
+            await fetchSessionInfoService(authVerificationUrl);
+        } catch (e) {
+            expect(e.message).toContain('Failed to fetch session info');
+        }
+        expect(logger.error).toHaveBeenCalledWith('Failed to fetch http://localhost:3000/callosum/v1/session/info', 'error');
     });
 
-    test('verifyTokenService', async () => {
+    test('verifyTokenService if token api works', async () => {
         global.fetch = jest.fn(() => Promise.resolve({ success: true, ok: true }));
         await verifyTokenService(thoughtSpotHost, authToken);
         expect(fetch).toBeCalledWith(`${thoughtSpotHost}${EndPoints.IS_ACTIVE}`, {
@@ -123,4 +128,12 @@ describe('Unit test for authService', () => {
             },
         });
     });
+
+    test('verifyTokenService if token api fails', async () => {
+        global.fetch = jest.fn(() => Promise.reject(new Error('error')));
+        jest.spyOn(logger, 'warn');
+        const status = await verifyTokenService(thoughtSpotHost, authToken);
+        expect(status).toBe(false);
+        expect(logger.warn).toHaveBeenCalledWith('Token Verification Service failed : error');
+    });
 });