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

package/lib/src/utils/sessionInfoService.js

@@ -0,0 +1,85 @@
+import { getEmbedConfig } from '../embed/embedConfig';
+import { fetchSessionInfoService } from './authService';
+let sessionInfo = null;
+/**
+ * Returns the session info object and caches it for future use.
+ * Once fetched the session info object is cached and returned from the cache on
+ * subsequent calls.
+ *
+ * @example ```js
+ * const sessionInfo = await getSessionInfo();
+ * console.log(sessionInfo);
+ * ```
+ * @version SDK: 1.28.3 | ThoughtSpot: *
+ * @returns {Promise<SessionInfo>} The session info object.
+ */
+export async function getSessionInfo() {
+    if (!sessionInfo) {
+        const host = getEmbedConfig().thoughtSpotHost;
+        const sessionResponse = await fetchSessionInfoService(host);
+        const processedSessionInfo = getSessionDetails(sessionResponse);
+        sessionInfo = processedSessionInfo;
+    }
+    return sessionInfo;
+}
+/**
+ * Returns the cached session info object. If the client is not authenticated the
+ * function will return null.
+ *
+ * @example ```js
+ * const sessionInfo = getCachedSessionInfo();
+ * if (sessionInfo) {
+ *   console.log(sessionInfo);
+ * } else {
+ *   console.log('Not authenticated');
+ * }
+ * ```
+ * @returns {SessionInfo | null} The session info object.
+ * @version SDK: 1.28.3 | ThoughtSpot: *
+ */
+export function getCachedSessionInfo() {
+    return sessionInfo;
+}
+/**
+ * Processes the session info response and returns the session info object.
+ *
+ *  @param sessionInfoResp {any} Response from the session info API.
+ *  @returns {SessionInfo} The session info object.
+ *  @example ```js
+ *  const sessionInfoResp = await fetch(sessionInfoPath);
+ *  const sessionInfo = getSessionDetails(sessionInfoResp);
+ *  console.log(sessionInfo);
+ *  ```
+ * @version SDK: 1.28.3 | ThoughtSpot: *
+ */
+export const getSessionDetails = (sessionInfoResp) => {
+    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,
+    };
+};
+/**
+ * Resets the cached session info object and forces a new fetch on the next call.
+ *
+ * @example ```js
+ * resetCachedSessionInfo();
+ * const sessionInfo = await getSessionInfo();
+ * console.log(sessionInfo);
+ * ```
+ * @version SDK: 1.28.3 | ThoughtSpot ts7.april.cl, 7.2.1
+ * @returns {void}
+ */
+export function resetCachedSessionInfo() {
+    sessionInfo = null;
+}
+//# sourceMappingURL=sessionInfoService.js.map

package/lib/src/utils/sessionInfoService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionInfoService.js","sourceRoot":"","sources":["../../../src/utils/sessionInfoService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAcxD,IAAI,WAAW,GAAuB,IAAI,CAAC;AAE3C;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc;IAChC,IAAI,CAAC,WAAW,EAAE;QACd,MAAM,IAAI,GAAG,cAAc,EAAE,CAAC,eAAe,CAAC;QAC9C,MAAM,eAAe,GAAG,MAAM,uBAAuB,CAAC,IAAI,CAAC,CAAC;QAC5D,MAAM,oBAAoB,GAAG,iBAAiB,CAAC,eAAe,CAAC,CAAC;QAChE,WAAW,GAAG,oBAAoB,CAAC;KACtC;IACD,OAAO,WAAW,CAAC;AACvB,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,oBAAoB;IAChC,OAAO,WAAW,CAAC;AACvB,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,eAAoB,EAAe,EAAE;IACnE,MAAM,gBAAgB,GAAG,eAAe,CAAC,UAAU,CAAC,cAAc,CAAC,SAAS,CAAC;IAC7E,MAAM,iBAAiB,GAAG,eAAe,CAAC,UAAU,CAAC,cAAc,CAAC,UAAU,CAAC;IAC/E,MAAM,aAAa,GAAG,eAAe,CAAC,UAAU,CAAC,cAAc,CAAC,UAAU;QACtE,CAAC,CAAC,iBAAiB;QACnB,CAAC,CAAC,gBAAgB,CAAC;IACvB,OAAO;QACH,QAAQ,EAAE,eAAe,CAAC,QAAQ;QAClC,aAAa;QACb,YAAY,EAAE,eAAe,CAAC,UAAU,CAAC,YAAY;QACrD,cAAc,EAAE,eAAe,CAAC,cAAc;QAC9C,SAAS,EAAE,eAAe,CAAC,UAAU,CAAC,aAAa;QACnD,WAAW,EAAE,eAAe,CAAC,UAAU,CAAC,eAAe;QACvD,GAAG,eAAe;KACrB,CAAC;AACN,CAAC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,UAAU,sBAAsB;IAClC,WAAW,GAAG,IAAI,CAAC;AACvB,CAAC"}

