@thoughtspot/visual-embed-sdk 1.44.1 → 1.44.2

package/src/utils/graphql/graphql-request.spec.ts

@@ -20,7 +20,7 @@ describe('graphQl tests', () => {
             json: jest.fn().mockResolvedValue({
                 data: {},
             }),
-        });
+        } as any);
 
         const details = await graphqlQuery({
             query: getSourceDetailQuery,
@@ -30,7 +30,7 @@ describe('graphQl tests', () => {
             thoughtSpotHost,
         });
 
-        expect(tokenizedFetchUtil.tokenizedFetch).toBeCalledWith('TSHOST/prism/?op=GetSourceDetail', {
+        expect(tokenizedFetchUtil.tokenizedFetch).toHaveBeenCalledWith('TSHOST/prism/?op=GetSourceDetail', {
             body: '{"operationName":"GetSourceDetail","query":"\\n    query GetSourceDetail($ids: [GUID!]!) {\\n        getSourceDetailById(ids: $ids, type: LOGICAL_TABLE) {\\n            id\\n            name\\n        }\\n    }  \\n","variables":{"ids":[2]}}',
             credentials: 'include',
             headers: {

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

@@ -14,6 +14,6 @@ describe('Source service tests', () => {
         }));
         await getSourceDetail('https://tshost', 'id');
         await getSourceDetail('https://tshost', 'id');
-        expect(fetchMock).toBeCalledTimes(1);
+        expect(fetchMock).toHaveBeenCalledTimes(1);
     });
 });

package/src/utils/processData.spec.ts

@@ -10,7 +10,7 @@ import { logger } from './logger';
 
 describe('Unit test for process data', () => {
     beforeAll(() => {
-        jest.spyOn(auth, 'postLoginService').mockImplementation(() => Promise.resolve({}));
+        jest.spyOn(auth, 'postLoginService').mockImplementation(() => Promise.resolve(undefined));
         base.init({
             thoughtSpotHost: 'https://tshost',
             authType: AuthType.None,
@@ -84,7 +84,7 @@ describe('Unit test for process data', () => {
         const processedData = { type: EmbedEvent.Data };
         jest.spyOn(processDataInstance, 'processCustomAction').mockImplementation(async () => ({}));
         processDataInstance.processEventData(EmbedEvent.Data, processedData, thoughtSpotHost, null);
-        expect(processDataInstance.processCustomAction).not.toBeCalled();
+        expect(processDataInstance.processCustomAction).not.toHaveBeenCalled();
     });
 
     test('AuthInit', () => {
@@ -95,14 +95,14 @@ describe('Unit test for process data', () => {
         };
         const e = { type: EmbedEvent.AuthInit, data: sessionInfo };
         jest.spyOn(base, 'notifyAuthSuccess');
-        jest.spyOn(sessionInfoService, 'getSessionInfo').mockReturnValue(sessionInfo);
+        jest.spyOn(sessionInfoService, 'getSessionInfo').mockImplementation(() => Promise.resolve(sessionInfo as any));
         expect(processDataInstance.processEventData(e.type, e, '', null)).toEqual({
             type: e.type,
             data: {
                 userGUID: sessionInfo.userGUID,
             },
         });
-        expect(base.notifyAuthSuccess).toBeCalled();
+        expect(base.notifyAuthSuccess).toHaveBeenCalled();
     });
 
     test('NoCookieAccess no suppress alert', () => {
@@ -111,14 +111,14 @@ describe('Unit test for process data', () => {
         jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValue({
             loginFailedMessage: 'Hello',
             suppressNoCookieAccessAlert: false,
-        });
+        } as any);
         jest.spyOn(window, 'alert').mockImplementation(() => undefined);
         const el: any = {};
         expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual({
             type: e.type,
         });
-        expect(base.notifyAuthFailure).toBeCalledWith(auth.AuthFailureType.NO_COOKIE_ACCESS);
-        expect(window.alert).toBeCalled();
+        expect(base.notifyAuthFailure).toHaveBeenCalledWith(auth.AuthFailureType.NO_COOKIE_ACCESS);
+        expect(window.alert).toHaveBeenCalled();
         expect(el.innerHTML).toBe('Hello');
     });
 
@@ -128,15 +128,15 @@ describe('Unit test for process data', () => {
         jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValue({
             loginFailedMessage: 'Hello',
             suppressNoCookieAccessAlert: true,
-        });
+        } as any);
         jest.spyOn(window, 'alert').mockReset();
         jest.spyOn(window, 'alert').mockImplementation(() => undefined);
         const el: any = {};
         expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual({
             type: e.type,
         });
-        expect(base.notifyAuthFailure).toBeCalledWith(auth.AuthFailureType.NO_COOKIE_ACCESS);
-        expect(window.alert).not.toBeCalled();
+        expect(base.notifyAuthFailure).toHaveBeenCalledWith(auth.AuthFailureType.NO_COOKIE_ACCESS);
+        expect(window.alert).not.toHaveBeenCalled();
         expect(el.innerHTML).toBe('Hello');
     });
 
@@ -146,15 +146,15 @@ describe('Unit test for process data', () => {
         jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValue({
             loginFailedMessage: 'Hello',
             ignoreNoCookieAccess: true,
-        });
+        } as any);
         jest.spyOn(window, 'alert').mockReset();
         jest.spyOn(window, 'alert').mockImplementation(() => undefined);
         const el: any = {};
         expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual({
             type: e.type,
         });
-        expect(base.notifyAuthFailure).toBeCalledWith(auth.AuthFailureType.NO_COOKIE_ACCESS);
-        expect(window.alert).not.toBeCalled();
+        expect(base.notifyAuthFailure).toHaveBeenCalledWith(auth.AuthFailureType.NO_COOKIE_ACCESS);
+        expect(window.alert).not.toHaveBeenCalled();
         expect(el.innerHTML).not.toBe('Hello');
     });
 
@@ -163,12 +163,12 @@ describe('Unit test for process data', () => {
         jest.spyOn(base, 'notifyAuthFailure');
         jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValue({
             loginFailedMessage: 'Hello',
-        });
+        } as any);
         const el: any = {};
         expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual({
             type: e.type,
         });
-        expect(base.notifyAuthFailure).toBeCalledWith(auth.AuthFailureType.OTHER);
+        expect(base.notifyAuthFailure).toHaveBeenCalledWith(auth.AuthFailureType.OTHER);
         expect(el.innerHTML).toBe('Hello');
     });
 
@@ -178,12 +178,12 @@ describe('Unit test for process data', () => {
         jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValue({
             loginFailedMessage: 'Hello',
             authType: AuthType.None,
-        });
+        } as any);
         const el: any = {};
         expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual({
             type: e.type,
         });
-        expect(base.notifyAuthFailure).not.toBeCalled();
+        expect(base.notifyAuthFailure).not.toHaveBeenCalled();
         expect(el.innerHTML).not.toBe('Hello');
     });
 
@@ -201,7 +201,7 @@ describe('Unit test for process data', () => {
         expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual({
             type: e.type,
         });
-        expect(base.notifyLogout).toBeCalled();
+        expect(base.notifyLogout).toHaveBeenCalled();
         expect(el.innerHTML).toBe('Hello');
         expect(embedConfigInstance.getEmbedConfig().autoLogin).toBe(false);
     });
@@ -212,12 +212,12 @@ describe('Unit test for process data', () => {
             loginFailedMessage: 'Hello',
             authType: AuthType.EmbeddedSSO,
             disableLoginFailurePage: true,
-        });
+        } as any);
         const el: any = {};
         expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual({
             type: e.type,
         });
