@thoughtspot/visual-embed-sdk 1.26.1 → 1.26.2

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

@@ -1,4 +1,5 @@
 /* eslint-disable dot-notation */
+import { resetCachedAuthToken } from '../authToken';
 import {
     AuthType,
     init,
@@ -10,11 +11,7 @@ import {
     LiveboardEmbed,
 } from '../index';
 import {
-    Action,
-    HomeLeftNavItem,
-    RuntimeFilter,
-    RuntimeFilterOp,
-    HomepageModule,
+    Action, HomeLeftNavItem, RuntimeFilter, RuntimeFilterOp, HomepageModule,
 } from '../types';
 import {
     executeAfterWait,
@@ -34,6 +31,7 @@ import * as mixpanelInstance from '../mixpanel-service';
 import * as authInstance from '../auth';
 import * as baseInstance from './base';
 import { MIXPANEL_EVENT } from '../mixpanel-service';
+import * as authService from '../utils/authService/authService';
 
 const defaultViewConfig = {
     frameParams: {
@@ -89,8 +87,51 @@ describe('Unit test case for ts embed', () => {
 
     afterEach(() => {
         jest.clearAllMocks();
+        resetCachedAuthToken();
     });
 
+    describe('AuthExpire embedEvent in cookieless authentication authType', () => {
+        beforeAll(() => {
+            jest.spyOn(authInstance, 'doCookielessTokenAuth').mockResolvedValueOnce(true);
+            jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(true);
+            init({
+                thoughtSpotHost: 'tshost',
+                customizations: customisations,
+                customCssUrl: 'http://localhost:5000',
+                authType: AuthType.TrustedAuthTokenCookieless,
+                getAuthToken: () => Promise.resolve('test_auth_token2'),
+            });
+        });
+
+        test('check for new authToken based on getAuthToken function', async () => {
+            const mockEmbedEventPayload = {
+                type: EmbedEvent.AuthExpire,
+                data: {},
+            };
+            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+            jest.spyOn(baseInstance, 'notifyAuthFailure');
+            jest.spyOn(baseInstance, 'handleAuth');
+
+            searchEmbed.render();
+            const mockPort: any = {
+                postMessage: jest.fn(),
+            };
+            await executeAfterWait(() => {
+                const iframe = getIFrameEl();
+                postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
+            });
+            await executeAfterWait(() => {
+                expect(baseInstance.notifyAuthFailure).toBeCalledWith(
+                    authInstance.AuthFailureType.EXPIRY,
+                );
+                expect(baseInstance.handleAuth).not.toHaveBeenCalled();
+                expect(mockPort.postMessage).toHaveBeenCalledWith({
+                    type: EmbedEvent.AuthExpire,
+                    data: { authToken: 'test_auth_token2' },
+                });
+            });
+        });
+    });
     describe('Called Embed event status for start and end', () => {
         beforeAll(() => {
             init({
@@ -193,8 +234,7 @@ describe('Unit test case for ts embed', () => {
                     hostConfig: undefined,
                     runtimeFilterParams: null,
                     hiddenHomeLeftNavItems: [],
-                    hiddenHomepageModules: [HomepageModule.MyLibrary,
-                        HomepageModule.Learning],
+                    hiddenHomepageModules: [HomepageModule.MyLibrary, HomepageModule.Learning],
                     reorderedHomepageModules: [],
                 },
             });
@@ -231,8 +271,7 @@ describe('Unit test case for ts embed', () => {
                     runtimeFilterParams: null,
                     hiddenHomeLeftNavItems: [],
                     hiddenHomepageModules: [],
-                    reorderedHomepageModules: [HomepageModule.MyLibrary,
-                        HomepageModule.Watchlist],
+                    reorderedHomepageModules: [HomepageModule.MyLibrary, HomepageModule.Watchlist],
                 },
             });
         });
@@ -346,8 +385,7 @@ describe('Unit test case for ts embed', () => {
                     authToken: '',
                     hostConfig: undefined,
                     runtimeFilterParams: null,
-                    hiddenHomeLeftNavItems: [HomeLeftNavItem.Home,
-                        HomeLeftNavItem.Documentation],
+                    hiddenHomeLeftNavItems: [HomeLeftNavItem.Home, HomeLeftNavItem.Documentation],
                     hiddenHomepageModules: [],
                     reorderedHomepageModules: [],
                 },
@@ -483,7 +521,15 @@ describe('Unit test case for ts embed', () => {
             });
         });
 
+        afterEach(() => {
+            baseInstance.reset();
+        });
+
         test('check for authToken based on getAuthToken function', async () => {
+            const a = jest.spyOn(authService, 'verifyTokenService');
+            a.mockResolvedValue(true);
+
+            // authVerifyMock.mockResolvedValue(true);
             const mockEmbedEventPayload = {
                 type: EmbedEvent.APP_INIT,
                 data: {},
@@ -511,47 +557,8 @@ describe('Unit test case for ts embed', () => {
                     },
                 });
             });
-        });
-    });
 
-    describe('AuthExpire embedEvent in cookieless authentication authType', () => {
-        beforeAll(() => {
-            jest.spyOn(authInstance, 'doCookielessTokenAuth').mockResolvedValueOnce(true);
-            init({
-                thoughtSpotHost: 'tshost',
-                customizations: customisations,
-                customCssUrl: 'http://localhost:5000',
-                authType: AuthType.TrustedAuthTokenCookieless,
-                getAuthToken: () => Promise.resolve('test_auth_token2'),
-            });
-        });
-
-        test('check for new authToken based on getAuthToken function', async () => {
-            const mockEmbedEventPayload = {
-                type: EmbedEvent.AuthExpire,
-                data: {},
-            };
-            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
-            jest.spyOn(baseInstance, 'notifyAuthFailure');
-            jest.spyOn(baseInstance, 'handleAuth');
-            searchEmbed.render();
-            const mockPort: any = {
-                postMessage: jest.fn(),
-            };
-            await executeAfterWait(() => {
-                const iframe = getIFrameEl();
-                postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
-            });
-            await executeAfterWait(() => {
-                expect(baseInstance.notifyAuthFailure).toBeCalledWith(
-                    authInstance.AuthFailureType.EXPIRY,
-                );
-                expect(baseInstance.handleAuth).not.toHaveBeenCalled();
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: EmbedEvent.AuthExpire,
-                    data: { authToken: 'test_auth_token2' },
-                });
-            });
+            jest.spyOn(authService, 'verifyTokenService').mockClear();
         });
     });
 
@@ -1036,7 +1043,7 @@ describe('Unit test case for ts embed', () => {
             expectUrlMatchesWithParams(
                 getIFrameSrc(),
                 `http://${thoughtSpotHost}/?embedApp=true&primaryNavHidden=true&profileAndHelpInNavBarHidden=false&${defaultParamsForPinboardEmbed}`
-                + `&foo=bar&baz=1&bool=true${defaultParamsPost}#/home`,
+                    + `&foo=bar&baz=1&bool=true${defaultParamsPost}#/home`,
             );
         });
 
@@ -1052,7 +1059,7 @@ describe('Unit test case for ts embed', () => {
             expectUrlMatchesWithParams(
                 getIFrameSrc(),
                 `http://${thoughtSpotHost}/?embedApp=true&primaryNavHidden=true&profileAndHelpInNavBarHidden=false&${defaultParamsForPinboardEmbed}`
-                + `&showAlerts=true${defaultParamsPost}#/home`,
+                    + `&showAlerts=true${defaultParamsPost}#/home`,
             );
         });
         it('Sets the locale param', async () => {
@@ -1067,7 +1074,7 @@ describe('Unit test case for ts embed', () => {
             expectUrlMatchesWithParams(
                 getIFrameSrc(),
                 `http://${thoughtSpotHost}/?embedApp=true&primaryNavHidden=true&profileAndHelpInNavBarHidden=false&${defaultParamsForPinboardEmbed}`
-                + `&locale=ja-JP${defaultParamsPost}#/home`,
+                    + `&locale=ja-JP${defaultParamsPost}#/home`,
             );
         });
         it('Sets the iconSprite url', async () => {
@@ -1084,7 +1091,7 @@ describe('Unit test case for ts embed', () => {
             expectUrlMatchesWithParams(
                 getIFrameSrc(),
                 `http://${thoughtSpotHost}/?embedApp=true&primaryNavHidden=true&profileAndHelpInNavBarHidden=false&${defaultParamsForPinboardEmbed}`
-                + `&iconSprite=iconSprite.com${defaultParamsPost}#/home`,
+                    + `&iconSprite=iconSprite.com${defaultParamsPost}#/home`,
             );
         });
 
@@ -1302,8 +1309,7 @@ describe('Unit test case for ts embed', () => {
             expect(preRenderWrapper.style.pointerEvents).toBe('none');
             expect(preRenderWrapper.style.zIndex).toBe('-1000');
 
-            const preRenderChild = (document
-                .getElementById(preRenderIds.child) as HTMLIFrameElement);
+            const preRenderChild = document.getElementById(preRenderIds.child) as HTMLIFrameElement;
             expect(preRenderWrapper.children[0]).toEqual(preRenderChild);
             expect(preRenderChild).toBeInstanceOf(HTMLIFrameElement);
             expect(preRenderChild.src).toMatch(/^http:\/\/tshost.*\/myLiveboardId/);
@@ -1314,24 +1320,26 @@ describe('Unit test case for ts embed', () => {
 
             let resizeObserverCb: any;
             (window as any).ResizeObserver = window.ResizeObserver
-            || jest.fn().mockImplementation((resizeObserverCbParam) => {
-                resizeObserverCb = resizeObserverCbParam;
-                return ({
-                    disconnect: jest.fn(),
-                    observe: jest.fn(),
-                    unobserve: jest.fn(),
+                || jest.fn().mockImplementation((resizeObserverCbParam) => {
+                    resizeObserverCb = resizeObserverCbParam;
+                    return {
+                        disconnect: jest.fn(),
+                        observe: jest.fn(),
+                        unobserve: jest.fn(),
+                    };
                 });
-            });
 
             // show preRender
             const warnSpy = spyOn(console, 'warn');
             libEmbed.showPreRender();
             expect(warnSpy).toHaveBeenCalledTimes(0);
 
-            resizeObserverCb([{
-                target: tsEmbedDiv,
-                contentRect: { height: 297, width: 987 },
-            }]);
+            resizeObserverCb([
+                {
+                    target: tsEmbedDiv,
+                    contentRect: { height: 297, width: 987 },
+                },
+            ]);
 
             expect(preRenderWrapper.style.height).toEqual(`${297}px`);
             expect(preRenderWrapper.style.width).toEqual(`${987}px`);
@@ -1394,11 +1402,11 @@ describe('Unit test case for ts embed', () => {
             createRootEleForEmbed();
             mockMessageChannel();
             (window as any).ResizeObserver = window.ResizeObserver
-            || jest.fn().mockImplementation(() => ({
-                disconnect: jest.fn(),
-                observe: jest.fn(),
-                unobserve: jest.fn(),
-            }));
+                || jest.fn().mockImplementation(() => ({
+                    disconnect: jest.fn(),
+                    observe: jest.fn(),
+                    unobserve: jest.fn(),
+                }));
             const libEmbed = new LiveboardEmbed('#tsEmbedDiv', {
                 preRenderId: 'i-am-preRendered',
                 liveboardId: 'myLiveboardId',
@@ -1451,7 +1459,9 @@ describe('Unit test case for ts embed', () => {
             });
             await libEmbed.preRender();
 
-            expect(document.getElementById('tsEmbed-pre-render-child-test').innerHTML).toBe('Not logged in');
+            expect(document.getElementById('tsEmbed-pre-render-child-test').innerHTML).toBe(
+                'Not logged in',
+            );
         });
         it('should log error if sync is called before preRender', async () => {
             jest.spyOn(console, 'error').mockImplementation(jest.fn());
@@ -1460,7 +1470,9 @@ describe('Unit test case for ts embed', () => {
                 preRenderId: 'test',
             });
             await libEmbed.syncPreRenderStyle();
-            expect(console.error).toBeCalledWith('PreRender should be called before using syncPreRenderStyle');
+            expect(console.error).toBeCalledWith(
+                'PreRender should be called before using syncPreRenderStyle',
+            );
             (console.error as any).mockClear();
         });
     });

package/src/embed/ts-embed.ts

@@ -9,6 +9,7 @@
 
 import isEqual from 'lodash/isEqual';
 
+import { getAuthenticationToken } from '../authToken';
 import { AnswerService } from '../utils/graphql/answerService/answerService';
 import {
     getEncodedQueryParamsString,
@@ -55,13 +56,10 @@ import { processEventData } from '../utils/processData';
 import { processTrigger } from '../utils/processTrigger';
 import pkgInfo from '../../package.json';
 import {
-    getAuthPromise,
-    getEmbedConfig,
-    renderInQueue,
-    handleAuth,
-    notifyAuthFailure,
+    getAuthPromise, renderInQueue, handleAuth, notifyAuthFailure,
 } from './base';
-import { AuthFailureType, getAuthenticationToken } from '../auth';
+import { AuthFailureType } from '../auth';
+import { getEmbedConfig } from './embedConfig';
 
 const { version } = pkgInfo;
 
@@ -1073,11 +1071,11 @@ export class TsEmbed {
                 ) {
                     console.warn(
                         `${this.embedComponentType} was pre-rendered with `
-                        + `"${key}" as "${JSON.stringify(preRenderedObject.viewConfig[key])}" `
-                        + `but a different value "${JSON.stringify(viewConfig[key])}" `
-                        + 'was passed to the Embed component. '
-                        + 'The new value provided is ignored, the value provided during '
-                        + 'preRender is used.',
+                            + `"${key}" as "${JSON.stringify(preRenderedObject.viewConfig[key])}" `
+                            + `but a different value "${JSON.stringify(viewConfig[key])}" `
+                            + 'was passed to the Embed component. '
+                            + 'The new value provided is ignored, the value provided during '
+                            + 'preRender is used.',
                     );
                 }
             });
@@ -1204,15 +1202,8 @@ export class TsEmbed {
      * @version SDK: 1.25.0 / ThoughtSpot 9.10.0
      */
     public async getAnswerService(vizId?: string): Promise<AnswerService> {
-        const { session, embedAnswerData } = await this.trigger(
-            HostEvent.GetAnswerSession,
-            vizId,
-        );
-        return new AnswerService(
-            session,
-            embedAnswerData,
-            this.embedConfig.thoughtSpotHost,
-        );
+        const { session, embedAnswerData } = await this.trigger(HostEvent.GetAnswerSession, vizId);
+        return new AnswerService(session, embedAnswerData, this.embedConfig.thoughtSpotHost);
     }
 }
 

package/src/index.ts

@@ -9,8 +9,13 @@
  */
 import { AppEmbed, Page, AppViewConfig } from './embed/app';
 import {
-    init, prefetch, logout, getEmbedConfig, executeTML, exportTML,
-    executeTMLInput, exportTMLInput,
+    init,
+    prefetch,
+    logout,
+    executeTML,
+    exportTML,
+    executeTMLInput,
+    exportTMLInput,
 } from './embed/base';
 import { PinboardEmbed, LiveboardViewConfig, LiveboardEmbed } from './embed/liveboard';
 import { SearchEmbed, SearchViewConfig } from './embed/search';
@@ -44,6 +49,7 @@ import {
 import { CustomCssVariables } from './css-variables';
 import { SageEmbed, SageViewConfig } from './embed/sage';
 import { AnswerService } from './utils/graphql/answerService/answerService';
+import { getEmbedConfig } from './embed/embedConfig';
 
 export {
     init,

package/src/tokenizedFetch.ts

@@ -0,0 +1,18 @@
+import { getAuthenticationToken } from './authToken';
+import { getEmbedConfig } from './embed/embedConfig';
+
+import { AuthType } from './types';
+
+export const tokenizedFetch: typeof fetch = async (input, init): Promise<Response> => {
+    const embedConfig = getEmbedConfig();
+    if (embedConfig.authType !== AuthType.TrustedAuthTokenCookieless) {
+        return fetch(input, init);
+    }
+
+    const req = new Request(input, init);
+    const authToken = await getAuthenticationToken(embedConfig);
+    if (authToken) {
+        req.headers.append('Authorization', `Bearer ${authToken}`);
+    }
+    return fetch(req);
+};

package/src/types.ts

@@ -531,10 +531,17 @@ export interface EmbedConfig {
      * @version SDK: 1.27.0 | ThoughtSpot: 9.8.0.cl
      */
     pendoTrackingKey?: string;
+
+    /**
+     * If passed as true all alerts will be suppressed in the embedded app.
+     *
+     * @version SDK: 1.26.2 | ThoughtSpot: *
+     */
+    suppressErrorAlerts?: boolean;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface LayoutConfig { }
+export interface LayoutConfig {}
 
 /**
  * Embedded iFrame configuration
@@ -3212,40 +3219,44 @@ export enum ContextMenuTriggerOptions {
 
 export interface ColumnValue {
     column: {
-        id: string,
-        name: string,
-        dataType: string,
-        [key: string]: any
-    },
-    value: string | number | boolean | {
-        v: {
-            s: number;
-            e: number;
-        }
+        id: string;
+        name: string;
+        dataType: string;
+        [key: string]: any;
     };
+    value:
+        | string
+        | number
+        | boolean
+        | {
+              v: {
+                  s: number;
+                  e: number;
+              };
+          };
 }
 
 export interface VizPoint {
-    selectedAttributes: ColumnValue[],
-    selectedMeasures: ColumnValue[]
+    selectedAttributes: ColumnValue[];
+    selectedMeasures: ColumnValue[];
 }
 
 export interface CustomActionPayload {
     contextMenuPoints?: {
-        clickedPoint: VizPoint
-        selectedPoints: VizPoint[]
+        clickedPoint: VizPoint;
+        selectedPoints: VizPoint[];
     };
     embedAnswerData: {
-        name: string,
-        id: string,
+        name: string;
+        id: string;
         sources: {
             header: {
-                guid: string
-            }
-        },
-        columns: any[],
-        data: any[],
-        [key: string]: any
+                guid: string;
+            };
+        };
+        columns: any[];
+        data: any[];
+        [key: string]: any;
     };
     session: SessionInterface;
     vizId?: string;

package/src/utils/{authService.spec.ts → authService/authService.spec.ts}

@@ -1,4 +1,3 @@
-import { embedConfig } from 'src/auth.spec';
 import {
     fetchSessionInfoService,
     fetchAuthTokenService,
@@ -6,8 +5,8 @@ import {
     fetchBasicAuthService,
     fetchAuthPostService,
     verifyTokenService,
-} from './authService';
-import { EndPoints } from '../auth';
+    EndPoints,
+} from '.';
 
 const thoughtSpotHost = 'http://10.79.135.124:3000';
 

package/src/utils/{authService.ts → authService/authService.ts}

@@ -1,5 +1,14 @@
-// eslint-disable-next-line import/no-cycle
-import { EndPoints } from '../auth';
+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',
+};
 
 /**
  *
@@ -15,31 +24,31 @@ function failureLoggedFetch(url: string, options: RequestInit = {}): Promise<Res
     });
 }
 
-/**
- *
- * @param authVerificationUrl
- */
-export function fetchSessionInfoService(authVerificationUrl: string): Promise<any> {
-    return failureLoggedFetch(authVerificationUrl, {
-        credentials: 'include',
-    });
-}
-
 /**
  * Service to validate a auth token against a ThoughtSpot host.
  *
  * @param thoughtSpotHost : ThoughtSpot host to verify the token against.
  * @param authToken : Auth token to verify.
  */
-export function verifyTokenService(thoughtSpotHost: string, authToken: string): Promise<Response> {
+export async function verifyTokenService(
+    thoughtSpotHost: string,
+    authToken: string,
+): Promise<boolean> {
     const authVerificationUrl = `${thoughtSpotHost}${EndPoints.IS_ACTIVE}`;
-    return fetch(authVerificationUrl, {
-        headers: {
-            Authorization: `Bearer ${authToken}`,
-            'x-requested-by': 'ThoughtSpot',
-        },
-        credentials: 'omit',
-    });
+    try {
+        const res = await fetch(authVerificationUrl, {
+            headers: {
+                Authorization: `Bearer ${authToken}`,
+                'x-requested-by': 'ThoughtSpot',
+            },
+            credentials: 'omit',
+        });
+        return res.ok;
+    } catch (e) {
+        console.error(`Token Verification Service failed : ${e.message}`);
+    }
+
+    return false;
 }
 
 /**
@@ -120,17 +129,3 @@ export async function fetchBasicAuthService(
         credentials: 'include',
     });
 }
-
-/**
- *
- * @param thoughtSpotHost
- */
-export async function fetchLogoutService(thoughtSpotHost: string): Promise<any> {
-    return failureLoggedFetch(`${thoughtSpotHost}${EndPoints.LOGOUT}`, {
-        credentials: 'include',
-        method: 'POST',
-        headers: {
-            'x-requested-by': 'ThoughtSpot',
-        },
-    });
-}

package/src/utils/authService/index.ts

@@ -0,0 +1,9 @@
+export {
+    EndPoints,
+    fetchAuthPostService,
+    fetchAuthService,
+    fetchAuthTokenService,
+    fetchBasicAuthService,
+    verifyTokenService,
+} from './authService';
+export { fetchLogoutService, fetchSessionInfoService } from './tokenizedAuthService';

package/src/utils/authService/tokenizedAuthService.ts

@@ -0,0 +1,40 @@
+import { tokenizedFetch } from '../../tokenizedFetch';
+import { EndPoints } from './authService';
+
+/**
+ *
+ * @param url
+ * @param options
+ */
+function tokenisedFailureLoggedFetch(url: string, options: RequestInit = {}): Promise<Response> {
+    return tokenizedFetch(url, options).then(async (r) => {
+        if (!r.ok && r.type !== 'opaqueredirect' && r.type !== 'opaque') {
+            console.error('Failure', await r.text?.());
+        }
+        return r;
+    });
+}
+
+/**
+ *
+ * @param authVerificationUrl
+ */
+export function fetchSessionInfoService(authVerificationUrl: string): Promise<any> {
+    return tokenisedFailureLoggedFetch(authVerificationUrl, {
+        credentials: 'include',
+    });
+}
+
+/**
+ *
+ * @param thoughtSpotHost
+ */
+export async function fetchLogoutService(thoughtSpotHost: string): Promise<any> {
+    return tokenisedFailureLoggedFetch(`${thoughtSpotHost}${EndPoints.LOGOUT}`, {
+        credentials: 'include',
+        method: 'POST',
+        headers: {
+            'x-requested-by': 'ThoughtSpot',
+        },
+    });
+}

package/src/utils/graphql/answerService/answerService.spec.ts

@@ -1,7 +1,10 @@
 import 'jest-fetch-mock';
-import { VizPoint } from 'src/types';
+import { AuthType, VizPoint } from '../../../types';
 import { AnswerService } from './answerService';
 import { getAnswerData, removeColumns } from './answer-queries';
+import * as authTokenInstance from '../../../authToken';
+import * as tokenizedFetch from '../../../tokenizedFetch';
+import * as embedConfigInstance from '../../../embed/embedConfig';
 
 const defaultSession = {
     sessionId: 'id',
@@ -111,20 +114,29 @@ describe('Answer service tests', () => {
     test('fetchCSVBlob should call the right API', () => {
         fetchMock.once('Bla');
         const answerService = createAnswerService();
+
+        const mockEmbedConfig = {
+            thougthspotHost: '/test',
+            authType: AuthType.TrustedAuthTokenCookieless,
+        };
+        jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValueOnce(mockEmbedConfig);
+        jest.spyOn(authTokenInstance, 'getAuthenticationToken').mockReturnValueOnce(Promise.resolve('token'));
+        const mockTokenizedFetch = jest.spyOn(tokenizedFetch, 'tokenizedFetch');
         answerService.fetchCSVBlob(undefined, true);
-        expect(fetchMock).toHaveBeenCalledWith(
+
+        expect(mockTokenizedFetch).toHaveBeenCalledWith(
             `https://tshost/prism/download/answer/csv?sessionId=${defaultSession.sessionId}&genNo=${defaultSession.genNo}&userLocale=en-us&exportFileName=data&hideCsvHeader=false`,
             expect.objectContaining({}),
         );
 
         answerService.fetchCSVBlob('en-uk', true);
-        expect(fetchMock).toHaveBeenCalledWith(
+        expect(mockTokenizedFetch).toHaveBeenCalledWith(
             `https://tshost/prism/download/answer/csv?sessionId=${defaultSession.sessionId}&genNo=${defaultSession.genNo}&userLocale=en-uk&exportFileName=data&hideCsvHeader=false`,
             expect.objectContaining({}),
         );
 
         answerService.fetchCSVBlob(undefined, false);
-        expect(fetchMock).toHaveBeenCalledWith(
+        expect(mockTokenizedFetch).toHaveBeenCalledWith(
             `https://tshost/prism/download/answer/csv?sessionId=${defaultSession.sessionId}&genNo=${defaultSession.genNo}&userLocale=en-us&exportFileName=data&hideCsvHeader=true`,
             expect.objectContaining({}),
         );