@thoughtspot/visual-embed-sdk 1.49.3 → 1.50.1

package/src/utils/processData.spec.ts

@@ -80,6 +80,11 @@ describe('Unit test for process data', () => {
         );
     });
 
+    test('ProcessData QueryChanged default branch returns payload unchanged', () => {
+        const e = { type: EmbedEvent.QueryChanged, data: { query: 'revenue by region' } };
+        expect(processDataInstance.processEventData(EmbedEvent.QueryChanged, e, thoughtSpotHost, null)).toEqual(e);
+    });
+
     test('ProcessData, when Action is non CustomAction', () => {
         const processedData = { type: EmbedEvent.Data };
         jest.spyOn(processDataInstance, 'processCustomAction').mockImplementation(async () => ({}));
@@ -279,6 +284,130 @@ describe('Unit test for process data', () => {
         mockHandleExitPresentMode.mockReset();
     });
 
+    test('AuthInit with payload.userGUID fallback when data.userGUID is absent', () => {
+        const e = {
+            type: EmbedEvent.AuthInit,
+            payload: { userGUID: 'payloadGUID' },
+        };
+        jest.spyOn(base, 'notifyAuthSuccess');
+        expect(processDataInstance.processEventData(e.type, e, '', null)).toEqual({
+            type: e.type,
+            payload: { userGUID: 'payloadGUID' },
+            data: { userGUID: 'payloadGUID' },
+        });
+        expect(base.notifyAuthSuccess).toHaveBeenCalled();
+    });
+
+    test('process authFailure EmbeddedSSO with UNAUTHENTICATED_FAILURE suppresses login page', () => {
+        const e = {
+            type: EmbedEvent.AuthFailure,
+            data: { type: auth.AuthFailureType.UNAUTHENTICATED_FAILURE },
+        };
+        jest.spyOn(base, 'notifyAuthFailure');
+        jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValue({
+            loginFailedMessage: 'Hello',
+            authType: AuthType.EmbeddedSSO,
+            disableLoginFailurePage: false,
+        } as any);
+        const el: any = {};
+        processDataInstance.processEventData(e.type, e, '', el);
+        // isEmbeddedSSOInfoFailure=true so neither branch fires, innerHTML stays unset
+        expect(el.innerHTML).toBeUndefined();
+        expect(base.notifyAuthFailure).not.toHaveBeenCalled();
+    });
+
+    test('processEventData default branch returns payload unchanged for non-special events', () => {
+        const events = [
+            EmbedEvent.Drilldown,
+            EmbedEvent.DataSourceSelected,
+            EmbedEvent.AddRemoveColumns,
+            EmbedEvent.VizPointDoubleClick,
+            EmbedEvent.VizPointClick,
+            EmbedEvent.Alert,
+            EmbedEvent.GetDataClick,
+            EmbedEvent.DialogClose,
+            EmbedEvent.Download,
+            EmbedEvent.DownloadAsPng,
+            EmbedEvent.DownloadAsPdf,
+            EmbedEvent.DownloadAsCsv,
+            EmbedEvent.DownloadAsXlsx,
+            EmbedEvent.DownloadLiveboardAsContinuousPDF,
+            EmbedEvent.AnswerDelete,
+            EmbedEvent.AIHighlights,
+            EmbedEvent.Pin,
+            EmbedEvent.SpotIQAnalyze,
+            EmbedEvent.Share,
+            EmbedEvent.DrillInclude,
+            EmbedEvent.DrillExclude,
+            EmbedEvent.CopyToClipboard,
+            EmbedEvent.UpdateTML,
+            EmbedEvent.EditTML,
+            EmbedEvent.ExportTML,
+            EmbedEvent.SaveAsView,
+            EmbedEvent.CopyAEdit,
+            EmbedEvent.ShowUnderlyingData,
+            EmbedEvent.AnswerChartSwitcher,
+            EmbedEvent.LiveboardInfo,
+            EmbedEvent.AddToFavorites,
+            EmbedEvent.Schedule,
+            EmbedEvent.Edit,
+            EmbedEvent.MakeACopy,
+            EmbedEvent.Present,
+            EmbedEvent.Delete,
+            EmbedEvent.SchedulesList,
+            EmbedEvent.Cancel,
+            EmbedEvent.Explore,
+            EmbedEvent.CopyLink,
+            EmbedEvent.CrossFilterChanged,
+            EmbedEvent.VizPointRightClick,
+            EmbedEvent.InsertIntoSlide,
+            EmbedEvent.FilterChanged,
+            EmbedEvent.UpdateConnection,
+            EmbedEvent.CreateConnection,
+            EmbedEvent.ResetLiveboard,
+            EmbedEvent.ChangePersonalizedView,
+            EmbedEvent.CreateWorksheet,
+            EmbedEvent.AskSageInit,
+            EmbedEvent.Rename,
+            EmbedEvent.ParameterChanged,
+            EmbedEvent.TableVizRendered,
+            EmbedEvent.CreateLiveboard,
+            EmbedEvent.CreateModel,
+            EmbedEvent.SpotterData,
+            EmbedEvent.PreviewSpotterData,
+            EmbedEvent.AddToCoaching,
+            EmbedEvent.DataModelInstructions,
+            EmbedEvent.SpotterQueryTriggered,
+            EmbedEvent.LastPromptEdited,
+            EmbedEvent.LastPromptDeleted,
+            EmbedEvent.ResetSpotterConversation,
+            EmbedEvent.SpotterInit,
+            EmbedEvent.SpotterLoadComplete,
+            EmbedEvent.OrgSwitched,
+            EmbedEvent.SpotterConversationRenamed,
+            EmbedEvent.SpotterConversationDeleted,
+            EmbedEvent.SpotterConversationSelected,
+            EmbedEvent.EmbedPageContextChanged,
+            EmbedEvent.Subscribed,
+            EmbedEvent.SendTestScheduleEmail,
+            EmbedEvent.SpotterVizInit,
+            EmbedEvent.SpotterVizQueryTriggered,
+            EmbedEvent.SpotterVizResponseComplete,
+            EmbedEvent.SpotterVizCheckpointCreated,
+            EmbedEvent.SpotterVizCheckpointRestored,
+            EmbedEvent.SpotterVizError,
+            EmbedEvent.SpotterVizClosed,
+            EmbedEvent.RefreshLiveboardBrowserCache,
+            EmbedEvent.V1Data,
+        ];
+        events.forEach((eventType) => {
+            const e = { type: eventType, data: 'test-payload' };
+            expect(
+                processDataInstance.processEventData(eventType, e, thoughtSpotHost, null),
+            ).toEqual(e);
+        });
+    });
+
     test('should handle ClearInfoCache', () => {
         const mockResetCachedPreauthInfo = jest.spyOn(sessionInfoService, 'resetCachedPreauthInfo').mockImplementation(() => {});
         const mockResetCachedSessionInfo = jest.spyOn(sessionInfoService, 'resetCachedSessionInfo').mockImplementation(() => {});

package/src/utils/processTrigger.spec.ts

@@ -216,5 +216,96 @@ describe('Unit test for processTrigger', () => {
                 'Fullscreen presentation mode is disabled. Set disableFullscreenPresentation: false to enable this feature.',
             );
         });
+
+        test('postMessage is called with type=present when disableFullscreenPresentation is false', () => {
+            mockGetEmbedConfig.mockReturnValue({ disableFullscreenPresentation: false });
+            const thoughtSpotHost = 'https://example.thoughtspot.com';
+            _processTriggerInstance.processTrigger(iFrame, HostEvent.Present, thoughtSpotHost, {});
+            expect(iFrame.contentWindow.postMessage).toHaveBeenCalledWith(
+                expect.objectContaining({ type: HostEvent.Present }),
+                thoughtSpotHost,
+                expect.anything(),
+            );
+        });
+
+        test('postMessage is still called with type=present when disableFullscreenPresentation is true', () => {
+            mockGetEmbedConfig.mockReturnValue({ disableFullscreenPresentation: true });
+            const thoughtSpotHost = 'https://example.thoughtspot.com';
+            _processTriggerInstance.processTrigger(iFrame, HostEvent.Present, thoughtSpotHost, {});
+            expect(iFrame.contentWindow.postMessage).toHaveBeenCalledWith(
+                expect.objectContaining({ type: HostEvent.Present }),
+                thoughtSpotHost,
+                expect.anything(),
+            );
+        });
+
+        test('handlePresentEvent receives the exact iFrame reference passed to processTrigger', () => {
+            mockGetEmbedConfig.mockReturnValue({ disableFullscreenPresentation: false });
+            _processTriggerInstance.processTrigger(
+                iFrame, HostEvent.Present, 'https://example.thoughtspot.com', {},
+            );
+            expect(mockHandlePresentEvent).toHaveBeenCalledWith(iFrame);
+        });
+    });
+
+    test('nested responseData.data.error causes promise rejection', async () => {
+        const messageType = HostEvent.Search;
+        const thoughtSpotHost = 'http://localhost:3000';
+        mockMessageChannel();
+        const triggerPromise = _processTriggerInstance.processTrigger(
+            iFrame, messageType, thoughtSpotHost, {},
+        );
+        messageChannelMock.port1.onmessage({ data: { data: { error: 'nested-error' } } });
+        await expect(triggerPromise).rejects.toEqual('nested-error');
+    });
+
+    test('context parameter is forwarded as context field in the postMessage payload', async () => {
+        const messageType = HostEvent.Search;
+        const thoughtSpotHost = 'http://localhost:3000';
+        const context = 'Liveboard' as any;
+        mockMessageChannel();
+        _processTriggerInstance.processTrigger(iFrame, messageType, thoughtSpotHost, {}, context);
+        expect(iFrame.contentWindow.postMessage).toHaveBeenCalledWith(
+            expect.objectContaining({ context }),
+            thoughtSpotHost,
+            expect.anything(),
+        );
+    });
+
+    describe('Reload timing and side-effects', () => {
+        test('src is cleared immediately but not restored until exactly 100ms', () => {
+            jest.useFakeTimers();
+            const iFrameElement = document.createElement('iframe');
+            iFrameElement.src = 'http://localhost:3000';
+            const originalSrc = iFrameElement.src; // normalized by jsdom
+
+            _processTriggerInstance.reload(iFrameElement);
+
+            expect(iFrameElement.src).not.toBe(originalSrc); // cleared
+            jest.advanceTimersByTime(99);
+            expect(iFrameElement.src).not.toBe(originalSrc); // not yet restored
+            jest.advanceTimersByTime(1);
+            expect(iFrameElement.src).toBe(originalSrc); // restored at 100ms
+            jest.useRealTimers();
+        });
+
+        test('processTrigger(Reload) does not call iFrame.contentWindow.postMessage', () => {
+            jest.useFakeTimers();
+            // Use the outer iFrame mock which has a mockable contentWindow
+            jest.clearAllMocks();
+            _processTriggerInstance.processTrigger(
+                iFrame, HostEvent.Reload, 'http://localhost:3000', {},
+            );
+            jest.advanceTimersByTime(200);
+            expect(iFrame.contentWindow.postMessage).not.toHaveBeenCalled();
+            jest.useRealTimers();
+        });
+
+        test('processTrigger(Reload) resolves with null', async () => {
+            const result = await _processTriggerInstance.processTrigger(
+                iFrame, HostEvent.Reload, 'http://localhost:3000', {},
+            );
+            expect(result).toBeNull();
+        });
     });
 });

