@thoughtspot/visual-embed-sdk 1.42.1-alpha.3 → 1.42.1-alpha.5

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

@@ -61,14 +61,6 @@ import { UIPassthroughEvent } from './hostEventClient/contracts';
 import * as sessionInfoService from '../utils/sessionInfoService';
 import * as authToken from '../authToken';
 
-// Mock api-intercept by default to avoid altering existing APP_INIT payload
-// expectations
-jest.mock('../api-intercept', () => ({
-    getInterceptInitData: jest.fn(() => ({})),
-    handleInterceptEvent: jest.fn(),
-    processLegacyInterceptResponse: jest.fn((x: any) => x),
-}));
-
 jest.mock('../utils/processTrigger');
 
 const mockProcessTrigger = processTrigger as jest.Mock;
@@ -3465,100 +3457,3 @@ describe('Unit test case for ts embed', () => {
         });
     });
 });
-
-describe('API Intercept integration in TsEmbed', () => {
-    beforeEach(() => {
-        document.body.innerHTML = getDocumentBody();
-        jest.clearAllMocks();
-    });
-
-    test('APP_INIT includes API intercept init data when enabled', async () => {
-        init({
-            thoughtSpotHost: 'tshost',
-            authType: AuthType.None,
-            enableApiIntercept: true,
-            interceptTimeout: 1234,
-        } as any);
-
-        // Include intercept setup via viewConfig too
-        const { InterceptedApiType } = require('../types');
-
-        // Override mocked getInterceptInitData for this test only
-        const apiInterceptModule = require('../api-intercept');
-        apiInterceptModule.getInterceptInitData.mockReturnValue({
-            enableApiIntercept: true,
-            interceptTimeout: 1234,
-            interceptUrls: [
-                'http://tshost/prism/?op=CreateAnswerSession',
-                'http://tshost/prism/?op=GetV2SourceDetail',
-                'http://tshost/custom/path',
-            ],
-        });
-        const searchEmbed = new SearchEmbed(getRootEl(), {
-            ...defaultViewConfig,
-            enableApiIntercept: true,
-            interceptUrls: [InterceptedApiType.METADATA, '/custom/path'],
-        } as any);
-
-        searchEmbed.render();
-
-        const mockPort: any = { postMessage: jest.fn() };
-        const mockEmbedEventPayload = { type: EmbedEvent.APP_INIT, data: {} };
-
-        await executeAfterWait(() => {
-            const iframe = getIFrameEl();
-            postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
-        });
-
-        await executeAfterWait(() => {
-            expect(mockPort.postMessage).toHaveBeenCalledWith(
-                expect.objectContaining({
-                    type: EmbedEvent.APP_INIT,
-                    data: expect.objectContaining({
-                        enableApiIntercept: true,
-                        interceptTimeout: 1234,
-                        interceptUrls: expect.arrayContaining([
-                            expect.stringContaining('CreateAnswerSession'),
-                            expect.stringContaining('GetV2SourceDetail'),
-                            expect.stringContaining('custom/path'),
-                        ]),
-                    }),
-                }),
-            );
-        });
-    });
-
-    test('ApiIntercept event delegates to handleInterceptEvent and bypasses default callbacks', async () => {
-        init({ thoughtSpotHost: 'tshost', authType: AuthType.None } as any);
-
-        const apiInterceptModule = require('../api-intercept');
-        const handleInterceptSpy = jest.spyOn(apiInterceptModule, 'handleInterceptEvent').mockResolvedValue(undefined);
-
-        const searchEmbed = new SearchEmbed(getRootEl(), {
-            ...defaultViewConfig,
-            enableApiIntercept: true,
-        } as any);
-
-        const apiCb = jest.fn();
-        searchEmbed.on(EmbedEvent.ApiIntercept as any, apiCb as any);
-
-        searchEmbed.render();
-
-        const mockPort: any = { postMessage: jest.fn() };
-        const eventPayload = {
-            type: EmbedEvent.ApiIntercept,
-            data: JSON.stringify({ input: '/prism/?op=GetChartWithData', init: { body: '{}' } }),
-        };
-
-        await executeAfterWait(() => {
-            const iframe = getIFrameEl();
-            postMessageToParent(iframe.contentWindow, eventPayload, mockPort);
-        });
-
-        await executeAfterWait(() => {
-            expect(handleInterceptSpy).toHaveBeenCalled();
-            expect(apiCb).not.toHaveBeenCalled();
-        });
-    });
-});
-

package/src/utils/processData.spec.ts

@@ -1,4 +1,3 @@
-import { disable } from 'mixpanel-browser';
 import * as processDataInstance from './processData';
 import * as answerServiceInstance from './graphql/answerService/answerService';
 import * as auth from '../auth';

package/src/api-intercept.spec.ts