-        expect(base.notifyAuthFailure).not.toBeCalled();
+        expect(base.notifyAuthFailure).not.toHaveBeenCalled();
         expect(el.innerHTML).not.toBe('Hello');
     });
 
@@ -228,12 +228,12 @@ describe('Unit test for process data', () => {
             loginFailedMessage: 'Hello',
             authType: AuthType.TrustedAuthToken,
             autoLogin: true,
-        });
+        } as any);
         const el: any = {};
         expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual({
             type: e.type,
         });
-        expect(base.notifyAuthFailure).toBeCalledWith(auth.AuthFailureType.IDLE_SESSION_TIMEOUT);
+        expect(base.notifyAuthFailure).toHaveBeenCalledWith(auth.AuthFailureType.IDLE_SESSION_TIMEOUT);
         expect(el.innerHTML).toBe('Hello');
     });
 
@@ -244,12 +244,12 @@ describe('Unit test for process data', () => {
             loginFailedMessage: 'Hello',
             authType: AuthType.TrustedAuthTokenCookieless,
             autoLogin: true,
-        });
+        } as any);
         const el: any = {};
         expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual({
             type: e.type,
         });
-        expect(base.notifyAuthFailure).toBeCalledWith(auth.AuthFailureType.IDLE_SESSION_TIMEOUT);
+        expect(base.notifyAuthFailure).toHaveBeenCalledWith(auth.AuthFailureType.IDLE_SESSION_TIMEOUT);
         expect(el.innerHTML).toBe('Hello');
     });
 
