@thoughtspot/visual-embed-sdk 1.43.0 → 1.43.1

package/src/api-intercept.spec.ts

@@ -0,0 +1,856 @@
+import * as apiIntercept from './api-intercept';
+import * as config from './config';
+import * as embedConfig from './embed/embedConfig';
+import { InterceptedApiType, EmbedEvent, BaseViewConfig } from './types';
+import { embedEventStatus } from './utils';
+import { logger } from './utils/logger';
+
+jest.mock('./config');
+jest.mock('./embed/embedConfig');
+jest.mock('./utils/logger');
+
+const mockGetThoughtSpotHost = config.getThoughtSpotHost as jest.Mock;
+const mockGetEmbedConfig = embedConfig.getEmbedConfig as jest.Mock;
+const mockLogger = logger as jest.Mocked<typeof logger>;
+
+describe('api-intercept', () => {
+  const thoughtSpotHost = 'https://test.thoughtspot.com';
+  let originalJsonParse: any;
+
+  beforeAll(() => {
+    originalJsonParse = JSON.parse;
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockGetThoughtSpotHost.mockReturnValue(thoughtSpotHost);
+    mockGetEmbedConfig.mockReturnValue({});
+    // Restore JSON.parse before each test
+    JSON.parse = originalJsonParse;
+  });
+
+  afterEach(() => {
+    // Ensure JSON.parse is restored after each test
+    JSON.parse = originalJsonParse;
+  });
+
+  describe('getInterceptInitData', () => {
+    it('should return default intercept flags when no intercepts are configured', () => {
+      const viewConfig: BaseViewConfig = {};
+
+      const result = apiIntercept.getInterceptInitData(viewConfig);
+
+      expect(result).toEqual({
+        interceptUrls: [],
+        interceptTimeout: undefined,
+      });
+    });
+
+    it('should expand InterceptedApiType.AnswerData to specific URLs', () => {
+      const viewConfig: BaseViewConfig = {
+        interceptUrls: [InterceptedApiType.AnswerData]
+      };
+
+      const result = apiIntercept.getInterceptInitData(viewConfig);
+
+      expect(result.interceptUrls).toEqual([
+        `${thoughtSpotHost}/prism/?op=GetChartWithData`,
+        `${thoughtSpotHost}/prism/?op=GetTableWithHeadlineData`,
+        `${thoughtSpotHost}/prism/?op=GetTableWithData`,
+      ]);
+    });
+
+    it('should expand InterceptedApiType.LiveboardData to specific URLs', () => {
+      const viewConfig: BaseViewConfig = {
+        interceptUrls: [InterceptedApiType.LiveboardData]
+      };
+
+      const result = apiIntercept.getInterceptInitData(viewConfig);
+
+      expect(result.interceptUrls).toEqual([
+        `${thoughtSpotHost}/prism/?op=LoadContextBook`
+      ]);
+    });
+
+    it('should handle multiple intercept types', () => {
+      const viewConfig: BaseViewConfig = {
+        interceptUrls: [
+          InterceptedApiType.AnswerData,
+          InterceptedApiType.LiveboardData
+        ]
+      };
+
+      const result = apiIntercept.getInterceptInitData(viewConfig);
+
+      expect(result.interceptUrls).toContain(`${thoughtSpotHost}/prism/?op=GetChartWithData`);
+      expect(result.interceptUrls).toContain(`${thoughtSpotHost}/prism/?op=LoadContextBook`);
+      expect(result.interceptUrls.length).toBe(4);
+    });
+
+    it('should handle custom URL strings', () => {
+      const customUrl = '/api/custom-endpoint';
+      const viewConfig: BaseViewConfig = {
+        interceptUrls: [customUrl]
+      };
+
+      const result = apiIntercept.getInterceptInitData(viewConfig);
+
+      expect(result.interceptUrls).toEqual([`${thoughtSpotHost}${customUrl}`]);
+    });
+
+    it('should handle full URL strings', () => {
+      const fullUrl = 'https://example.com/api/endpoint';
+      const viewConfig: BaseViewConfig = {
+        interceptUrls: [fullUrl]
+      };
+
+      const result = apiIntercept.getInterceptInitData(viewConfig);
+
+      expect(result.interceptUrls).toEqual([fullUrl]);
+    });
+
+    it('should handle InterceptedApiType.ALL', () => {
+      const viewConfig: BaseViewConfig = {
+        interceptUrls: [InterceptedApiType.ALL]
+      };
+
+      const result = apiIntercept.getInterceptInitData(viewConfig);
+
+      expect(result.interceptUrls).toEqual([InterceptedApiType.ALL]);
+    });
+
+    it('should prioritize ALL over other intercept types', () => {
+      const viewConfig: BaseViewConfig = {
+        interceptUrls: [
+          InterceptedApiType.AnswerData,
+          InterceptedApiType.ALL,
+          '/api/custom'
+        ]
+      };
+
+      const result = apiIntercept.getInterceptInitData(viewConfig);
+
+      expect(result.interceptUrls).toEqual([InterceptedApiType.ALL]);
+    });
+
+    it('should handle legacy isOnBeforeGetVizDataInterceptEnabled flag', () => {
+      const viewConfig: any = {
+        isOnBeforeGetVizDataInterceptEnabled: true
+      };
+
+      const result = apiIntercept.getInterceptInitData(viewConfig);
+
+      expect(result.interceptUrls).toContain(`${thoughtSpotHost}/prism/?op=GetChartWithData`);
+    });
+
+    it('should combine legacy flag with interceptUrls', () => {
+      const viewConfig: any = {
+        isOnBeforeGetVizDataInterceptEnabled: true,
+        interceptUrls: [InterceptedApiType.LiveboardData]
+      };
+
+      const result = apiIntercept.getInterceptInitData(viewConfig);
+
+      expect(result.interceptUrls).toContain(`${thoughtSpotHost}/prism/?op=GetChartWithData`);
+      expect(result.interceptUrls).toContain(`${thoughtSpotHost}/prism/?op=LoadContextBook`);
+    });
+
+    it('should pass through interceptTimeout', () => {
+      const viewConfig: BaseViewConfig = {
+        interceptUrls: [],
+        interceptTimeout: 5000
+      };
+
+      const result = apiIntercept.getInterceptInitData(viewConfig);
+
+      expect(result.interceptTimeout).toBe(5000);
+    });
+
+    it('should deduplicate URLs when same type is added multiple times', () => {
+      const viewConfig: BaseViewConfig = {
+        interceptUrls: [
+          InterceptedApiType.AnswerData,
+          InterceptedApiType.AnswerData
+        ]
+      };
+
+      const result = apiIntercept.getInterceptInitData(viewConfig);
+
+      expect(result.interceptUrls.length).toBe(3); // 3 answer data URLs
+    });
+  });
+
+  describe('handleInterceptEvent', () => {
+    let executeEvent: jest.Mock;
+    let getUnsavedAnswerTml: jest.Mock;
+    let viewConfig: BaseViewConfig;
+
+    beforeEach(() => {
+      executeEvent = jest.fn();
+      getUnsavedAnswerTml = jest.fn().mockResolvedValue({ answer: { tml: 'test-tml' } });
+      viewConfig = {};
+    });
+
+    it('should handle valid intercept data', async () => {
+      const eventData = {
+        data: JSON.stringify({
+          input: '/prism/?op=GetChartWithData',
+          init: {
+            method: 'POST',
+            body: JSON.stringify({
+              variables: {
+                session: { sessionId: 'session-123' },
+                contextBookId: 'viz-456'
+              }
+            })
+          }
+        })
+      };
+
+      await apiIntercept.handleInterceptEvent({
+        eventData,
+        executeEvent,
+        viewConfig,
+        getUnsavedAnswerTml
+      });
+
+      expect(executeEvent).toHaveBeenCalledWith(
+        EmbedEvent.ApiIntercept,
+        expect.objectContaining({
+          input: '/prism/?op=GetChartWithData',
+          urlType: InterceptedApiType.AnswerData
+        })
+      );
+    });
+
+    it('should trigger legacy OnBeforeGetVizDataIntercept for answer data URLs', async () => {
+      viewConfig.isOnBeforeGetVizDataInterceptEnabled = true;
+      const eventData = {
+        data: JSON.stringify({
+          input: '/prism/?op=GetChartWithData',
+          init: {
+            method: 'POST',
+            body: JSON.stringify({
+              variables: {
+                session: { sessionId: 'session-123' },
+                contextBookId: 'viz-456'
+              }
+            })
+          }
+        })
+      };
+
+      await apiIntercept.handleInterceptEvent({
+        eventData,
+        executeEvent,
+        viewConfig,
+        getUnsavedAnswerTml
+      });
+
+      expect(getUnsavedAnswerTml).toHaveBeenCalledWith({
+        sessionId: 'session-123',
+        vizId: 'viz-456'
+      });
+
+      expect(executeEvent).toHaveBeenCalledWith(
+        EmbedEvent.OnBeforeGetVizDataIntercept,
+        {
+          data: {
+            data: { answer: { tml: 'test-tml' } },
+            status: embedEventStatus.END,
+            type: EmbedEvent.OnBeforeGetVizDataIntercept
+          }
+        }
+      );
+
+      expect(executeEvent).toHaveBeenCalledWith(
+        EmbedEvent.ApiIntercept,
+        expect.any(Object)
+      );
+    });
+
+    it('should not trigger legacy intercept for non-answer data URLs', async () => {
+      viewConfig.isOnBeforeGetVizDataInterceptEnabled = true;
+      const eventData = {
+        data: JSON.stringify({
+          input: '/prism/?op=LoadContextBook',
+          init: {
+            method: 'POST',
+            body: '{}'
+          }
+        })
+      };
+
+      await apiIntercept.handleInterceptEvent({
+        eventData,
+        executeEvent,
+        viewConfig,
+        getUnsavedAnswerTml
+      });
+
+      expect(getUnsavedAnswerTml).not.toHaveBeenCalled();
+      expect(executeEvent).toHaveBeenCalledTimes(1);
+      expect(executeEvent).toHaveBeenCalledWith(
+        EmbedEvent.ApiIntercept,
+        expect.any(Object)
+      );
+    });
+
+    it('should handle GetTableWithHeadlineData URL as answer data', async () => {
+      viewConfig.isOnBeforeGetVizDataInterceptEnabled = true;
+      const eventData = {
+        data: JSON.stringify({
+          input: '/prism/?op=GetTableWithHeadlineData',
+          init: {
+            body: JSON.stringify({
+              variables: { session: { sessionId: 'test' } }
+            })
+          }
+        })
+      };
+
+      await apiIntercept.handleInterceptEvent({
+        eventData,
+        executeEvent,
+        viewConfig,
+        getUnsavedAnswerTml
+      });
+
+      expect(getUnsavedAnswerTml).toHaveBeenCalled();
+    });
+
+    it('should handle GetTableWithData URL as answer data', async () => {
+      viewConfig.isOnBeforeGetVizDataInterceptEnabled = true;
+      const eventData = {
+        data: JSON.stringify({
+          input: '/prism/?op=GetTableWithData',
+          init: {
+            body: JSON.stringify({
+              variables: { session: { sessionId: 'test' } }
+            })
+          }
+        })
+      };
+
+      await apiIntercept.handleInterceptEvent({
+        eventData,
+        executeEvent,
+        viewConfig,
+        getUnsavedAnswerTml
+      });
+
+      expect(getUnsavedAnswerTml).toHaveBeenCalled();
+    });
+
+    it('should handle invalid JSON in event data', async () => {
+      const eventData = {
+        data: 'invalid-json'
+      };
+
+      await apiIntercept.handleInterceptEvent({
+        eventData,
+        executeEvent,
+        viewConfig,
+        getUnsavedAnswerTml
+      });
+
+      expect(executeEvent).toHaveBeenCalledWith(
+        EmbedEvent.Error,
+        { error: 'Error parsing api intercept body' }
+      );
+      expect(mockLogger.error).toHaveBeenCalled();
+    });
+
+    it('should handle init with non-JSON body', async () => {
+      const eventData = {
+        data: JSON.stringify({
+          input: '/api/test',
+          init: {
+            method: 'POST',
+            body: 'plain-text-body'
+          }
+        })
+      };
+
+      await apiIntercept.handleInterceptEvent({
+        eventData,
+        executeEvent,
+        viewConfig,
+        getUnsavedAnswerTml
+      });
+
+      expect(executeEvent).toHaveBeenCalledWith(
+        EmbedEvent.ApiIntercept,
+        expect.objectContaining({
+          init: expect.objectContaining({
+            body: 'plain-text-body'
+          })
+        })
+      );
+    });
+
+    it('should handle malformed event data structure with property access error', async () => {
+      // Create an object with a getter that throws when accessing 'input'
+      global.JSON.parse = jest.fn().mockImplementationOnce((str) => {
+        // Return an object with a getter that throws
+        return new Proxy({}, {
+          get(target, prop) {
+            if (prop === 'input') {
+              throw new Error('Property access error');
+            }
+            return undefined;
+          }
+        });
+      });
+
+      const eventData = {
+        data: JSON.stringify({ input: '/test', init: {} })
+      };
+
+      await apiIntercept.handleInterceptEvent({
+        eventData,
+        executeEvent,
+        viewConfig,
+        getUnsavedAnswerTml
+      });
+
+      expect(executeEvent).toHaveBeenCalledWith(
+        EmbedEvent.Error,
+        { error: 'Error parsing api intercept body' }
+      );
+      expect(mockLogger.error).toHaveBeenCalled();
+
+      // Explicitly restore for this test
+      global.JSON.parse = originalJsonParse;
+    });
+
+    it('should determine urlType as ALL for unknown URLs', async () => {
+      const eventData = {
+        data: JSON.stringify({
+          input: '/unknown/endpoint',
+          init: { method: 'GET' }
+        })
+      };
+
+      await apiIntercept.handleInterceptEvent({
+        eventData,
+        executeEvent,
+        viewConfig,
+        getUnsavedAnswerTml
+      });
+
+      expect(executeEvent).toHaveBeenCalledWith(
+        EmbedEvent.ApiIntercept,
+        expect.objectContaining({
+          urlType: InterceptedApiType.ALL
+        })
+      );
+    });
+
+    it('should determine urlType as LiveboardData for liveboard URLs', async () => {
+      const eventData = {
+        data: JSON.stringify({
+          input: '/prism/?op=LoadContextBook',
+          init: { method: 'POST' }
+        })
+      };
+
+      await apiIntercept.handleInterceptEvent({
+        eventData,
+        executeEvent,
+        viewConfig,
+        getUnsavedAnswerTml
+      });
+
+      expect(executeEvent).toHaveBeenCalledWith(
+        EmbedEvent.ApiIntercept,
+        expect.objectContaining({
+          urlType: InterceptedApiType.LiveboardData
+        })
+      );
+    });
+
+    it('should handle event data with missing init', async () => {
+      const eventData = {
+        data: JSON.stringify({
+          input: '/prism/?op=GetChartWithData'
+        })
+      };
+
+      await apiIntercept.handleInterceptEvent({
+        eventData,
+        executeEvent,
+        viewConfig,
+        getUnsavedAnswerTml
+      });
+
+      // When init is missing, accessing init.body throws an error
+      expect(executeEvent).toHaveBeenCalledWith(
+        EmbedEvent.Error,
+        { error: 'Error parsing api intercept body' }
+      );
+    });
+
+    it('should handle event data with missing body', async () => {
+      const eventData = {
+        data: JSON.stringify({
+          input: '/prism/?op=GetChartWithData',
+          init: {}
+        })
+      };
+
+      await apiIntercept.handleInterceptEvent({
+        eventData,
+        executeEvent,
+        viewConfig,
+        getUnsavedAnswerTml
+      });
+
+      expect(executeEvent).toHaveBeenCalledWith(
+        EmbedEvent.ApiIntercept,
+        expect.any(Object)
+      );
+    });
+
+    it('should handle event data with missing variables in body', async () => {
+      const eventData = {
+        data: JSON.stringify({
+          input: '/prism/?op=GetChartWithData',
+          init: {
+            body: JSON.stringify({})
+          }
+        })
+      };
+
+      await apiIntercept.handleInterceptEvent({
+        eventData,
+        executeEvent,
+        viewConfig,
+        getUnsavedAnswerTml
+      });
+
+      expect(executeEvent).toHaveBeenCalledWith(
+        EmbedEvent.ApiIntercept,
+        expect.any(Object)
+      );
+    });
+
+    it('should handle event data with missing session in variables', async () => {
+      const eventData = {
+        data: JSON.stringify({
+          input: '/prism/?op=GetChartWithData',
+          init: {
+            body: JSON.stringify({
+              variables: {}
+            })
+          }
+        })
+      };
+
+      await apiIntercept.handleInterceptEvent({
+        eventData,
+        executeEvent,
+        viewConfig,
+        getUnsavedAnswerTml
+      });
+
+      expect(executeEvent).toHaveBeenCalledWith(
+        EmbedEvent.ApiIntercept,
+        expect.any(Object)
+      );
+    });
+  });
+
+  describe('processApiInterceptResponse', () => {
+    it('should process legacy format with error', () => {
+      const legacyPayload = {
+        data: {
+          error: {
+            errorText: 'Test Error',
+            errorDescription: 'Test Description'
+          },
+          execute: false
+        }
+      };
+
+      const result = apiIntercept.processApiInterceptResponse(legacyPayload);
+
+      expect(result).toEqual({
+        data: {
+          execute: false,
+          response: {
+            body: {
+              errors: [
+                {
+                  title: 'Test Error',
+                  description: 'Test Description',
+                  isUserError: true,
+                },
+              ],
+              data: {},
+            },
+          },
+        }
+      });
+    });
+
+    it('should pass through new format unchanged', () => {
+      const newPayload = {
+        execute: true,
+        response: {
+          body: { data: 'test' }
+        }
+      };
+
+      const result = apiIntercept.processApiInterceptResponse(newPayload);
+
+      expect(result).toEqual(newPayload);
+    });
+
+    it('should handle payload without data property', () => {
+      const payload = {
+        execute: true
+      };
+
+      const result = apiIntercept.processApiInterceptResponse(payload);
+
+      expect(result).toEqual(payload);
+    });
+
+    it('should handle payload with data but no error', () => {
+      const payload = {
+        data: {
+          execute: true,
+          someOtherProperty: 'value'
+        }
+      };
+
+      const result = apiIntercept.processApiInterceptResponse(payload);
+
+      expect(result).toEqual(payload);
+    });
+
+    it('should handle null payload', () => {
+      const result = apiIntercept.processApiInterceptResponse(null);
+
+      expect(result).toBeNull();
+    });
+
+    it('should handle undefined payload', () => {
+      const result = apiIntercept.processApiInterceptResponse(undefined);
+
+      expect(result).toBeUndefined();
+    });
+
+    it('should handle payload with null data', () => {
+      const payload: any = {
+        data: null
+      };
+
+      const result = apiIntercept.processApiInterceptResponse(payload);
+
+      expect(result).toEqual(payload);
+    });
+
+    it('should handle payload with data.error set to null', () => {
+      const payload: any = {
+        data: {
+          error: null,
+          execute: true
+        }
+      };
+
+      const result = apiIntercept.processApiInterceptResponse(payload);
+
+      expect(result).toEqual(payload);
+    });
+
+    it('should handle payload with data.error set to undefined', () => {
+      const payload: any = {
+        data: {
+          error: undefined,
+          execute: true
+        }
+      };
+
+      const result = apiIntercept.processApiInterceptResponse(payload);
+
+      expect(result).toEqual(payload);
+    });
+
+    it('should handle payload with data.error set to false', () => {
+      const payload = {
+        data: {
+          error: false,
+          execute: true
+        }
+      };
+
+      const result = apiIntercept.processApiInterceptResponse(payload);
+
+      expect(result).toEqual(payload);
+    });
+
+    it('should handle payload with data.error set to 0', () => {
+      const payload = {
+        data: {
+          error: 0,
+          execute: true
+        }
+      };
+
+      const result = apiIntercept.processApiInterceptResponse(payload);
+
+      expect(result).toEqual(payload);
+    });
+
+    it('should handle payload with data.error set to empty string', () => {
+      const payload = {
+        data: {
+          error: '',
+          execute: true
+        }
+      };
+
+      const result = apiIntercept.processApiInterceptResponse(payload);
+
+      expect(result).toEqual(payload);
+    });
+  });
+
+  describe('processLegacyInterceptResponse', () => {
+    it('should convert legacy error format to new format', () => {
+      const legacyPayload = {
+        data: {
+          error: {
+            errorText: 'Custom Error',
+            errorDescription: 'Custom Description'
+          },
+          execute: false
+        }
+      };
+
+      const result = apiIntercept.processLegacyInterceptResponse(legacyPayload);
+
+      expect(result).toEqual({
+        data: {
+          execute: false,
+          response: {
+            body: {
+              errors: [
+                {
+                  title: 'Custom Error',
+                  description: 'Custom Description',
+                  isUserError: true,
+                },
+              ],
+              data: {},
+            },
+          },
+        }
+      });
+    });
+
+    it('should handle missing error properties', () => {
+      const legacyPayload = {
+        data: {
+          error: {},
+          execute: true
+        }
+      };
+
+      const result = apiIntercept.processLegacyInterceptResponse(legacyPayload);
+
+      expect(result.data.response.body.errors[0]).toEqual({
+        title: undefined,
+        description: undefined,
+        isUserError: true,
+      });
+    });
+
+    it('should handle missing execute property', () => {
+      const legacyPayload = {
+        data: {
+          error: {
+            errorText: 'Error',
+            errorDescription: 'Description'
+          }
+        }
+      };
+
+      const result = apiIntercept.processLegacyInterceptResponse(legacyPayload);
+
+      expect(result.data.execute).toBeUndefined();
+    });
+
+    it('should always include empty data object', () => {
+      const legacyPayload = {
+        data: {
+          error: {
+            errorText: 'Error',
+            errorDescription: 'Description'
+          },
+          execute: false
+        }
+      };
+
+      const result = apiIntercept.processLegacyInterceptResponse(legacyPayload);
+
+      expect(result.data.response.body.data).toEqual({});
+    });
+
+    it('should always set isUserError to true', () => {
+      const legacyPayload = {
+        data: {
+          error: {
+            errorText: 'Error',
+            errorDescription: 'Description'
+          },
+          execute: false
+        }
+      };
+
+      const result = apiIntercept.processLegacyInterceptResponse(legacyPayload);
+
+      expect(result.data.response.body.errors[0].isUserError).toBe(true);
+    });
+
+    it('should handle payload with null data', () => {
+      const legacyPayload: any = {
+        data: null
+      };
+
+      const result = apiIntercept.processLegacyInterceptResponse(legacyPayload);
+
+      expect(result.data.execute).toBeUndefined();
+      expect(result.data.response.body.errors[0].title).toBeUndefined();
+      expect(result.data.response.body.errors[0].description).toBeUndefined();
+    });
+
+    it('should handle payload with null error', () => {
+      const legacyPayload: any = {
+        data: {
+          error: null,
+          execute: true
+        }
+      };
+
+      const result = apiIntercept.processLegacyInterceptResponse(legacyPayload);
+
+      expect(result.data.execute).toBe(true);
+      expect(result.data.response.body.errors[0].title).toBeUndefined();
+      expect(result.data.response.body.errors[0].description).toBeUndefined();
+    });
+
+    it('should handle payload with undefined properties', () => {
+      const legacyPayload = {};
+
+      const result = apiIntercept.processLegacyInterceptResponse(legacyPayload);
+
+      expect(result.data.execute).toBeUndefined();
+      expect(result.data.response.body.errors[0].title).toBeUndefined();
+      expect(result.data.response.body.errors[0].description).toBeUndefined();
+    });
+  });
+});
+