@thoughtspot/visual-embed-sdk 1.50.0 → 1.51.0-test

package/src/embed/hostEventClient/host-event-client.spec.ts

@@ -311,6 +311,82 @@ describe('HostEventClient', () => {
             );
         });
 
+        it('should dispatch UpdateParameters over the legacy channel', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            const payload = [
+                { name: 'param1', value: 10, applicability: { level: 'TAB', targetId: 'tab-guid-1' } },
+            ] as any;
+            mockProcessTrigger.mockResolvedValueOnce({ success: true });
+
+            const result = await client.triggerHostEvent(HostEvent.UpdateParameters, payload);
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(1);
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.UpdateParameters,
+                mockThoughtSpotHost,
+                payload,
+                undefined,
+            );
+            expect(result).toEqual({ success: true });
+        });
+
+        it('should forward UpdateParameters with null applicability', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            const payload = [{ name: 'param1', value: 10, applicability: null }] as any;
+            mockProcessTrigger.mockResolvedValueOnce({ success: true });
+
+            await client.triggerHostEvent(HostEvent.UpdateParameters, payload);
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.UpdateParameters,
+                mockThoughtSpotHost,
+                payload,
+                undefined,
+            );
+        });
+
+        it('should throw when UpdateParameters entry has invalid applicability', async () => {
+            const { client } = createHostEventClient();
+            const invalidPayload = [
+                { name: 'param1', value: 10, applicability: { level: 'TAB' } }, // missing targetId
+            ] as any;
+
+            await expect(client.triggerHostEvent(HostEvent.UpdateParameters, invalidPayload))
+                .rejects.toThrow('UpdateParameters received an invalid applicability');
+            expect(mockProcessTrigger).not.toHaveBeenCalled();
+        });
+
+        it('should pass context to UpdateParameters event', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            const payload = [{ name: 'param1', value: 10 }] as any;
+            const context = { vizId: 'viz-1' } as any;
+            mockProcessTrigger.mockResolvedValueOnce({ success: true });
+
+            await client.triggerHostEvent(HostEvent.UpdateParameters, payload, context);
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.UpdateParameters,
+                mockThoughtSpotHost,
+                payload,
+                context,
+            );
+        });
+
+        it('should route GetGroups through passthrough and return data', async () => {
+            const { client } = createHostEventClient();
+            const mockResponse = [{ value: { orderedGroupIds: ['g1', 'g2'], numberOfGroups: 2, Groups: [] as any[] } }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce(mockResponse);
+
+            const result = await client.triggerHostEvent(HostEvent.GetGroups, {});
+
+            expect(result).toEqual({ orderedGroupIds: ['g1', 'g2'], numberOfGroups: 2, Groups: [] });
+        });
+
         it('should throw when DrillDown payload has no valid points', async () => {
             const { client } = createHostEventClient();
             const invalidPayload = {} as any;
@@ -816,4 +892,300 @@ describe('HostEventClient', () => {
             expect(result).toEqual({ ok: true });
         });
     });
+
+    describe('availablePassthroughKeysCache reuse', () => {
+        const allKeys = () => [{ value: { keys: Object.values(UIPassthroughEvent) } }];
+
+        it('GetFilters: second call reuses cache — GetAvailableUIPassthroughs called only once', async () => {
+            const { client } = createHostEventClient();
+            const filterResponse = [{ value: { liveboardFilters: [] as any[], runtimeFilters: [] as any[] } }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce(filterResponse)
+                .mockResolvedValueOnce(filterResponse);
+
+            await client.triggerHostEvent(HostEvent.GetFilters, {});
+            await client.triggerHostEvent(HostEvent.GetFilters, {});
+
+            // 3 calls total: 1 GetAvailableUIPassthroughs + 2 GetFilters
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(3);
+            expect(mockProcessTrigger).not.toHaveBeenNthCalledWith(
+                3,
+                expect.anything(),
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                expect.objectContaining({ type: UIPassthroughEvent.GetAvailableUIPassthroughs }),
+                undefined,
+            );
+        });
+
+        it('GetTabs: second call reuses cache — GetAvailableUIPassthroughs called only once', async () => {
+            const { client } = createHostEventClient();
+            const tabResponse = [{ value: { orderedTabIds: [] as any[], numberOfTabs: 0, Tabs: [] as any[] } }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce(tabResponse)
+                .mockResolvedValueOnce(tabResponse);
+
+            await client.triggerHostEvent(HostEvent.GetTabs, {});
+            await client.triggerHostEvent(HostEvent.GetTabs, {});
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(3);
+        });
+
+        it('GetParameters: second call reuses cache — GetAvailableUIPassthroughs called only once', async () => {
+            const { client } = createHostEventClient();
+            const paramResponse = [{ value: { parameters: [] as any[] } }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce(paramResponse)
+                .mockResolvedValueOnce(paramResponse);
+
+            await client.triggerHostEvent(HostEvent.GetParameters, {});
+            await client.triggerHostEvent(HostEvent.GetParameters, {});
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(3);
+        });
+
+        it('GetAnswerSession: second call reuses cache — GetAvailableUIPassthroughs called only once', async () => {
+            const { client } = createHostEventClient();
+            const sessionResponse = [{ value: { session: 's1' } }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce(sessionResponse)
+                .mockResolvedValueOnce(sessionResponse);
+
+            await client.triggerHostEvent(HostEvent.GetAnswerSession, {});
+            await client.triggerHostEvent(HostEvent.GetAnswerSession, {});
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(3);
+        });
+
+        it('UIPassthrough direct trigger does not populate the cache', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger.mockResolvedValue([{ value: { result: 'ok' } }]);
+
+            await client.triggerHostEvent(HostEvent.UIPassthrough, {});
+            // Cache not populated — next GetFilters call must still fetch keys
+            mockProcessTrigger.mockResolvedValueOnce(allKeys());
+            mockProcessTrigger.mockResolvedValueOnce([{ value: { liveboardFilters: [], runtimeFilters: [] as any[] } }]);
+            await client.triggerHostEvent(HostEvent.GetFilters, {});
+
+            // UIPassthrough call + GetAvailableUIPassthroughs + GetFilters = 3
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(3);
+        });
+
+        it('GetAnswerSession: catch in getAvailableUIPassthroughKeys does not cache, so next call retries GetAvailableUIPassthroughs', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger.mockReset();
+
+            // Flow per triggerHostEvent call when GetAvailableUIPassthroughs rejects:
+            //   1. getAvailableUIPassthroughKeys → processTrigger(UIPassthrough, GetAvailableUIPassthroughs) → rejects → returns []
+            //   2. keys=[] so getDataWithPassthroughFallback is called →
+            //      triggerUIPassthroughApi(GetAnswerSession) → processTrigger(UIPassthrough) → null → hostEventFallback called
+            //   3. hostEventFallback → processTrigger(GetAnswerSession) → legacy result
+
+            // First triggerHostEvent: 3 calls
+            mockProcessTrigger.mockRejectedValueOnce(new Error('network error')); // call 1
+            mockProcessTrigger.mockResolvedValueOnce(null);                       // call 2
+            mockProcessTrigger.mockResolvedValueOnce({ session: 'leg1' });        // call 3
+
+            await client.triggerHostEvent(HostEvent.GetAnswerSession, { vizId: '1' });
+
+            // Second triggerHostEvent: cache was NOT set, so GetAvailableUIPassthroughs is retried: 3 more calls
+            mockProcessTrigger.mockRejectedValueOnce(new Error('network error')); // call 4
+            mockProcessTrigger.mockResolvedValueOnce(null);                       // call 5
+            mockProcessTrigger.mockResolvedValueOnce({ session: 'leg2' });        // call 6
+
+            await client.triggerHostEvent(HostEvent.GetAnswerSession, { vizId: '2' });
+
+            // 6 total calls: GetAvailableUIPassthroughs was called TWICE (cache not set after catch)
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(6);
+            const availableCallsCount = mockProcessTrigger.mock.calls.filter(
+                (call) => call[3]?.type === UIPassthroughEvent.GetAvailableUIPassthroughs,
+            ).length;
+            expect(availableCallsCount).toBe(2);
+        });
+    });
+
+    describe('GetTML edge cases', () => {
+        const allKeys = () => [{ value: { keys: Object.values(UIPassthroughEvent) } }];
+
+        it('includeNonExecutedSearchTokens flag is forwarded in UIPassthrough parameters', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce([{ value: { tml: 'data' } }]);
+
+            await client.triggerHostEvent(HostEvent.GetTML, { includeNonExecutedSearchTokens: true } as any);
+
+            expect(mockProcessTrigger).toHaveBeenNthCalledWith(
+                2,
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                {
+                    type: UIPassthroughEvent.GetTML,
+                    parameters: { includeNonExecutedSearchTokens: true },
+                },
+                undefined,
+            );
+        });
+
+        it('value.error (singular) throws — distinct from value.errors', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce([{ value: { error: 'TML fetch failed' } }]);
+
+            await expect(client.triggerHostEvent(HostEvent.GetTML, {}))
+                .rejects.toThrow('TML fetch failed');
+        });
+
+        it('GetTML key absent from non-empty keys array falls back to legacy hostEventFallback', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            // Return keys that do NOT include GetTML
+            mockProcessTrigger
+                .mockResolvedValueOnce([{ value: { keys: [UIPassthroughEvent.GetFilters] } }])
+                .mockResolvedValueOnce({ answer: { search_query: 'revenue' } });
+
+            const result = await client.triggerHostEvent(HostEvent.GetTML, {});
+
+            expect(mockProcessTrigger).toHaveBeenNthCalledWith(
+                2,
+                mockIframe,
+                HostEvent.GetTML,
+                mockThoughtSpotHost,
+                {},
+                undefined,
+            );
+            expect(result).toEqual({ answer: { search_query: 'revenue' } });
+        });
+    });
+
+    describe('SaveAnswer key-presence edge cases', () => {
+        const allKeys = () => [{ value: { keys: Object.values(UIPassthroughEvent) } }];
+        const saveResponse = [{
+            value: {
+                saveResponse: {
+                    data: {
+                        Answer__save: {
+                            answer: { id: 'ans123' },
+                        },
+                    },
+                },
+            },
+            refId: 'viz1',
+        }];
+
+        it('name+description both empty string route through passthrough, not Save fallback', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce(saveResponse);
+
+            await client.triggerHostEvent(HostEvent.SaveAnswer, { name: '', description: '' } as any);
+
+            expect(mockProcessTrigger).toHaveBeenNthCalledWith(
+                2,
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                { type: UIPassthroughEvent.SaveAnswer, parameters: { name: '', description: '' } },
+                undefined,
+            );
+        });
+
+        it('description: undefined (key present) routes through passthrough, not Save fallback', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce(saveResponse);
+
+            await client.triggerHostEvent(HostEvent.SaveAnswer, { name: 'Test', description: undefined } as any);
+
+            expect(mockProcessTrigger).toHaveBeenNthCalledWith(
+                2,
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                { type: UIPassthroughEvent.SaveAnswer, parameters: { name: 'Test', description: undefined } },
+                undefined,
+            );
+        });
+
+        it('name key absent falls back to HostEvent.Save', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce([saveResponse[0].value]);
+
+            await client.triggerHostEvent(HostEvent.SaveAnswer, { description: 'desc only' } as any);
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.Save,
+                mockThoughtSpotHost,
+                { description: 'desc only' },
+                undefined,
+            );
+        });
+
+        it('answerId is undefined when saveResponse.data.Answer__save.answer.id is missing', async () => {
+            const { client } = createHostEventClient();
+            const noIdSaveResponse = [{
+                value: {
+                    saveResponse: {
+                        data: {
+                            Answer__save: {
+                                answer: {},
+                            },
+                        },
+                    },
+                },
+                refId: 'viz1',
+            }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce(noIdSaveResponse);
+
+            const result = await client.triggerHostEvent(HostEvent.SaveAnswer, { name: 'Test', description: 'Desc' } as any);
+
+            expect(result.answerId).toBeUndefined();
+        });
+    });
+
+    describe('trigger typing contracts (compile-time)', () => {
+        // These assertions are enforced by ts-jest at compile time; the runtime
+        // expect() is trivial. They lock the PayloadT default on
+        // triggerHostEvent: no-payload calls must infer the contract response
+        // instead of collapsing to `any`.
+        type IsAny<T> = 0 extends 1 & T ? true : false;
+        type Extends<A, B> = A extends B ? true : false;
+
+        it('infers typed response for no-payload contracted events and keeps any for uncontracted', () => {
+            const { client } = createHostEventClient();
+
+            // Contracted event, called with no payload — the fixed case.
+            const getTabs = () => client.triggerHostEvent(HostEvent.GetTabs);
+            type TabsResponse = Awaited<ReturnType<typeof getTabs>>;
+            const tabsIsTyped: IsAny<TabsResponse> = false;
+            const tabsHasContractFields: Extends<
+                TabsResponse,
+                { numberOfTabs: number; orderedTabIds: string[] }
+            > = true;
+            const probeUnknownField = (r: TabsResponse) =>
+                // @ts-expect-error — field not on the GetTabs contract (was silent when `any`)
+                r.tabCount;
+            void probeUnknownField;
+
+            // Uncontracted event — must remain `any` with or without payload.
+            const reload = () => client.triggerHostEvent(HostEvent.Reload);
+            type ReloadResponse = Awaited<ReturnType<typeof reload>>;
+            const reloadStaysAny: IsAny<ReloadResponse> = true;
+
+            expect([tabsIsTyped, tabsHasContractFields, reloadStaysAny])
+                .toEqual([false, true, true]);
+        });
+    });
 });