@@ -258,9 +258,9 @@ describe('Unit test for process data', () => {
             disableFullscreenPresentation: false,
         };
         
-        const mockHandleExitPresentMode = jest.spyOn(utilsModule, 'handleExitPresentMode').mockImplementation(() => {});
+        const mockHandleExitPresentMode = jest.spyOn(utilsModule, 'handleExitPresentMode').mockImplementation(() => Promise.resolve(undefined));
         
-        jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValue(mockConfig);
+        jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValue(mockConfig as any);
 
         const processedData = {
             type: EmbedEvent.ExitPresentMode,

package/src/utils/processTrigger.spec.ts

@@ -29,7 +29,7 @@ describe('Unit test for processTrigger', () => {
         const data = {};
         _processTriggerInstance.processTrigger(iFrameElement, messageType, thoughtSpotHost, data);
         jest.advanceTimersByTime(200);
-        expect(spyReload).toBeCalledWith(iFrameElement);
+        expect(spyReload).toHaveBeenCalledWith(iFrameElement);
     });
 
     test('when hostevent is search, postMessage should be called', async () => {
@@ -43,14 +43,14 @@ describe('Unit test for processTrigger', () => {
             thoughtSpotHost,
             data,
         );
-        expect(iFrame.contentWindow.postMessage).toBeCalled();
+        expect(iFrame.contentWindow.postMessage).toHaveBeenCalled();
         const res = {
             data: {
                 test: '123',
             },
         };
         messageChannelMock.port1.onmessage(res);
-        expect(messageChannelMock.port1.close).toBeCalled();
+        expect(messageChannelMock.port1.close).toHaveBeenCalled();
         expect(triggerPromise).resolves.toEqual(res.data);
     });
 
@@ -65,14 +65,14 @@ describe('Unit test for processTrigger', () => {
             thoughtSpotHost,
             data,
         );
-        expect(iFrame.contentWindow.postMessage).toBeCalled();
+        expect(iFrame.contentWindow.postMessage).toHaveBeenCalled();
         const res = {
             data: {
                 error: 'error',
             },
         };
         messageChannelMock.port1.onmessage(res);
-        expect(messageChannelMock.port1.close).toBeCalled();
+        expect(messageChannelMock.port1.close).toHaveBeenCalled();
         expect(triggerPromise).rejects.toEqual(res.data.error);
     });
 
@@ -91,7 +91,7 @@ describe('Unit test for processTrigger', () => {
 
         jest.advanceTimersByTime(_processTriggerInstance.TRIGGER_TIMEOUT);
 
-        expect(messageChannelMock.port1.close).toBeCalled();
+        expect(messageChannelMock.port1.close).toHaveBeenCalled();
         await expect(triggerPromise).resolves.toBeInstanceOf(Error);
     });
 
@@ -101,9 +101,9 @@ describe('Unit test for processTrigger', () => {
         let mockGetEmbedConfig: any;
 
         beforeEach(() => {
-            mockHandlePresentEvent = jest.spyOn(utilsModule, 'handlePresentEvent').mockImplementation(() => {});
+            mockHandlePresentEvent = jest.spyOn(utilsModule, 'handlePresentEvent').mockImplementation(() => Promise.resolve(undefined));
             mockLoggerWarn = jest.spyOn(logger, 'warn').mockImplementation(() => {});
-            mockGetEmbedConfig = jest.spyOn(embedConfigModule, 'getEmbedConfig').mockImplementation(() => ({}));
+            mockGetEmbedConfig = jest.spyOn(embedConfigModule, 'getEmbedConfig').mockImplementation(() => ({ disableFullscreenPresentation: false } as any));
         });
 
         afterEach(() => {

package/src/utils.spec.ts

@@ -19,6 +19,7 @@ import {
     arrayIncludesString,
     calculateVisibleElementData,
     formatTemplate,
+    isValidCssMargin,
 } from './utils';
 import { RuntimeFilterOp } from './types';
 import { logger } from './utils/logger';
@@ -142,12 +143,12 @@ describe('unit test for utils', () => {
     });
 
     describe('getRedirectURL', () => {
-        let windowSpy: any;
+        let originalLocation: Location;
         beforeEach(() => {
-            windowSpy = jest.spyOn(window, 'window', 'get');
+            originalLocation = window.location;
         });
         afterEach(() => {
-            windowSpy.mockRestore();
+            window.location.hash = '';
         });
 
         test('Should return correct value when path is undefined', () => {
@@ -158,18 +159,12 @@ describe('unit test for utils', () => {
         });
 
         test('Should return correct value when path is set', () => {
-            windowSpy.mockImplementation(() => ({
-                location: {
-                    origin: 'http://myhost:3000',
-                },
-            }));
-
             expect(getRedirectUrl('http://myhost:3000/', 'hashFrag', '/bar')).toBe(
-                'http://myhost:3000/bar#?tsSSOMarker=hashFrag',
+                'http://localhost/bar#?tsSSOMarker=hashFrag',
             );
 
             expect(getRedirectUrl('http://myhost:3000/#/foo', 'hashFrag', '#/bar')).toBe(
-                'http://myhost:3000/#/bar?tsSSOMarker=hashFrag',
+                'http://localhost/#/bar?tsSSOMarker=hashFrag',
             );
         });
     });
@@ -736,3 +731,19 @@ describe('formatTemplate', () => {
         ).toBe('Hello John, you are {age} years old');
     });
 });
+
+describe('isValidCssMargin', () => {
+    it('should return true for valid CSS margin values', () => {
+        expect(isValidCssMargin('10px')).toBe(true);
+        expect(isValidCssMargin('0px')).toBe(true);
+        expect(isValidCssMargin('20%')).toBe(true);
+        expect(isValidCssMargin('0')).toBe(true);
+    });
+
+    it('should return false for invalid CSS margin values', () => {
+        expect(isValidCssMargin('')).toBe(false);
+        expect(isValidCssMargin('   ')).toBe(false);
+        expect(isValidCssMargin('invalid')).toBe(false);
+        expect(isValidCssMargin('10')).toBe(false); // missing unit
+    });
+});

package/src/utils.ts

@@ -132,6 +132,40 @@ export const getCssDimension = (value: number | string): string => {
     return value;
 };
 
+/**
+ * Validates if a string is a valid CSS margin value.
+ * @param value - The string to validate
+ * @returns true if the value is a valid CSS margin value, false otherwise
+ */
+export const isValidCssMargin = (value: string): boolean => {
+    if(isUndefined(value)) {
+        return false;
+    }
+    if (typeof value !== 'string') {
+        logger.error('Please provide a valid lazyLoadingMargin value (e.g., "10px")');
+        return false;
+    }
+
+    // This pattern allows for an optional negative sign, and numbers that can be integers or decimals (including leading dot).
+    const cssUnitPattern = /^-?(\d+(\.\d*)?|\.\d+)(px|em|rem|%|vh|vw)$/i;
+    const parts = value.trim().split(/\s+/);
+
+    if (parts.length > 4) {
+        logger.error('Please provide a valid lazyLoadingMargin value (e.g., "10px")');
+        return false;
+    }
+
+    const isValid = parts.every(part => {
+        const trimmedPart = part.trim();
+        return trimmedPart.toLowerCase() === 'auto' || trimmedPart === '0' || cssUnitPattern.test(trimmedPart);
+    });
+    if (!isValid) {
+        logger.error('Please provide a valid lazyLoadingMargin value (e.g., "10px")');
+        return false;
+    }
+    return true;
+};
+
 export const getSSOMarker = (markerId: string) => {
     const encStringToAppend = encodeURIComponent(markerId);
     return `tsSSOMarker=${encStringToAppend}`;