package/lib/src/visual-embed-sdk.d.ts

@@ -17,7 +17,8 @@ declare module '@thoughtspot/visual-embed-sdk' {
     import { PinboardEmbed, LiveboardViewConfig, LiveboardEmbed } from '@thoughtspot/visual-embed-sdk/embed/liveboard';
     import { SearchEmbed, SearchViewConfig } from '@thoughtspot/visual-embed-sdk/embed/search';
     import { SearchBarEmbed, SearchBarViewConfig } from '@thoughtspot/visual-embed-sdk/embed/search-bar';
-    import { AuthFailureType, AuthStatus, AuthEvent, AuthEventEmitter, getSessionInfo } from '@thoughtspot/visual-embed-sdk/auth';
+    import { AuthFailureType, AuthStatus, AuthEvent, AuthEventEmitter } from '@thoughtspot/visual-embed-sdk/auth';
+    import { getSessionInfo } from '@thoughtspot/visual-embed-sdk/utils/sessionInfoService';
     import { AuthType, RuntimeFilter, RuntimeFilterOp, EmbedEvent, HostEvent, DataSourceVisualMode, Action, EmbedConfig, PrefetchFeatures, FrameParams, DOMSelector, HomeLeftNavItem, HomepageModule, MessageOptions, MessageCallback, MessagePayload, CustomisationsInterface, CustomStyles, customCssInterface, ContextMenuTriggerOptions, RuntimeParameter, LogLevel, VizPoint, CustomActionPayload } from '@thoughtspot/visual-embed-sdk/types';
     import { CustomCssVariables } from '@thoughtspot/visual-embed-sdk/css-variables';
     import { SageEmbed, SageViewConfig } from '@thoughtspot/visual-embed-sdk/embed/sage';
@@ -1383,12 +1384,6 @@ declare module '@thoughtspot/visual-embed-sdk/auth' {
     export let samlAuthWindow: Window;
     export let samlCompletionPromise: Promise<void>;
     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}.
@@ -1506,7 +1501,7 @@ declare module '@thoughtspot/visual-embed-sdk/auth' {
     /**
         *
         */
-    export function notifyAuthSuccess(): void;
+    export function notifyAuthSuccess(): Promise<void>;
     /**
         *
         * @param failureType
@@ -1516,19 +1511,23 @@ declare module '@thoughtspot/visual-embed-sdk/auth' {
         *
         */
     export function notifyLogout(): void;
-    export const initSession: (sessionDetails: sessionInfoInterface) => void;
-    export const getSessionDetails: (sessionInfoResp: any) => sessionInfoInterface;
     /**
-        * 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(): string;
+    export function postLoginService(): Promise<void>;
     /**
-        * 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>;
+    export function getReleaseVersion(): string;
     /**
         * Perform token based authentication
         *
@@ -1564,7 +1563,74 @@ declare module '@thoughtspot/visual-embed-sdk/auth' {
         * Check if we are authenticated to the ThoughtSpot cluster
         */
     export const isAuthenticated: () => boolean;
-    export {};
+}
+
+declare module '@thoughtspot/visual-embed-sdk/utils/sessionInfoService' {
+    export type SessionInfo = {
+            releaseVersion: string;
+            userGUID: string;
+            currentOrgId: number;
+            privileges: string[];
+            mixpanelToken: string;
+            isPublicUser: boolean;
+            clusterId: string;
+            clusterName: string;
+            [key: string]: any;
+    };
+    /**
+        * Returns the session info object and caches it for future use.
+        * Once fetched the session info object is cached and returned from the cache on
+        * subsequent calls.
+        *
+        * @example ```js
+        * const sessionInfo = await getSessionInfo();
+        * console.log(sessionInfo);
+        * ```
+        * @version SDK: 1.28.3 | ThoughtSpot: *
+        * @returns {Promise<SessionInfo>} The session info object.
+        */
+    export function getSessionInfo(): Promise<SessionInfo>;
+    /**
+        * Returns the cached session info object. If the client is not authenticated the
+        * function will return null.
+        *
+        * @example ```js
+        * const sessionInfo = getCachedSessionInfo();
+        * if (sessionInfo) {
+        *   console.log(sessionInfo);
+        * } else {
+        *   console.log('Not authenticated');
+        * }
+        * ```
+        * @returns {SessionInfo | null} The session info object.
+        * @version SDK: 1.28.3 | ThoughtSpot: *
+        */
+    export function getCachedSessionInfo(): SessionInfo | null;
+    /**
+        * Processes the session info response and returns the session info object.
+        *
+        *  @param sessionInfoResp {any} Response from the session info API.
+        *  @returns {SessionInfo} The session info object.
+        *  @example ```js
+        *  const sessionInfoResp = await fetch(sessionInfoPath);
+        *  const sessionInfo = getSessionDetails(sessionInfoResp);
+        *  console.log(sessionInfo);
+        *  ```
+        * @version SDK: 1.28.3 | ThoughtSpot: *
+        */
+    export const getSessionDetails: (sessionInfoResp: any) => SessionInfo;
+    /**
+        * Resets the cached session info object and forces a new fetch on the next call.
+        *
+        * @example ```js
+        * resetCachedSessionInfo();
+        * const sessionInfo = await getSessionInfo();
+        * console.log(sessionInfo);
+        * ```
+        * @version SDK: 1.28.3 | ThoughtSpot ts7.april.cl, 7.2.1
+        * @returns {void}
+        */
+    export function resetCachedSessionInfo(): void;
 }
 
 declare module '@thoughtspot/visual-embed-sdk/types' {
@@ -4003,7 +4069,7 @@ declare module '@thoughtspot/visual-embed-sdk/types' {
                 *
                 * @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
@@ -6362,6 +6428,16 @@ declare module '@thoughtspot/visual-embed-sdk/utils/graphql/answerService/answer
         *     const data = await underlying.fetchData(0, 100);
         *  })
         * ```
+        * @example
+        * ```js
+        * embed.on(EmbedEvent.Data, async (e) => {
+        *     const service = await embed.getAnswerService();
+        *     await service.addColumns([
+        *         "<column guid>"
+        *     ]);
+        *     console.log(await service.fetchData());
+        * });
+        * ```
         * @version SDK: 1.25.0| ThoughtSpot: 9.10.0.cl
         * @group Events
         */
@@ -6481,6 +6557,7 @@ declare module '@thoughtspot/visual-embed-sdk/embed/embedConfig' {
 }
 
 declare module '@thoughtspot/visual-embed-sdk/mixpanel-service' {
+    import { SessionInfo } from '@thoughtspot/visual-embed-sdk/utils/sessionInfoService';
     export const EndPoints: {
             CONFIG: string;
     };
@@ -6506,7 +6583,7 @@ declare module '@thoughtspot/visual-embed-sdk/mixpanel-service' {
         *
         * @param sessionInfo
         */
-    export function initMixpanel(sessionInfo: any): void;
+    export function initMixpanel(sessionInfo: SessionInfo): void;
     /**
         *
         */
@@ -6528,7 +6605,7 @@ declare module '@thoughtspot/visual-embed-sdk/tokenizedFetch' {
 
 declare module '@thoughtspot/visual-embed-sdk/authToken' {
     import { EmbedConfig } from '@thoughtspot/visual-embed-sdk/types';
-    export const getAuthenticationToken: (embedConfig: EmbedConfig) => Promise<string>;
+    export function getAuthenticationToken(embedConfig: EmbedConfig): Promise<string>;
     /**
       * Resets the auth token and a new token will be fetched on the next request.
       *

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@thoughtspot/visual-embed-sdk",
-    "version": "1.29.0-alpha.8",
+    "version": "1.29.0-alpha.SCAL-205893-1",
     "description": "ThoughtSpot Embed SDK",
     "module": "lib/src/index.js",
     "main": "dist/tsembed.js",

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);
+    });
 });