package/src/utils/reporting.spec.ts

@@ -88,4 +88,31 @@ describe('ReportingObserver', () => {
 
         (window as any).ReportingObserver = currentObserver;
     });
+
+    test('should suppress alert but still log error when suppressErrorAlerts is true', () => {
+        let callBackPassed: any;
+        const NewMockRO = jest.fn().mockImplementation((callback: any) => {
+            callBackPassed = callback;
+            return ({ observe: jest.fn(), disconnect: jest.fn(), takeRecords: jest.fn() });
+        });
+        const currentObserver = (window as any).ReportingObserver;
+        (window as any).ReportingObserver = NewMockRO;
+
+        setEmbedConfig({
+            thoughtSpotHost: 'testHost',
+            authType: AuthType.None,
+            suppressErrorAlerts: true,
+        } as any);
+
+        const mockAlert = jest.fn();
+        window.alert = mockAlert;
+
+        registerReportingObserver(true);
+        callBackPassed([{ type: 'csp-violation', url: 'testHost', body: { effectiveDirective: 'frame-ancestors' } }]);
+
+        expect(mockAlert).not.toHaveBeenCalled();
+        expect(logger.error).toHaveBeenCalledWith(ERROR_MESSAGE.CSP_FRAME_HOST_VIOLATION_LOG_MESSAGE);
+
+        (window as any).ReportingObserver = currentObserver;
+    });
 });