package/src/embed/hostEventClient/host-event-client.ts

@@ -3,8 +3,10 @@ import { processTrigger as processTriggerService } from '../../utils/processTrig
 import { getEmbedConfig } from '../embedConfig';
 import {
     isValidUpdateFiltersPayload,
+    isValidUpdateParametersPayload,
     isValidDrillDownPayload,
     throwUpdateFiltersValidationError,
+    throwUpdateParametersValidationError,
     throwDrillDownValidationError,
 } from './utils';
 import {
@@ -36,6 +38,7 @@ const PASSTHROUGH_MAP: Partial<Record<HostEvent, UIPassthroughEvent>> = {
     [HostEvent.GetParameters]: UIPassthroughEvent.GetParameters,
     [HostEvent.GetTML]: UIPassthroughEvent.GetTML,
     [HostEvent.GetTabs]: UIPassthroughEvent.GetTabs,
+    [HostEvent.GetGroups]: UIPassthroughEvent.GetGroups,
     [HostEvent.getExportRequestForCurrentPinboard]: UIPassthroughEvent.GetExportRequestForCurrentPinboard,
 };
 
@@ -58,6 +61,7 @@ export class HostEventClient {
           [HostEvent.Pin]: (p, c) => this.handlePinEvent(p, c),
           [HostEvent.SaveAnswer]: (p, c) => this.handleSaveAnswerEvent(p, c),
           [HostEvent.UpdateFilters]: (p, c) => this.handleUpdateFiltersEvent(p, c),
+          [HostEvent.UpdateParameters]: (p, c) => this.handleUpdateParametersEvent(p, c),
           [HostEvent.DrillDown]: (p, c) => this.handleDrillDownEvent(p, c),
       };
   }
