@thoughtspot/ts-chart-sdk 0.0.1-alpha.9 → 0.0.2-alpha.10

package/lib/main/custom-chart-context.spec.js

@@ -4,7 +4,6 @@ import { ChartToTSEvent, ErrorType } from '../types/chart-to-ts-event.types';
 import { TSToChartEvent } from '../types/ts-to-chart-event.types';
 import { CustomChartContext, getChartContext } from './custom-chart-context';
 import * as PostMessageEventBridge from './post-message-event-bridge';
-jest.mock('./post-message-event-bridge');
 jest.spyOn(console, 'log').mockImplementation(() => {
 });
 describe('CustomChartContext', () => {
@@ -20,6 +19,7 @@ describe('CustomChartContext', () => {
         renderChart = jest.fn();
         mockInitMessage.mockImplementation((fn) => {
             eventProcessor = fn;
+            return () => null;
         });
         mockPostMessageToHost.mockImplementation(() => {
             return global.Promise.resolve();
@@ -54,54 +54,90 @@ describe('CustomChartContext', () => {
         test('should return a promise that resolves when the chart context is initialized', async () => {
             expect(mockInitMessage).toHaveBeenCalled();
             const promise = customChartContext.initialize();
-            const mockPostMessage = jest.fn();
-            eventProcessor({
-                data: {
-                    payload: mockInitializeContextPayload,
-                    eventType: TSToChartEvent.Initialize,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
+            const initResp = await eventProcessor({
+                payload: mockInitializeContextPayload,
+                eventType: TSToChartEvent.Initialize,
             });
             eventProcessor({
-                data: {
-                    payload: {},
-                    eventType: TSToChartEvent.InitializeComplete,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
+                payload: {},
+                eventType: TSToChartEvent.InitializeComplete,
             });
             await expect(promise).resolves.toBeUndefined();
-            expect(mockPostMessage).toHaveBeenCalledTimes(2);
-            expect(mockPostMessage.mock.calls[0][0]).toEqual({
+            expect(initResp).toEqual({
                 isConfigValid: false,
                 defaultChartConfig: undefined,
                 chartConfigEditorDefinition: undefined,
                 visualPropEditorDefinition: undefined,
+                allowedConfigurations: {
+                    allowColumnNumberFormatting: false,
+                    allowColumnConditionalFormatting: false,
+                    allowMeasureNamesAndValues: false,
+                },
             });
-            expect(mockPostMessage).toHaveBeenCalled();
             expect(mockPostMessageToHost).not.toHaveBeenCalled();
         });
-        test('multiple intializations should throw an error', async () => {
+        test('type check string for visualProps on initialize payload should not throw an error.', async () => {
+            expect(mockInitMessage).toHaveBeenCalled();
             const promise = customChartContext.initialize();
-            const mockPostMessage = jest.fn();
-            eventProcessor({
-                data: {
-                    payload: mockInitializeContextPayload,
-                    eventType: TSToChartEvent.Initialize,
-                    source: 'ts-host-app',
+            const mockInitializeContextPayloadWithVisualProps = {
+                ...mockInitializeContextPayload,
+                chartModel: {
+                    ...mockInitializeContextPayload.chartModel,
+                    visualProps: 'visualPropStringPayload',
                 },
-                ports: [{ postMessage: mockPostMessage }],
+            };
+            await eventProcessor({
+                payload: mockInitializeContextPayloadWithVisualProps,
+                eventType: TSToChartEvent.Initialize,
             });
             eventProcessor({
-                data: {
-                    payload: {},
-                    eventType: TSToChartEvent.InitializeComplete,
-                    source: 'ts-host-app',
+                payload: {},
+                eventType: TSToChartEvent.InitializeComplete,
+            });
+            await expect(promise).resolves.toBeUndefined();
+            const chartModel = customChartContext.getChartModel();
+            expect(typeof chartModel.visualProps).toEqual('string');
+            expect(chartModel.visualProps).toEqual('visualPropStringPayload');
+            expect(mockPostMessageToHost).not.toHaveBeenCalled();
+        });
+        test('type check object for visualProps on initialize payload should not throw an error.', async () => {
+            expect(mockInitMessage).toHaveBeenCalled();
+            const promise = customChartContext.initialize();
+            const mockInitializeContextPayloadWithVisualProps = {
+                ...mockInitializeContextPayload,
+                chartModel: {
+                    ...mockInitializeContextPayload.chartModel,
+                    visualProps: {
+                        data: 'sample data',
+                    },
                 },
-                ports: [{ postMessage: mockPostMessage }],
+            };
+            await eventProcessor({
+                payload: mockInitializeContextPayloadWithVisualProps,
+                eventType: TSToChartEvent.Initialize,
+            });
+            eventProcessor({
+                payload: {},
+                eventType: TSToChartEvent.InitializeComplete,
             });
             await expect(promise).resolves.toBeUndefined();
+            const chartModel = customChartContext.getChartModel();
+            expect(typeof chartModel.visualProps).toEqual('object');
+            expect(chartModel.visualProps).toEqual({
+                data: 'sample data',
+            });
+            expect(mockPostMessageToHost).not.toHaveBeenCalled();
+        });
+        test('multiple intializations should throw an error', async () => {
+            getChartContext({
+                getDefaultChartConfig,
+                getQueriesFromChartConfig,
+                renderChart,
+            });
+            eventProcessor({
+                payload: {},
+                eventType: TSToChartEvent.InitializeComplete,
+            });
             let error;
             try {
                 customChartContext = new CustomChartContext({
@@ -141,120 +177,169 @@ describe('CustomChartContext', () => {
             customChartContext.destroy();
             eventProcessor = null;
         });
-        test('should not trigger post message if host is not accurate', () => {
-            expect(mockInitMessage).toHaveBeenCalled();
-            const mockPostMessage = jest.fn();
-            eventProcessor({
-                data: {
-                    payload: mockInitializeContextPayload,
-                    eventType: TSToChartEvent.ChartConfigValidate,
-                    source: 'incorrect-source',
+        test('TSToChartEvent.ChartConfigValidate validation response testing', async () => {
+            customChartContext = new CustomChartContext({
+                getDefaultChartConfig,
+                getQueriesFromChartConfig,
+                renderChart,
+                visualPropEditorDefinition: { elements: [] },
+                chartConfigEditorDefinition: [],
+            });
+            const responseWithInitialContext = await eventProcessor({
+                payload: mockInitializeContextPayload,
+                eventType: TSToChartEvent.ChartConfigValidate,
+                source: 'ts-host-app',
+            });
+            expect(responseWithInitialContext).toStrictEqual({
+                isValid: true,
+                visualPropEditorDefinition: { elements: [] },
+                chartConfigEditorDefinition: [],
+            });
+            customChartContext = new CustomChartContext({
+                getDefaultChartConfig,
+                getQueriesFromChartConfig,
+                renderChart,
+                visualPropEditorDefinition: () => {
+                    return { elements: [] };
+                },
+                chartConfigEditorDefinition: () => {
+                    return [
+                        {
+                            key: 'x',
+                            columnSections: [{ label: 'x-axis', key: 'x' }],
+                        },
+                    ];
                 },
-                ports: [{ postMessage: mockPostMessage }],
             });
-            expect(mockPostMessage).not.toHaveBeenCalled();
+            const responseWithUpdatedContext = await eventProcessor({
+                payload: mockInitializeContextPayload,
+                eventType: TSToChartEvent.ChartConfigValidate,
+                source: 'ts-host-app',
+            });
+            expect(responseWithUpdatedContext).toStrictEqual({
+                isValid: true,
+                visualPropEditorDefinition: { elements: [] },
+                chartConfigEditorDefinition: [
+                    {
+                        key: 'x',
+                        columnSections: [{ label: 'x-axis', key: 'x' }],
+                    },
+                ],
+            });
         });
-        test('default internal function testing', () => {
-            expect(mockInitMessage).toHaveBeenCalled();
-            const mockPostMessage = jest.fn();
-            eventProcessor({
-                data: {
-                    payload: mockInitializeContextPayload,
-                    eventType: TSToChartEvent.ChartConfigValidate,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
+        test('TSToChartEvent.validateVisualProps validation response testing', () => {
+            customChartContext = new CustomChartContext({
+                getDefaultChartConfig,
+                getQueriesFromChartConfig,
+                renderChart,
+                visualPropEditorDefinition: { elements: [] },
+                chartConfigEditorDefinition: [],
+            });
+            const responseWithInitialContext = eventProcessor({
+                payload: mockInitializeContextPayload,
+                eventType: TSToChartEvent.VisualPropsValidate,
+                source: 'ts-host-app',
             });
-            expect(mockPostMessage).toHaveBeenCalledWith({
+            expect(responseWithInitialContext).toStrictEqual({
                 isValid: true,
+                visualPropEditorDefinition: { elements: [] },
+                chartConfigEditorDefinition: [],
             });
-            mockPostMessage.mockReset();
-            eventProcessor({
-                data: {
-                    payload: mockInitializeContextPayload,
-                    eventType: TSToChartEvent.VisualPropsValidate,
-                    source: 'ts-host-app',
+            customChartContext = new CustomChartContext({
+                getDefaultChartConfig,
+                getQueriesFromChartConfig,
+                renderChart,
+                visualPropEditorDefinition: () => {
+                    return { elements: [] };
+                },
+                chartConfigEditorDefinition: () => {
+                    return [
+                        {
+                            key: 'x',
+                            columnSections: [{ label: 'x-axis', key: 'x' }],
+                        },
+                    ];
                 },
-                ports: [{ postMessage: mockPostMessage }],
             });
-            expect(mockPostMessage).toHaveBeenCalledWith({
+            const responseWithFunctionReturnedValues = eventProcessor({
+                payload: mockInitializeContextPayload,
+                eventType: TSToChartEvent.VisualPropsValidate,
+                source: 'ts-host-app',
+            });
+            expect(responseWithFunctionReturnedValues).toStrictEqual({
                 isValid: true,
+                visualPropEditorDefinition: { elements: [] },
+                chartConfigEditorDefinition: [
+                    {
+                        key: 'x',
+                        columnSections: [{ label: 'x-axis', key: 'x' }],
+                    },
+                ],
             });
-            mockPostMessage.mockReset();
-            eventProcessor({
-                data: {
-                    payload: mockInitializeContextPayload,
-                    eventType: TSToChartEvent.TriggerRenderChart,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
+        });
+        test('should not trigger post message if host is not accurate', async () => {
+            expect(mockInitMessage).toHaveBeenCalled();
+            const validateChartConfigResp = await eventProcessor({
+                payload: mockInitializeContextPayload,
+                eventType: TSToChartEvent.ChartConfigValidate,
+            });
+            expect(validateChartConfigResp).toEqual({
+                isValid: true,
+            });
+            const validateVisualPropsResp = await eventProcessor({
+                payload: mockInitializeContextPayload,
+                eventType: TSToChartEvent.VisualPropsValidate,
+            });
+            expect(validateVisualPropsResp).toEqual({
+                isValid: true,
+            });
+            const renderResp = await eventProcessor({
+                payload: mockInitializeContextPayload,
+                eventType: TSToChartEvent.TriggerRenderChart,
             });
-            expect(mockPostMessage).toHaveBeenCalledWith({});
             expect(renderChart).toHaveBeenCalled();
-            mockPostMessage.mockReset();
             eventProcessor({
-                data: {
-                    payload: mockInitializeContextPayload,
-                    eventType: TSToChartEvent.GetDataQuery,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
+                payload: mockInitializeContextPayload,
+                eventType: TSToChartEvent.GetDataQuery,
             });
-            expect(mockPostMessage).toHaveBeenCalledWith({});
             expect(getQueriesFromChartConfig).toHaveBeenCalled();
         });
-        test('default external function testing', () => {
+        test('default external function testing', async () => {
             expect(mockInitMessage).toHaveBeenCalled();
-            const mockPostMessage = jest.fn();
-            eventProcessor({
-                data: {
-                    payload: {
-                        data: 'random data',
-                    },
-                    eventType: TSToChartEvent.DataUpdate,
-                    source: 'ts-host-app',
+            const dataUpdateResp = await eventProcessor({
+                payload: {
+                    data: 'random data',
                 },
-                ports: [{ postMessage: mockPostMessage }],
+                eventType: TSToChartEvent.DataUpdate,
             });
-            expect(mockPostMessage).toHaveBeenCalledWith({
+            expect(dataUpdateResp).toEqual({
                 triggerRenderChart: true,
             });
             expect(customChartContext.getChartModel().data).toBe('random data');
-            mockPostMessage.mockReset();
-            eventProcessor({
-                data: {
-                    payload: {
-                        chartModel: {
-                            data: 'random data2',
-                            visualProps: null,
-                        },
+            const modelUpdateResp = await eventProcessor({
+                payload: {
+                    chartModel: {
+                        data: 'random data2',
+                        visualProps: null,
                     },
-                    eventType: TSToChartEvent.ChartModelUpdate,
-                    source: 'ts-host-app',
                 },
-                ports: [{ postMessage: mockPostMessage }],
+                eventType: TSToChartEvent.ChartModelUpdate,
             });
-            expect(mockPostMessage).toHaveBeenCalledWith({
+            expect(modelUpdateResp).toEqual({
                 triggerRenderChart: true,
             });
             expect(customChartContext.getChartModel().data).toBe('random data2');
             expect(customChartContext.getChartModel().visualProps).toBe(null);
-            mockPostMessage.mockReset();
-            eventProcessor({
-                data: {
-                    payload: {
-                        visualProps: 'random data',
-                    },
-                    eventType: TSToChartEvent.VisualPropsUpdate,
-                    source: 'ts-host-app',
+            const visualPropsUpdateResp = await eventProcessor({
+                payload: {
+                    visualProps: 'random data',
                 },
-                ports: [{ postMessage: mockPostMessage }],
+                eventType: TSToChartEvent.VisualPropsUpdate,
             });
-            expect(mockPostMessage).toHaveBeenCalledWith({
+            expect(visualPropsUpdateResp).toEqual({
                 triggerRenderChart: true,
             });
             expect(customChartContext.getChartModel().visualProps).toBe('random data');
-            mockPostMessage.mockReset();
             customChartContext.axisMenuCustomActionPreProcessor([
                 {
                     customActions: [
@@ -267,20 +352,16 @@ describe('CustomChartContext', () => {
                     ],
                 },
             ]);
-            eventProcessor({
-                data: {
-                    payload: {
-                        customAction: {
-                            id: 'custom-action-1',
-                            columnIds: ['9f96b5b0-f7e4-4a5e-aa11-4c77fdf42125'],
-                        },
+            const axisMenuClickResp = await eventProcessor({
+                payload: {
+                    customAction: {
+                        id: 'custom-action-1',
+                        columnIds: ['9f96b5b0-f7e4-4a5e-aa11-4c77fdf42125'],
                     },
-                    eventType: TSToChartEvent.AxisMenuActionClick,
-                    source: 'ts-host-app',
                 },
-                ports: [{ postMessage: mockPostMessage }],
+                eventType: TSToChartEvent.AxisMenuActionClick,
             });
-            expect(mockPostMessage).toHaveBeenCalledWith({
+            expect(axisMenuClickResp).toEqual({
                 isValid: true,
             });
             customChartContext.contextMenuCustomActionPreProcessor([
@@ -295,20 +376,16 @@ describe('CustomChartContext', () => {
                     ],
                 },
             ]);
-            eventProcessor({
-                data: {
-                    payload: {
-                        customAction: {
-                            id: 'custom-action-1',
-                            columnIds: ['9f96b5b0-f7e4-4a5e-aa11-4c77fdf42125'],
-                        },
+            const ctxMenuResp = await eventProcessor({
+                payload: {
+                    customAction: {
+                        id: 'custom-action-1',
+                        columnIds: ['9f96b5b0-f7e4-4a5e-aa11-4c77fdf42125'],
                     },
-                    eventType: TSToChartEvent.ContextMenuActionClick,
-                    source: 'ts-host-app',
                 },
-                ports: [{ postMessage: mockPostMessage }],
+                eventType: TSToChartEvent.ContextMenuActionClick,
             });
-            expect(mockPostMessage).toHaveBeenCalledWith({
+            expect(ctxMenuResp).toEqual({
                 isValid: true,
             });
         });
@@ -317,30 +394,20 @@ describe('CustomChartContext', () => {
             const TEST_EVENT_TYPE = 'testEventType';
             const testCallbackFn = jest.fn();
             customChartContext.on(TEST_EVENT_TYPE, testCallbackFn);
-            const mockPostMessage = jest.fn();
             eventProcessor({
-                data: {
-                    payload: mockInitializeContextPayload,
-                    eventType: TEST_EVENT_TYPE,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
+                payload: mockInitializeContextPayload,
+                eventType: TEST_EVENT_TYPE,
             });
             expect(testCallbackFn).toHaveBeenCalled();
         });
-        test('should respond with an error to an unspecified event type', () => {
+        test('should respond with an error to an unspecified event type', async () => {
             expect(mockInitMessage).toHaveBeenCalled();
             const TEST_EVENT_TYPE = 'testEventType';
-            const mockPostMessage = jest.fn();
-            eventProcessor({
-                data: {
-                    payload: mockInitializeContextPayload,
-                    eventType: TEST_EVENT_TYPE,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
+            const resp = await eventProcessor({
+                payload: mockInitializeContextPayload,
+                eventType: TEST_EVENT_TYPE,
             });
-            expect(mockPostMessage).toHaveBeenCalledWith({
+            expect(resp).toEqual({
                 hasError: true,
                 error: `Event type not recognised or processed: ${TEST_EVENT_TYPE}`,
             });
@@ -364,14 +431,9 @@ describe('CustomChartContext', () => {
             const TEST_EVENT_TYPE = 'testEventType';
             const testCallbackFn = jest.fn();
             customChartContext.on(TEST_EVENT_TYPE, testCallbackFn);
-            const mockPostMessage = jest.fn();
             eventProcessor({
-                data: {
-                    payload: mockInitializeContextPayload,
-                    eventType: TEST_EVENT_TYPE,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
+                payload: mockInitializeContextPayload,
+                eventType: TEST_EVENT_TYPE,
             });
             customChartContext.off(TEST_EVENT_TYPE);
             expect(testCallbackFn).toHaveBeenCalled();
@@ -386,22 +448,13 @@ describe('CustomChartContext', () => {
             customChartContext.on(TEST_EVENT_TYPE_2, testCallbackFn2);
             expect(customChartContext.eventListeners[TEST_EVENT_TYPE_1]).toHaveLength(1);
             expect(customChartContext.eventListeners[TEST_EVENT_TYPE_2]).toHaveLength(1);
-            const mockPostMessage = jest.fn();
             eventProcessor({
-                data: {
-                    payload: {},
-                    eventType: TEST_EVENT_TYPE_1,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
+                payload: {},
+                eventType: TEST_EVENT_TYPE_1,
             });
             eventProcessor({
-                data: {
-                    payload: {},
-                    eventType: TEST_EVENT_TYPE_2,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
+                payload: {},
+                eventType: TEST_EVENT_TYPE_2,
             });
             expect(testCallbackFn1).toHaveBeenCalled();
             expect(testCallbackFn2).toHaveBeenCalled();
@@ -437,26 +490,16 @@ describe('CustomChartContext', () => {
             await expect(result).rejects.toBeDefined();
         });
         test('should resolve the promise if the chart context is initialized', async () => {
-            const mockPostMessage = jest.fn();
             eventProcessor({
-                data: {
-                    payload: mockInitializeContextPayload,
-                    eventType: TSToChartEvent.Initialize,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
+                payload: mockInitializeContextPayload,
+                eventType: TSToChartEvent.Initialize,
             });
             eventProcessor({
-                data: {
-                    payload: {},
-                    eventType: TSToChartEvent.InitializeComplete,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
+                payload: {},
+                eventType: TSToChartEvent.InitializeComplete,
             });
             const promise = customChartContext.initialize();
             await expect(promise).resolves.toBeUndefined();
-            expect(mockPostMessage).toHaveBeenCalledTimes(2);
             let resolve;
             mockPostMessageToHost.mockImplementation(() => new global.Promise((res) => {
                 resolve = res;
@@ -477,24 +520,15 @@ describe('CustomChartContext', () => {
             expect(mockPostMessageToHost).toHaveBeenCalledWith(mockInitializeContextPayload.componentId, mockInitializeContextPayload.hostUrl, null, ChartToTSEvent.RenderStart);
         });
         test('should process the event payload for context menu custom actions', async () => {
-            const mockPostMessage = jest.fn();
             const mockCustomAction = jest.fn();
             let resolve;
             eventProcessor({
-                data: {
-                    payload: mockInitializeContextPayload,
-                    eventType: TSToChartEvent.Initialize,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
+                payload: mockInitializeContextPayload,
+                eventType: TSToChartEvent.Initialize,
             });
             eventProcessor({
-                data: {
-                    payload: {},
-                    eventType: TSToChartEvent.InitializeComplete,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
+                payload: {},
+                eventType: TSToChartEvent.InitializeComplete,
             });
             customChartContext.initialize();
             mockPostMessageToHost.mockImplementation(() => new global.Promise((res) => {
@@ -522,19 +556,15 @@ describe('CustomChartContext', () => {
                 ],
             }, TEST_EVENT_TYPE);
             eventProcessor({
-                data: {
-                    payload: {
-                        customAction: {
-                            id: 'custom-action-1',
-                            clickedPoint: {},
-                            event: {},
-                            selectedPoints: [{}],
-                        },
+                payload: {
+                    customAction: {
+                        id: 'custom-action-1',
+                        clickedPoint: {},
+                        event: {},
+                        selectedPoints: [{}],
                     },
-                    eventType: TSToChartEvent.ContextMenuActionClick,
-                    source: 'ts-host-app',
                 },
-                ports: [{ postMessage: mockPostMessage }],
+                eventType: TSToChartEvent.ContextMenuActionClick,
             });
             expect(mockCustomAction).toHaveBeenCalled();
             expect(mockCustomAction).toHaveBeenCalledWith({
@@ -545,24 +575,15 @@ describe('CustomChartContext', () => {
             });
         });
         test('should process the event payload for axis menu custom actions', async () => {
-            const mockPostMessage = jest.fn();
             const mockCustomAction = jest.fn();
             let resolve;
             eventProcessor({
-                data: {
-                    payload: mockInitializeContextPayload,
-                    eventType: TSToChartEvent.Initialize,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
+                payload: mockInitializeContextPayload,
+                eventType: TSToChartEvent.Initialize,
             });
             eventProcessor({
-                data: {
-                    payload: {},
-                    eventType: TSToChartEvent.InitializeComplete,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
+                payload: {},
+                eventType: TSToChartEvent.InitializeComplete,
             });
             customChartContext.initialize();
             mockPostMessageToHost.mockImplementation(() => new global.Promise((res) => {
@@ -590,18 +611,14 @@ describe('CustomChartContext', () => {
                 ],
             }, TEST_EVENT_TYPE);
             eventProcessor({
-                data: {
-                    payload: {
-                        customAction: {
-                            id: 'custom-action-1',
-                            columnIds: ['123'],
-                            event: {},
-                        },
+                payload: {
+                    customAction: {
+                        id: 'custom-action-1',
+                        columnIds: ['123'],
+                        event: {},
                     },
-                    eventType: TSToChartEvent.AxisMenuActionClick,
-                    source: 'ts-host-app',
                 },
-                ports: [{ postMessage: mockPostMessage }],
+                eventType: TSToChartEvent.AxisMenuActionClick,
             });
             expect(mockCustomAction).toHaveBeenCalled();
             expect(mockCustomAction).toHaveBeenCalledWith({
@@ -611,23 +628,14 @@ describe('CustomChartContext', () => {
             });
         });
         test('should process the event payload for axis menu when custom actions are not defined', async () => {
-            const mockPostMessage = jest.fn();
             let resolve;
             eventProcessor({
-                data: {
-                    payload: mockInitializeContextPayload,
-                    eventType: TSToChartEvent.Initialize,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
+                payload: mockInitializeContextPayload,
+                eventType: TSToChartEvent.Initialize,
             });
             eventProcessor({
-                data: {
-                    payload: {},
-                    eventType: TSToChartEvent.InitializeComplete,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
+                payload: {},
+                eventType: TSToChartEvent.InitializeComplete,
             });
             customChartContext.initialize();
             mockPostMessageToHost.mockImplementation(() => new global.Promise((res) => {
@@ -639,23 +647,14 @@ describe('CustomChartContext', () => {
             expect(mockPostMessageToHost).toHaveBeenCalledWith(mockInitializeContextPayload.componentId, mockInitializeContextPayload.hostUrl, {}, TEST_EVENT_TYPE);
         });
         test('should process the event payload for context menu when custom actions are not defined', async () => {
-            const mockPostMessage = jest.fn();
             let resolve;
             eventProcessor({
-                data: {
-                    payload: mockInitializeContextPayload,
-                    eventType: TSToChartEvent.Initialize,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
+                payload: mockInitializeContextPayload,
+                eventType: TSToChartEvent.Initialize,
             });
             eventProcessor({
-                data: {
-                    payload: {},
-                    eventType: TSToChartEvent.InitializeComplete,
-                    source: 'ts-host-app',
-                },
-                ports: [{ postMessage: mockPostMessage }],
+                payload: {},
+                eventType: TSToChartEvent.InitializeComplete,
             });
             customChartContext.initialize();
             mockPostMessageToHost.mockImplementation(() => new global.Promise((res) => {