package/src/utils/sessionInfoService.spec.ts

@@ -0,0 +1,151 @@
+import * as authServiceModule from './authService';
+import * as embedConfigModule from '../embed/embedConfig';
+import {
+    formatPreauthInfo,
+    getPreauthInfo,
+    getSessionInfo,
+    resetCachedPreauthInfo,
+    resetCachedSessionInfo,
+    getCachedSessionInfo,
+    getSessionDetails,
+} from './sessionInfoService';
+
+describe('sessionInfoService', () => {
+    beforeEach(() => {
+        resetCachedPreauthInfo();
+        resetCachedSessionInfo();
+        jest.clearAllMocks();
+    });
+
+    describe('formatPreauthInfo', () => {
+        it('parses headers and JSON body from a response', async () => {
+            const headers = new Headers({ 'content-type': 'application/json' });
+            const mockResp = {
+                headers,
+                json: jest.fn().mockResolvedValue({ info: { userGUID: 'u1' } }),
+            };
+            const result = await formatPreauthInfo(mockResp);
+            expect(result.info.userGUID).toBe('u1');
+            expect(result.status).toBe(200);
+            expect(result.headers['content-type']).toBe('application/json');
+        });
+
+        it('returns null when response.json() throws (covers catch block)', async () => {
+            const mockResp = {
+                headers: null as any,
+                json: jest.fn().mockRejectedValue(new Error('parse error')),
+            };
+            const result = await formatPreauthInfo(mockResp);
+            expect(result).toBeNull();
+        });
+
+        it('handles response where headers is null (covers headers?.forEach branch)', async () => {
+            const mockResp = {
+                headers: null as any,
+                json: jest.fn().mockResolvedValue({ info: {} }),
+            };
+            const result = await formatPreauthInfo(mockResp);
+            expect(result.headers).toEqual({});
+        });
+    });
+
+    describe('getPreauthInfo', () => {
+        it('fetches and caches preauthInfo on first call', async () => {
+            const mockResp = {
+                headers: new Headers({ 'x-caller': 'test' }),
+                json: jest.fn().mockResolvedValue({ info: { userGUID: 'u1' } }),
+            };
+            jest.spyOn(embedConfigModule, 'getEmbedConfig').mockReturnValue({ thoughtSpotHost: 'https://ts' } as any);
+            jest.spyOn(authServiceModule, 'fetchPreauthInfoService').mockResolvedValue(mockResp as any);
+
+            const result = await getPreauthInfo();
+            expect(result.info.userGUID).toBe('u1');
+        });
+
+        it('returns cached preauthInfo on subsequent calls (covers allowCache=true && preauthInfo cached branch)', async () => {
+            const mockResp = {
+                headers: new Headers(),
+                json: jest.fn().mockResolvedValue({ info: { userGUID: 'cached-user' } }),
+            };
+            jest.spyOn(embedConfigModule, 'getEmbedConfig').mockReturnValue({ thoughtSpotHost: 'https://ts' } as any);
+            const fetchSpy = jest.spyOn(authServiceModule, 'fetchPreauthInfoService').mockResolvedValue(mockResp as any);
+
+            await getPreauthInfo(); // first call — fetches and caches
+            await getPreauthInfo(); // second call — should use cache
+
+            expect(fetchSpy).toHaveBeenCalledTimes(1);
+        });
+
+        it('returns null when fetch throws (covers catch block)', async () => {
+            jest.spyOn(embedConfigModule, 'getEmbedConfig').mockReturnValue({ thoughtSpotHost: 'https://ts' } as any);
+            jest.spyOn(authServiceModule, 'fetchPreauthInfoService').mockRejectedValue(new Error('network error'));
+
+            const result = await getPreauthInfo();
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('getSessionInfo', () => {
+        it('fetches and returns session info', async () => {
+            const sessionInfoResp = {
+                userGUID: 'u1',
+                releaseVersion: '1.0',
+                configInfo: {
+                    mixpanelConfig: { devSdkKey: 'dev', prodSdkKey: 'prod', production: false },
+                    isPublicUser: false,
+                    selfClusterId: 'c1',
+                    selfClusterName: 'cluster1',
+                },
+            };
+            jest.spyOn(embedConfigModule, 'getEmbedConfig').mockReturnValue({ thoughtSpotHost: 'https://ts' } as any);
+            jest.spyOn(authServiceModule, 'fetchSessionInfoService').mockResolvedValue(sessionInfoResp as any);
+
+            const result = await getSessionInfo();
+            expect(result.userGUID).toBe('u1');
+            expect(result.mixpanelToken).toBe('dev');
+        });
+
+        it('returns cached session info on second call', async () => {
+            const sessionInfoResp = {
+                userGUID: 'u2',
+                releaseVersion: '2.0',
+                configInfo: {
+                    mixpanelConfig: { devSdkKey: 'dev2', prodSdkKey: 'prod2', production: true },
+                    isPublicUser: false,
+                    selfClusterId: 'c2',
+                    selfClusterName: 'cluster2',
+                },
+            };
+            jest.spyOn(embedConfigModule, 'getEmbedConfig').mockReturnValue({ thoughtSpotHost: 'https://ts' } as any);
+            const fetchSpy = jest.spyOn(authServiceModule, 'fetchSessionInfoService').mockResolvedValue(sessionInfoResp as any);
+
+            await getSessionInfo();
+            await getSessionInfo();
+            expect(fetchSpy).toHaveBeenCalledTimes(1);
+        });
+    });
+
+    describe('getCachedSessionInfo', () => {
+        it('returns null before any fetch', () => {
+            expect(getCachedSessionInfo()).toBeNull();
+        });
+    });
+
+    describe('getSessionDetails', () => {
+        it('uses prodSdkKey when production flag is true', () => {
+            const resp = {
+                userGUID: 'u3',
+                releaseVersion: '3.0',
+                configInfo: {
+                    mixpanelConfig: { devSdkKey: 'dev', prodSdkKey: 'prod', production: true },
+                    isPublicUser: true,
+                    selfClusterId: 'c3',
+                    selfClusterName: 'cluster3',
+                },
+            };
+            const result = getSessionDetails(resp);
+            expect(result.mixpanelToken).toBe('prod');
+            expect(result.isPublicUser).toBe(true);
+        });
+    });
+});

package/src/utils.spec.ts

@@ -27,6 +27,13 @@ import {
     validateHttpUrl,
     setParamIfDefined,
     querySelectorAcrossShadowRoot,
+    getSSOMarker,
+    deepMerge,
+    getHostEventsConfig,
+    isWindowUndefined,
+    getOffsetTop,
+    getDOMNode,
+    getOperationNameFromQuery,
 } from './utils';
 import { RuntimeFilterOp } from './types';
 import { logger } from './utils/logger';
@@ -388,6 +395,18 @@ describe('Fullscreen Utility Functions', () => {
             expect(logger.error).toHaveBeenCalledWith('Fullscreen API is not supported by this browser.');
         });
 
+        it('should catch error and log warning when requestFullscreen throws (covers line 506)', async () => {
+            // Covers line 506: catch block inside fullscreen method attempt
+            (mockIframe.requestFullscreen as jest.Mock).mockRejectedValue(new Error('permission denied'));
+
+            await handlePresentEvent(mockIframe);
+
+            expect(logger.warn).toHaveBeenCalledWith(
+                expect.stringContaining('Failed to enter fullscreen'),
+                expect.any(Error),
+            );
+        });
+
         it('should not attempt fullscreen when already in fullscreen mode', () => {
             Object.defineProperty(document, 'fullscreenElement', {
                 writable: true,
@@ -1009,6 +1028,24 @@ describe('isValidCssMargin', () => {
         expect(isValidCssMargin('invalid')).toBe(false);
         expect(isValidCssMargin('10')).toBe(false); // missing unit
     });
+
+    it('should return false and log error when value is not a string (non-string type)', () => {
+        // Covers line 147-148: typeof value !== 'string' branch
+        expect(isValidCssMargin(42 as any)).toBe(false);
+        expect(logger.error).toHaveBeenCalledWith('Please provide a valid lazyLoadingMargin value (e.g., "10px")');
+    });
+
+    it('should return false when more than 4 space-separated parts are given', () => {
+        // Covers line 157-158: parts.length > 4 branch
+        expect(isValidCssMargin('10px 20px 30px 40px 50px')).toBe(false);
+        expect(logger.error).toHaveBeenCalledWith('Please provide a valid lazyLoadingMargin value (e.g., "10px")');
+    });
+
+    it('should return true for valid multi-part margin (up to 4 parts)', () => {
+        expect(isValidCssMargin('10px 20px')).toBe(true);
+        expect(isValidCssMargin('10px 20px 30px 40px')).toBe(true);
+        expect(isValidCssMargin('auto')).toBe(true);
+    });
 });
 
 describe('getValueFromWindow and storeValueInWindow', () => {
@@ -1140,3 +1177,161 @@ describe('getValueFromWindow and storeValueInWindow', () => {
         });
     });
 });
+
+// ---------------------------------------------------------------------------
+// getSSOMarker
+// ---------------------------------------------------------------------------
+describe('getSSOMarker', () => {
+    test('returns tsSSOMarker query string with encoded markerId', () => {
+        expect(getSSOMarker('abc123')).toBe('tsSSOMarker=abc123');
+    });
+
+    test('URL-encodes special characters in markerId', () => {
+        expect(getSSOMarker('hello world')).toBe('tsSSOMarker=hello%20world');
+        expect(getSSOMarker('foo=bar&baz')).toBe('tsSSOMarker=foo%3Dbar%26baz');
+    });
+
+    test('handles empty string markerId', () => {
+        expect(getSSOMarker('')).toBe('tsSSOMarker=');
+    });
+});
+
+// ---------------------------------------------------------------------------
+// deepMerge
+// ---------------------------------------------------------------------------
+describe('deepMerge', () => {
+    test('merges two flat objects', () => {
+        const result = deepMerge({ a: 1 }, { b: 2 });
+        expect(result).toEqual({ a: 1, b: 2 });
+    });
+
+    test('source overrides target for same keys', () => {
+        const result = deepMerge({ a: 1, b: 2 }, { b: 99 });
+        expect(result).toEqual({ a: 1, b: 99 });
+    });
+
+    test('deep merges nested objects', () => {
+        const result = deepMerge({ a: { x: 1, y: 2 } }, { a: { y: 99, z: 3 } });
+        expect(result).toEqual({ a: { x: 1, y: 99, z: 3 } });
+    });
+
+    test('handles empty source', () => {
+        const result = deepMerge({ a: 1 }, {});
+        expect(result).toEqual({ a: 1 });
+    });
+
+    test('handles empty target', () => {
+        const result = deepMerge({}, { b: 2 });
+        expect(result).toEqual({ b: 2 });
+    });
+});
+
+// ---------------------------------------------------------------------------
+// getHostEventsConfig
+// ---------------------------------------------------------------------------
+describe('getHostEventsConfig', () => {
+    test('returns shouldBypassPayloadValidation and useHostEventsV2 from viewConfig', () => {
+        const viewConfig: any = { shouldBypassPayloadValidation: true, useHostEventsV2: false };
+        expect(getHostEventsConfig(viewConfig)).toEqual({
+            shouldBypassPayloadValidation: true,
+            useHostEventsV2: false,
+        });
+    });
+
+    test('returns undefined for missing keys', () => {
+        const result = getHostEventsConfig({} as any);
+        expect(result.shouldBypassPayloadValidation).toBeUndefined();
+        expect(result.useHostEventsV2).toBeUndefined();
+    });
+
+    test('ignores unrelated config properties', () => {
+        const viewConfig: any = {
+            shouldBypassPayloadValidation: false,
+            useHostEventsV2: true,
+            liveboardId: 'lb-1',
+        };
+        expect(getHostEventsConfig(viewConfig)).toEqual({
+            shouldBypassPayloadValidation: false,
+            useHostEventsV2: true,
+        });
+    });
+});
+
+// ---------------------------------------------------------------------------
+// isWindowUndefined
+// ---------------------------------------------------------------------------
+describe('isWindowUndefined', () => {
+    test('returns false when window is defined (browser/jsdom env)', () => {
+        // In jest/jsdom, window is always defined
+        expect(isWindowUndefined()).toBe(false);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// getOffsetTop
+// ---------------------------------------------------------------------------
+describe('getOffsetTop', () => {
+    test('returns rect.top + window.scrollY', () => {
+        const mockElement = {
+            getBoundingClientRect: () => ({ top: 50 }),
+        };
+        Object.defineProperty(window, 'scrollY', { value: 100, configurable: true });
+        expect(getOffsetTop(mockElement)).toBe(150);
+    });
+
+    test('returns rect.top when scrollY is 0', () => {
+        const mockElement = {
+            getBoundingClientRect: () => ({ top: 30 }),
+        };
+        Object.defineProperty(window, 'scrollY', { value: 0, configurable: true });
+        expect(getOffsetTop(mockElement)).toBe(30);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// getDOMNode
+// ---------------------------------------------------------------------------
+describe('getDOMNode', () => {
+    test('returns the element from document.querySelector when passed a string selector', () => {
+        const div = document.createElement('div');
+        div.id = 'test-dom-node';
+        document.body.appendChild(div);
+        expect(getDOMNode('#test-dom-node')).toBe(div);
+        document.body.removeChild(div);
+    });
+
+    test('returns the element directly when passed an HTMLElement', () => {
+        const div = document.createElement('div');
+        expect(getDOMNode(div)).toBe(div);
+    });
+
+    test('returns null for a selector that matches nothing', () => {
+        expect(getDOMNode('#nonexistent-element-xyz')).toBeNull();
+    });
+});
+
+// ---------------------------------------------------------------------------
+// getOperationNameFromQuery
+// ---------------------------------------------------------------------------
+describe('getOperationNameFromQuery', () => {
+    test('extracts operation name from a query string', () => {
+        expect(getOperationNameFromQuery('query GetUser { user { id } }')).toBe('GetUser');
+    });
+
+    test('extracts operation name from a mutation string', () => {
+        expect(getOperationNameFromQuery('mutation CreateUser { createUser { id } }')).toBe('CreateUser');
+    });
+
+    test('returns undefined when no operation name is present', () => {
+        expect(getOperationNameFromQuery('{ user { id } }')).toBeUndefined();
+    });
+
+    test('handles multiline query strings', () => {
+        const query = `
+            query FetchData {
+                data { id }
+            }
+        `;
+        expect(getOperationNameFromQuery(query)).toBe('FetchData');
+    });
+});