@@ -243,6 +247,18 @@ export class HostEventClient {
     return this.handleHostEventWithParam(UIPassthroughEvent.UpdateFilters, payload, context as ContextType);
   }
 
+  protected handleUpdateParametersEvent(
+    payload: HostEventRequest<HostEvent.UpdateParameters>,
+    context?: ContextType,
+  ): Promise<any> {
+    if (!isValidUpdateParametersPayload(payload)) {
+      throwUpdateParametersValidationError();
+    }
+
+    // UpdateParameters has no UI passthrough contract; dispatch over the legacy channel
+    return this.hostEventFallback(HostEvent.UpdateParameters, payload, context);
+  }
+
   protected handleDrillDownEvent(
     payload: HostEventRequest<HostEvent.DrillDown>,
     context?: ContextType,
@@ -265,8 +281,8 @@ export class HostEventClient {
    */
   public async triggerHostEvent<
     HostEventT extends HostEvent,
-    PayloadT,
-    ContextT extends ContextType,
+    PayloadT = HostEventRequest<HostEventT>,
+    ContextT extends ContextType = ContextType,
   >(
       hostEvent: HostEventT,
       payload?: TriggerPayload<PayloadT, HostEventT>,

package/src/embed/hostEventClient/utils.spec.ts

@@ -1,8 +1,10 @@
 import {
     isValidUpdateFiltersPayload,
+    isValidUpdateParametersPayload,
     isValidDrillDownPayload,
     createValidationError,
     throwUpdateFiltersValidationError,
+    throwUpdateParametersValidationError,
     throwDrillDownValidationError,
 } from './utils';
 import { ERROR_MESSAGE } from '../../errors';
@@ -114,6 +116,201 @@ describe('hostEventClient utils', () => {
                 filters: [{ column: 'y' }], // invalid
             } as any)).toBe(true);
         });