@@ -1,147 +0,0 @@
-import { getInterceptInitData, processApiIntercept, handleInterceptEvent, processLegacyInterceptResponse } from './api-intercept';
-import { EmbedEvent, InterceptedApiType } from './types';
-import * as embedCfg from './embed/embedConfig';
-import * as cfg from './config';
-import { logger } from './utils/logger';
-
-describe('api-intercept', () => {
-  beforeEach(() => {
-    jest.restoreAllMocks();
-    jest.clearAllMocks();
-  });
-
-  describe('getInterceptInitData', () => {
-    test('returns disabled when not enabled in either config', () => {
-      const init = getInterceptInitData({} as any, {} as any);
-      expect(init).toEqual({ enableApiIntercept: false });
-    });
-
-    test('merges urls and expands api types, formats with host', () => {
-      jest.spyOn(embedCfg, 'getEmbedConfig').mockReturnValue({ thoughtSpotHost: 'http://tshost' } as any);
-      jest.spyOn(cfg, 'getThoughtSpotHost').mockReturnValue('http://tshost');
-
-      const embedConfig: any = { enableApiIntercept: true };
-      const viewConfig: any = { interceptUrls: [InterceptedApiType.METADATA, '/custom/path'] };
-
-      const init = getInterceptInitData(embedConfig, viewConfig);
-
-      expect(init.enableApiIntercept).toBe(true);
-      expect(init.interceptUrls).toEqual(expect.arrayContaining([
-        'http://tshost/prism/?op=CreateAnswerSession',
-        'http://tshost/prism/?op=GetV2SourceDetail',
-        'http://tshost/custom/path',
-      ]));
-    });
-
-    test('honors InterceptedApiType.ALL and interceptTimeout', () => {
-      const embedConfig: any = { enableApiIntercept: true, interceptTimeout: 2500 };
-      const viewConfig: any = { interceptUrls: [InterceptedApiType.ALL] };
-
-      const init = getInterceptInitData(embedConfig, viewConfig);
-
-      expect(init).toEqual({
-        enableApiIntercept: true,
-        interceptUrls: [InterceptedApiType.ALL],
-        interceptTimeout: 2500,
-      });
-    });
-
-    test('legacy flag isOnBeforeGetVizDataInterceptEnabled adds ANSWER_DATA', () => {
-      jest.spyOn(embedCfg, 'getEmbedConfig').mockReturnValue({ thoughtSpotHost: 'http://tshost' } as any);
-      jest.spyOn(cfg, 'getThoughtSpotHost').mockReturnValue('http://tshost');
-
-      const embedConfig: any = { enableApiIntercept: true };
-      const viewConfig: any = { isOnBeforeGetVizDataInterceptEnabled: true, interceptUrls: [] };
-
-      const init = getInterceptInitData(embedConfig, viewConfig);
-
-      // Should expand to concrete ANSWER_DATA URLs
-      expect(init.interceptUrls).toEqual(expect.arrayContaining([
-        'http://tshost/prism/?op=GetChartWithData',
-        'http://tshost/prism/?op=GetTableWithHeadlineData',
-      ]));
-    });
-
-    test('viewConfig enableApiIntercept=false overrides embed config', () => {
-      const embedConfig: any = { enableApiIntercept: true };
-      const viewConfig: any = { enableApiIntercept: false };
-      const init = getInterceptInitData(embedConfig, viewConfig);
-      expect(init).toEqual({ enableApiIntercept: false });
-    });
-  });
-
-  describe('processApiIntercept', () => {
-    test('parses data JSON string', async () => {
-      const result = await processApiIntercept({ data: JSON.stringify({ foo: 'bar' }) });
-      expect(result).toEqual({ foo: 'bar' });
-    });
-  });
-
-  describe('handleInterceptEvent', () => {
-    test('emits error on body parse failure', async () => {
-      const executeEvent = jest.fn();
-      const loggerErrSpy = jest.spyOn(logger, 'error').mockImplementation(() => undefined as any);
-      await handleInterceptEvent({
-        eventData: { data: 'not-a-json' },
-        executeEvent,
-        embedConfig: {} as any,
-        viewConfig: {} as any,
-        getUnsavedAnswerTml: jest.fn(),
-      });
-      expect(executeEvent).toHaveBeenCalledWith(EmbedEvent.Error, { error: 'Error parsing api intercept body' });
-      loggerErrSpy.mockReset();
-    });
-
-    test('calls getUnsavedAnswerTml and emits legacy + ApiIntercept events when applicable', async () => {
-      const executeEvent = jest.fn();
-      const getUnsavedAnswerTml = jest.fn().mockResolvedValue({ tml: 'TML_STRING' });
-
-      const eventPayload = {
-        input: '/prism/?op=GetChartWithData',
-        init: {
-          body: JSON.stringify({
-            variables: {
-              session: { sessionId: 'S1' },
-              contextBookId: 'V1',
-            },
-          }),
-        },
-      };
-
-      await handleInterceptEvent({
-        eventData: { data: JSON.stringify(eventPayload) },
-        executeEvent,
-        embedConfig: {} as any,
-        viewConfig: { isOnBeforeGetVizDataInterceptEnabled: true } as any,
-        getUnsavedAnswerTml,
-      });
-
-      expect(getUnsavedAnswerTml).toHaveBeenCalledWith({ sessionId: 'S1', vizId: 'V1' });
-      expect(executeEvent).toHaveBeenCalledWith(
-        EmbedEvent.OnBeforeGetVizDataIntercept,
-        { data: { data: { tml: 'TML_STRING' } } },
-      );
-      expect(executeEvent).toHaveBeenCalledWith(
-        EmbedEvent.ApiIntercept,
-        expect.objectContaining({ input: '/prism/?op=GetChartWithData' }),
-      );
-    });
-  });
-
-  describe('processLegacyInterceptResponse', () => {
-    test('wraps legacy error payload as expected', () => {
-      const payload = { data: { errorText: 'Title', errorDescription: 'Desc' } } as any;
-      const res = processLegacyInterceptResponse(payload);
-      expect(Array.isArray(res)).toBe(true);
-      expect(res[0]).toEqual(expect.objectContaining({
-        errors: [
-          expect.objectContaining({
-            errorObj: expect.objectContaining({ title: 'Title', desc: 'Desc' }),
-          }),
-        ],
-      }));
-    });
-  });
-});
-
-