@thoughtspot/visual-embed-sdk 1.49.3 → 1.50.1

package/src/embed/hostEventClient/contracts.ts

@@ -7,6 +7,43 @@ export interface LiveboardTab {
   [key: string]: any;
 }
 
+/**
+ * Levels at which a filter or parameter can be applied.
+ */
+export enum ApplicabilityLevel {
+  Liveboard = 'LIVEBOARD',
+  Tab = 'TAB',
+  Group = 'GROUP',
+}
+
+/**
+ * Scopes a filter or parameter to a specific target.
+ * At `LIVEBOARD` level the filter applies to the whole Liveboard, so `targetId`
+ * is not required.
+ */
+export interface Applicability {
+  level: ApplicabilityLevel;
+  targetId?: string;
+}
+
+export interface FilterUpdate {
+  column: string;
+  oper: string;
+  values: string[];
+  type?: string;
+  applicability?: Applicability;
+}
+
+export interface LiveboardFilter {
+  applicability?: Applicability;
+  [key: string]: any;
+}
+
+export interface LiveboardParameter {
+  applicability?: Applicability;
+  [key: string]: any;
+}
+
 export enum UIPassthroughEvent {
   PinAnswerToLiveboard = 'addVizToPinboard',
   SaveAnswer = 'saveAnswer',
@@ -103,7 +140,7 @@ export type UIPassthroughContractBase = {
       vizId?: string;
     };
     response: {
-      liveboardFilters: Record<string, any>[];
+      liveboardFilters: LiveboardFilter[];
       runtimeFilters: RuntimeFilter[];
     };
   };
@@ -116,7 +153,7 @@ export type UIPassthroughContractBase = {
   [UIPassthroughEvent.GetParameters]: {
     request: Record<string, never>;
     response: {
-      parameters: Record<string, any>[];
+      parameters: LiveboardParameter[];
     };
   };
   [UIPassthroughEvent.GetTML]: {
@@ -143,18 +180,8 @@ export type UIPassthroughContractBase = {
   };
   [UIPassthroughEvent.UpdateFilters]: {
     request: {
-      filter?: {
-        column: string;
-        oper: string;
-        values: string[];
-        type?: string;
-      };
-      filters?: {
-        column: string;
-        oper: string;
-        values: string[];
-        type?: string;
-      }[];
+      filter?: FilterUpdate;
+      filters?: FilterUpdate[];
     };
     response: unknown;
   };

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

@@ -311,6 +311,70 @@ 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 throw when DrillDown payload has no valid points', async () => {
             const { client } = createHostEventClient();
             const invalidPayload = {} as any;
@@ -816,4 +880,266 @@ 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();
+        });
+    });
 });

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 {
@@ -58,6 +60,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 +246,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,

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())