+
+        it('returns true for filter without applicability', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: { column: 'x', oper: 'EQ', values: ['a'] },
+            } as any)).toBe(true);
+        });
+
+        it('returns true for filter with valid applicability', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: {
+                    column: 'x',
+                    oper: 'EQ',
+                    values: ['a'],
+                    applicability: { level: 'TAB', targetId: 'tab-guid-1' },
+                },
+            } as any)).toBe(true);
+        });
+
+        it('returns true for filters array with applicability on some filters', () => {
+            expect(isValidUpdateFiltersPayload({
+                filters: [
+                    {
+                        column: 'x',
+                        oper: 'IN',
+                        values: ['a', 'b'],
+                        applicability: { level: 'TAB', targetId: 'tab-guid-1' },
+                    },
+                    { column: 'y', oper: 'EQ', values: ['c'] },
+                ],
+            } as any)).toBe(true);
+        });
+
+        it('returns false for applicability missing targetId', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: {
+                    column: 'x',
+                    oper: 'EQ',
+                    values: ['a'],
+                    applicability: { level: 'TAB' },
+                },
+            } as any)).toBe(false);
+        });
+
+        it('returns false for applicability with empty targetId', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: {
+                    column: 'x',
+                    oper: 'EQ',
+                    values: ['a'],
+                    applicability: { level: 'TAB', targetId: '' },
+                },
+            } as any)).toBe(false);
+        });
+
+        it('returns false for null applicability', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: {
+                    column: 'x',
+                    oper: 'EQ',
+                    values: ['a'],
+                    applicability: null,
+                },
+            } as any)).toBe(false);
+        });
+
+        it('returns false for non-object applicability', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: {
+                    column: 'x',
+                    oper: 'EQ',
+                    values: ['a'],
+                    applicability: 'TAB',
+                },
+            } as any)).toBe(false);
+        });
+
+        it('returns true for LIVEBOARD level applicability without targetId', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: {
+                    column: 'x',
+                    oper: 'EQ',
+                    values: ['a'],
+                    applicability: { level: 'LIVEBOARD' },
+                },
+            } as any)).toBe(true);
+        });
+
+        it('returns false for applicability missing level', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: {
+                    column: 'x',
+                    oper: 'EQ',
+                    values: ['a'],
+                    applicability: { targetId: 'tab-guid-1' },
+                },
+            } as any)).toBe(false);
+        });
+
+        it('returns false for applicability with non-string level', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: {
+                    column: 'x',
+                    oper: 'EQ',
+                    values: ['a'],
+                    applicability: { level: 123, targetId: 'tab-guid-1' },
+                },
+            } as any)).toBe(false);
+        });
+
+        it('returns false if one filter in filters array has invalid applicability', () => {
+            expect(isValidUpdateFiltersPayload({
+                filters: [
+                    { column: 'x', oper: 'EQ', values: ['a'] },
+                    {
+                        column: 'y',
+                        oper: 'EQ',
+                        values: ['b'],
+                        applicability: { level: 'TAB' }, // missing targetId
+                    },
+                ],
+            } as any)).toBe(false);
+        });
+    });
+
+    // =========================
+    // UpdateParameters Validation
+    // =========================
+    describe('isValidUpdateParametersPayload', () => {
+        it('returns true for undefined payload', () => {
+            expect(isValidUpdateParametersPayload(undefined)).toBe(true);
+        });
+
+        it('returns true for non-array payload', () => {
+            expect(isValidUpdateParametersPayload({ name: 'p', value: 1 })).toBe(true);
+        });
+
+        it('returns true for parameters without applicability', () => {
+            expect(isValidUpdateParametersPayload([
+                { name: 'p1', value: 1 },
+                { name: 'p2', value: 'a' },
+            ])).toBe(true);
+        });
+
+        it('returns true for null applicability', () => {
+            expect(isValidUpdateParametersPayload([
+                { name: 'p', value: 1, applicability: null },
+            ])).toBe(true);
+        });
+
+        it('returns true for valid TAB applicability with targetId', () => {
+            expect(isValidUpdateParametersPayload([
+                { name: 'p', value: 1, applicability: { level: 'TAB', targetId: 'tab-guid-1' } },
+            ])).toBe(true);
+        });
+
+        it('returns true for LIVEBOARD level applicability without targetId', () => {
+            expect(isValidUpdateParametersPayload([
+                { name: 'p', value: 1, applicability: { level: 'LIVEBOARD' } },
+            ])).toBe(true);
+        });
+
+        it('returns false for applicability missing targetId', () => {
+            expect(isValidUpdateParametersPayload([
+                { name: 'p', value: 1, applicability: { level: 'TAB' } },
+            ])).toBe(false);
+        });
+
+        it('returns false for applicability with empty targetId', () => {
+            expect(isValidUpdateParametersPayload([
+                { name: 'p', value: 1, applicability: { level: 'GROUP', targetId: ' ' } },
+            ])).toBe(false);
+        });
+
+        it('returns false for applicability with invalid level', () => {
+            expect(isValidUpdateParametersPayload([
+                { name: 'p', value: 1, applicability: { level: 'VIZ', targetId: 'guid-1' } },
+            ])).toBe(false);
+        });
+
+        it('returns false for non-object applicability', () => {
+            expect(isValidUpdateParametersPayload([
+                { name: 'p', value: 1, applicability: 'TAB' },
+            ])).toBe(false);
+        });
+
+        it('returns false if one parameter has invalid applicability', () => {
+            expect(isValidUpdateParametersPayload([
+                { name: 'p1', value: 1 },
+                { name: 'p2', value: 2, applicability: { level: 'GROUP' } }, // missing targetId
+            ])).toBe(false);
+        });
+
+        it('returns true for non-object entries', () => {
+            expect(isValidUpdateParametersPayload(['p', 1, null])).toBe(true);
+        });
     });
 
     // =========================
@@ -216,6 +413,13 @@ describe('hostEventClient utils', () => {
         });
     });
 
+    describe('throwUpdateParametersValidationError', () => {
+        it('throws with UPDATEPARAMETERS_INVALID_PAYLOAD message', () => {
+            expect(() => throwUpdateParametersValidationError())
+                .toThrow(ERROR_MESSAGE.UPDATEPARAMETERS_INVALID_PAYLOAD);
+        });
+    });
+
     describe('throwDrillDownValidationError', () => {
         it('throws with DRILLDOWN_INVALID_PAYLOAD message', () => {
             expect(() => throwDrillDownValidationError())