@webex/plugin-meetings 3.11.0 → 3.12.0-mobius-socket.2

package/test/unit/spec/webinar/index.ts

@@ -1,9 +1,11 @@
-import {assert, expect} from '@webex/test-helper-chai';
+import {assert} from '@webex/test-helper-chai';
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
 import Webinar from '@webex/plugin-meetings/src/webinar';
 import MockWebex from '@webex/test-helper-mock-webex';
 import uuid from 'uuid';
 import sinon from 'sinon';
+import {DataChannelTokenType} from '@webex/internal-plugin-llm';
+import {LLM_PRACTICE_SESSION, SHARE_STATUS} from '@webex/plugin-meetings/src/constants';
 
 describe('plugin-meetings', () => {
     describe('Webinar', () => {
@@ -26,7 +28,20 @@ describe('plugin-meetings', () => {
             webex.meetings = {};
             webex.credentials.getUserToken = getUserTokenStub;
             webex.meetings.getMeetingByType = sinon.stub();
-
+            webex.internal.voicea.announce = sinon.stub();
+
+      webex.internal.llm = {
+        getDatachannelToken: sinon.stub().returns(undefined),
+        setDatachannelToken: sinon.stub(),
+        isDataChannelTokenEnabled: sinon.stub().resolves(false),
+        isConnected: sinon.stub().returns(false),
+        disconnectLLM: sinon.stub().resolves(),
+        off: sinon.stub(),
+        on: sinon.stub(),
+        getLocusUrl: sinon.stub().returns('old-locus-url'),
+        getDatachannelUrl: sinon.stub().returns('old-dc-url'),
+        registerAndConnect: sinon.stub().resolves('REGISTER_AND_CONNECT_RESULT'),
+      };
         });
 
         afterEach(() => {
@@ -147,20 +162,399 @@ describe('plugin-meetings', () => {
           assert.equal(result.isPromoted, false, 'should not indicate promotion');
           assert.equal(result.isDemoted, false, 'should not indicate demotion');
         });
+
+      it('handles missing role payload safely', () => {
+        const updateStatusByRoleStub = sinon.stub(webinar, 'updateStatusByRole');
+
+        const result = webinar.updateRoleChanged(undefined);
+
+        assert.equal(webinar.selfIsPanelist, false);
+        assert.equal(webinar.selfIsAttendee, false);
+        assert.equal(webinar.canManageWebcast, false);
+        assert.deepEqual(result, {isPromoted: false, isDemoted: false});
+        assert.calledOnceWithExactly(updateStatusByRoleStub, {isPromoted: false, isDemoted: false});
+      });
+    });
+
+    describe('#cleanUp', () => {
+      it('delegates to cleanupPSDataChannel', () => {
+        const cleanupPSDataChannelStub = sinon.stub(webinar, 'cleanupPSDataChannel').resolves();
+
+        webinar.cleanUp();
+
+        assert.calledOnceWithExactly(cleanupPSDataChannelStub);
+      });
+    });
+
+    describe('#cleanupPSDataChannel', () => {
+      let meeting;
+
+      beforeEach(() => {
+        meeting = {
+          processRelayEvent: sinon.stub(),
+        };
+
+        webex.meetings.getMeetingByType = sinon.stub().returns(meeting);
+      });
+
+      it('disconnects the practice session channel and removes the relay listener', async () => {
+        await webinar.cleanupPSDataChannel();
+
+        assert.calledOnceWithExactly(
+          webex.internal.llm.disconnectLLM,
+          {code: 3050, reason: 'done (permanent)'},
+          LLM_PRACTICE_SESSION
+        );
+        assert.calledOnceWithExactly(
+          webex.internal.llm.off,
+          `event:relay.event:${LLM_PRACTICE_SESSION}`,
+          meeting.processRelayEvent
+        );
+      });
+
+      it('removes a pending online listener if one exists', async () => {
+        const listener = sinon.stub();
+        webinar._pendingOnlineListener = listener;
+
+        await webinar.cleanupPSDataChannel();
+
+        assert.calledWith(webex.internal.llm.off, 'online', listener);
+        assert.isNull(webinar._pendingOnlineListener);
+      });
+
+      it('skips online listener removal when none is pending', async () => {
+        webinar._pendingOnlineListener = null;
+
+        await webinar.cleanupPSDataChannel();
+
+        // 'off' should only be called for the relay event, not for 'online'
+        const onlineOffCalls = webex.internal.llm.off.args.filter(([event]) => event === 'online');
+        assert.equal(onlineOffCalls.length, 0);
+      });
+    });
+
+    describe('#updatePSDataChannel', () => {
+      let meeting;
+      let processRelayEvent;
+
+      beforeEach(() => {
+        processRelayEvent = sinon.stub();
+        meeting = {
+          isJoined: sinon.stub().returns(true),
+          processRelayEvent,
+          locusInfo: {
+            url: 'locus-url',
+            info: {practiceSessionDatachannelUrl: 'dc-url'},
+          },
+        };
+
+        webex.meetings.getMeetingByType = sinon.stub().returns(meeting);
+
+        // Default session is connected by default; practice session is not
+        webex.internal.llm.isConnected = sinon.stub().callsFake((sessionId) => {
+          return sessionId !== LLM_PRACTICE_SESSION;
+        });
+
+        // Token is pre-saved into LLM by saveDataChannelToken
+        webex.internal.llm.getDatachannelToken = sinon.stub().callsFake((tokenType) => {
+          if (tokenType === DataChannelTokenType.PracticeSession) return 'ps-token';
+          return undefined;
+        });
+
+        // Ensure connect path is eligible
+        webinar.selfIsPanelist = true;
+        webinar.practiceSessionEnabled = true;
+        webex.internal.voicea.getIsCaptionBoxOn = sinon.stub().returns(false);
+        webex.internal.voicea.updateSubchannelSubscriptions = sinon.stub();
+      });
+
+      it('refreshes practice-session token before register when cached token is missing', async () => {
+        webex.internal.llm.isDataChannelTokenEnabled.resolves(true);
+        webex.internal.llm.getDatachannelToken = sinon.stub().callsFake((tokenType) => {
+          if (tokenType === DataChannelTokenType.PracticeSession) return undefined;
+
+          return undefined;
+        });
+        meeting.refreshDataChannelToken = sinon.stub().resolves({
+          body: {
+            datachannelToken: 'ps-token-from-refresh',
+            dataChannelTokenType: DataChannelTokenType.PracticeSession,
+          },
+        });
+
+        await webinar.updatePSDataChannel();
+
+        assert.calledOnceWithExactly(meeting.refreshDataChannelToken);
+        assert.calledWithExactly(
+          webex.internal.llm.setDatachannelToken,
+          'ps-token-from-refresh',
+          DataChannelTokenType.PracticeSession
+        );
+        assert.calledWith(
+          webex.internal.llm.registerAndConnect,
+          'locus-url',
+          'dc-url',
+          'ps-token-from-refresh',
+          LLM_PRACTICE_SESSION
+        );
+      });
+
+      it('does not reconnect if practice-session eligibility changes during async token refresh', async () => {
+        webex.internal.llm.isDataChannelTokenEnabled.resolves(true);
+        webex.internal.llm.getDatachannelToken = sinon.stub().returns(undefined);
+
+        let resolveRefresh;
+        meeting.refreshDataChannelToken = sinon.stub().returns(
+          new Promise((resolve) => {
+            resolveRefresh = resolve;
+          })
+        );
+
+        const updatePromise = webinar.updatePSDataChannel();
+
+        webinar.practiceSessionEnabled = false;
+
+        resolveRefresh({
+          body: {
+            datachannelToken: 'stale-ps-token',
+            dataChannelTokenType: DataChannelTokenType.PracticeSession,
+          },
+        });
+
+        const result = await updatePromise;
+
+        assert.isUndefined(result);
+        assert.notCalled(webex.internal.llm.registerAndConnect);
+      });
+
+      it('no-ops when practice session join eligibility is false', async () => {
+        webinar.practiceSessionEnabled = false;
+        const cleanupPSDataChannelStub = sinon.stub(webinar, 'cleanupPSDataChannel').resolves();
+
+        const result = await webinar.updatePSDataChannel();
+
+        assert.isUndefined(result);
+        assert.calledOnceWithExactly(cleanupPSDataChannelStub);
+        assert.notCalled(webex.internal.llm.registerAndConnect);
+      });
+
+      it('no-ops when meeting is not joined', async () => {
+        meeting.isJoined.returns(false);
+        const cleanupPSDataChannelStub = sinon.stub(webinar, 'cleanupPSDataChannel').resolves();
+
+        const result = await webinar.updatePSDataChannel();
+
+        assert.isUndefined(result);
+        assert.calledOnceWithExactly(cleanupPSDataChannelStub);
+        assert.notCalled(webex.internal.llm.registerAndConnect);
+      });
+
+      it('no-ops when practiceSessionDatachannelUrl is missing', async () => {
+        meeting.locusInfo.info.practiceSessionDatachannelUrl = undefined;
+
+        const result = await webinar.updatePSDataChannel();
+
+        assert.isUndefined(result);
+        assert.notCalled(webex.internal.llm.registerAndConnect);
+      });
+
+      it('no-ops when already connected to the same endpoints', async () => {
+        webex.internal.llm.isConnected.returns(true);
+        webex.internal.llm.getLocusUrl.returns('locus-url');
+        webex.internal.llm.getDatachannelUrl.returns('dc-url');
+        const cleanupPSDataChannelStub = sinon.stub(webinar, 'cleanupPSDataChannel').resolves();
+
+        const result = await webinar.updatePSDataChannel();
+
+        assert.isUndefined(result);
+        assert.notCalled(cleanupPSDataChannelStub);
+        assert.notCalled(webex.internal.llm.registerAndConnect);
+      });
+
+      it('connects when eligible', async () => {
+        const result = await webinar.updatePSDataChannel();
+
+        assert.calledOnce(webex.internal.llm.registerAndConnect);
+        assert.calledWith(
+          webex.internal.llm.registerAndConnect,
+          'locus-url',
+          'dc-url',
+          'ps-token',
+          LLM_PRACTICE_SESSION
+        );
+        assert.calledOnceWithExactly(webex.internal.voicea.announce);
+        assert.equal(result, 'REGISTER_AND_CONNECT_RESULT');
+      });
+
+      it('uses token from LLM', async () => {
+        webex.internal.llm.getDatachannelToken = sinon.stub().callsFake((tokenType) => {
+          if (tokenType === DataChannelTokenType.PracticeSession) return 'cached-token';
+          return undefined;
+        });
+
+        await webinar.updatePSDataChannel();
+
+        assert.calledWithExactly(
+          webex.internal.llm.getDatachannelToken,
+          DataChannelTokenType.PracticeSession
+        );
+        assert.notCalled(webex.internal.llm.setDatachannelToken);
+        assert.calledWith(
+          webex.internal.llm.registerAndConnect,
+          'locus-url',
+          'dc-url',
+          'cached-token',
+          LLM_PRACTICE_SESSION
+        );
+      });
+
+      it('cleans up the existing practice session channel before reconnecting to new endpoints', async () => {
+        webex.internal.llm.isConnected.returns(true);
+        const cleanupPSDataChannelStub = sinon.stub(webinar, 'cleanupPSDataChannel').resolves();
+
+        await webinar.updatePSDataChannel();
+
+        assert.calledOnceWithExactly(cleanupPSDataChannelStub);
+        assert.calledOnce(webex.internal.llm.registerAndConnect);
+      });
+
+      it('rebinds relay listener after successful connect', async () => {
+        await webinar.updatePSDataChannel();
+
+        assert.calledWith(
+          webex.internal.llm.off,
+          `event:relay.event:${LLM_PRACTICE_SESSION}`,
+          processRelayEvent
+        );
+        assert.calledWith(
+          webex.internal.llm.on,
+          `event:relay.event:${LLM_PRACTICE_SESSION}`,
+          processRelayEvent
+        );
+      });
+
+      it('subscribes to transcription when caption intent is enabled', async () => {
+        webex.internal.voicea.getIsCaptionBoxOn = sinon.stub().returns(true);
+
+        await webinar.updatePSDataChannel();
+
+        assert.calledOnceWithExactly(webex.internal.voicea.updateSubchannelSubscriptions, { subscribe: ['transcription'] });
+      });
+
+      it('does not subscribe to transcription when caption intent is disabled', async () => {
+        webex.internal.voicea.getIsCaptionBoxOn = sinon.stub().returns(false);
+
+        await webinar.updatePSDataChannel();
+
+        assert.notCalled(webex.internal.voicea.updateSubchannelSubscriptions);
+      });
+
+      it('defers connect when default session is not yet connected', async () => {
+        // Default session is not connected initially
+        webex.internal.llm.isConnected = sinon.stub().returns(false);
+
+        const result = await webinar.updatePSDataChannel();
+
+        // Should return undefined immediately (deferred)
+        assert.isUndefined(result);
+        // Should register an 'online' listener but NOT call registerAndConnect yet
+        assert.calledWith(webex.internal.llm.on, 'online', sinon.match.func);
+        assert.notCalled(webex.internal.llm.registerAndConnect);
+        // Should store the pending listener
+        assert.isNotNull(webinar._pendingOnlineListener);
+      });
+
+      it('does not register duplicate online listeners on repeated calls', async () => {
+        webex.internal.llm.isConnected = sinon.stub().returns(false);
+
+        await webinar.updatePSDataChannel();
+        await webinar.updatePSDataChannel();
+        await webinar.updatePSDataChannel();
+
+        // Only one 'online' listener should have been registered
+        const onlineCalls = webex.internal.llm.on.args.filter(([event]) => event === 'online');
+        assert.equal(onlineCalls.length, 1, 'should register exactly one online listener');
+      });
+
+      it('re-invokes updatePSDataChannel when default session comes online', async () => {
+        // Default session is not connected initially
+        webex.internal.llm.isConnected = sinon.stub().returns(false);
+
+        const updatePSDataChannelSpy = sinon.spy(webinar, 'updatePSDataChannel');
+
+        // First call defers
+        await webinar.updatePSDataChannel();
+
+        // Capture the 'online' listener
+        const onlineCall = webex.internal.llm.on.args.find(([event]) => event === 'online');
+        assert.isDefined(onlineCall, 'should have registered an online listener');
+
+        // Now simulate default session coming online
+        webex.internal.llm.isConnected = sinon.stub().callsFake((sessionId) => {
+          return sessionId !== LLM_PRACTICE_SESSION;
+        });
+
+        // Fire the captured listener
+        onlineCall[1]();
+
+        // The listener should have cleared itself, removed itself, and re-called updatePSDataChannel
+        assert.isNull(webinar._pendingOnlineListener);
+        assert.calledWith(webex.internal.llm.off, 'online', sinon.match.func);
+        assert.equal(updatePSDataChannelSpy.callCount, 2);
+      });
+
+      it('does not reconnect with stale data if demoted before default session comes online', async () => {
+        // Default session is not connected initially
+        webex.internal.llm.isConnected = sinon.stub().returns(false);
+
+        await webinar.updatePSDataChannel();
+
+        // Capture the 'online' listener
+        const onlineCall = webex.internal.llm.on.args.find(([event]) => event === 'online');
+        assert.isDefined(onlineCall);
+
+        // Simulate demotion while waiting
+        webinar.selfIsPanelist = false;
+
+        // Now default session comes online
+        webex.internal.llm.isConnected = sinon.stub().callsFake((sessionId) => {
+          return sessionId !== LLM_PRACTICE_SESSION;
+        });
+
+        // Fire the listener — re-invokes updatePSDataChannel which will see isPracticeSession = false
+        onlineCall[1]();
+
+        // Should NOT have called registerAndConnect since the user is no longer eligible
+        assert.notCalled(webex.internal.llm.registerAndConnect);
+      });
+
+      it('proceeds immediately when default session is already connected', async () => {
+        // Default session already connected, practice session not
+        webex.internal.llm.isConnected = sinon.stub().callsFake((sessionId) => {
+          return sessionId !== LLM_PRACTICE_SESSION;
+        });
+
+        const result = await webinar.updatePSDataChannel();
+
+        // The 'online' listener is registered then immediately removed since default session is already connected
+        assert.calledWith(webex.internal.llm.on, 'online', sinon.match.func);
+        assert.calledWith(webex.internal.llm.off, 'online', sinon.match.func);
+        assert.isNull(webinar._pendingOnlineListener);
+        assert.calledOnce(webex.internal.llm.registerAndConnect);
+        assert.equal(result, 'REGISTER_AND_CONNECT_RESULT');
+      });
       });
 
       describe('#updateStatusByRole', () => {
-        let updateLLMConnection;
         let updateMediaShares;
         beforeEach(() => {
-          // @ts-ignore
-          updateLLMConnection = sinon.stub();
           updateMediaShares = sinon.stub()
           webinar.webex.meetings = {
             getMeetingByType: sinon.stub().returns({
               id: 'meeting-id',
-              updateLLMConnection: updateLLMConnection,
-              shareStatus: 'whiteboard_share_active',
+              isJoined: sinon.stub().returns(false),
+              updateLLMConnection: sinon.stub(),
+              shareStatus: SHARE_STATUS.WHITEBOARD_SHARE_ACTIVE,
               locusInfo: {
                 mediaShares: 'mediaShares',
                 updateMediaShares: updateMediaShares
@@ -173,40 +567,20 @@ describe('plugin-meetings', () => {
           sinon.restore();
         });
 
-        it('trigger updateLLMConnection if PS started', () => {
-
-          webinar.practiceSessionEnabled = true;
-          const roleChange = {isPromoted: true, isDemoted: false};
-
-          const result = webinar.updateStatusByRole(roleChange);
-
-          assert.calledOnce(updateLLMConnection);
-        });
-
-        it('Not trigger updateLLMConnection if PS not started', () => {
-
-          webinar.practiceSessionEnabled = false;
-          const roleChange = {isPromoted: true, isDemoted: false};
-
-          const result = webinar.updateStatusByRole(roleChange);
-
-          assert.notCalled(updateLLMConnection);
-        });
-
         it('trigger updateMediaShares if promoted', () => {
 
           const roleChange = {isPromoted: true, isDemoted: false};
 
-          const result = webinar.updateStatusByRole(roleChange);
+          webinar.updateStatusByRole(roleChange);
 
-          assert.calledOnce(updateMediaShares);
+          assert.calledOnceWithExactly(updateMediaShares, 'mediaShares', true);
         });
 
         it('Not trigger updateMediaShares if no role change', () => {
 
           const roleChange = {isPromoted: false, isDemoted: false};
 
-          const result = webinar.updateStatusByRole(roleChange);
+          webinar.updateStatusByRole(roleChange);
 
           assert.notCalled(updateMediaShares);
         });
@@ -214,18 +588,18 @@ describe('plugin-meetings', () => {
 
           const roleChange = {isPromoted: true, isDemoted: false};
 
-          const result = webinar.updateStatusByRole(roleChange);
+          webinar.updateStatusByRole(roleChange);
 
-          assert.calledOnce(updateMediaShares);
+          assert.calledOnceWithExactly(updateMediaShares, 'mediaShares', true);
         });
 
         it('trigger updateMediaShares if is attendee with whiteboard share', () => {
 
           const roleChange = {isPromoted: false, isDemoted: true};
 
-          const result = webinar.updateStatusByRole(roleChange);
+          webinar.updateStatusByRole(roleChange);
 
-          assert.calledOnce(updateMediaShares);
+          assert.calledOnceWithExactly(updateMediaShares, 'mediaShares', true);
         });
 
         it('Not trigger updateMediaShares if is attendee with screen share', () => {
@@ -233,8 +607,9 @@ describe('plugin-meetings', () => {
           webinar.webex.meetings = {
             getMeetingByType: sinon.stub().returns({
               id: 'meeting-id',
-              updateLLMConnection: updateLLMConnection,
-              shareStatus: 'remote_share_active',
+              isJoined: sinon.stub().returns(false),
+              updateLLMConnection: sinon.stub(),
+              shareStatus: SHARE_STATUS.REMOTE_SHARE_ACTIVE,
               locusInfo: {
                 mediaShares: 'mediaShares',
                 updateMediaShares: updateMediaShares
@@ -244,10 +619,18 @@ describe('plugin-meetings', () => {
 
           const roleChange = {isPromoted: false, isDemoted: true};
 
-          const result = webinar.updateStatusByRole(roleChange);
+          webinar.updateStatusByRole(roleChange);
 
           assert.notCalled(updateMediaShares);
         });
+
+      it('updates PS data channel based on join eligibility', () => {
+        const updatePSDataChannelStub = sinon.stub(webinar, 'updatePSDataChannel').resolves();
+
+        webinar.updateStatusByRole({isPromoted: false, isDemoted: false});
+
+        assert.calledOnceWithExactly(updatePSDataChannelStub);
+      });
       });
 
       describe("#setPracticeSessionState", () => {
@@ -323,6 +706,14 @@ describe('plugin-meetings', () => {
 
           assert.equal(webinar.practiceSessionEnabled, false);
         });
+      it('triggers PS data channel update using computed eligibility', () => {
+        webinar.selfIsPanelist = true;
+        const updatePSDataChannelStub = sinon.stub(webinar, 'updatePSDataChannel').resolves();
+
+        webinar.updatePracticeSessionStatus({enabled: true});
+
+        assert.calledOnceWithExactly(updatePSDataChannelStub);
+      });
       });
 
       describe("#startWebcast", () => {
@@ -631,5 +1022,111 @@ describe('plugin-meetings', () => {
           }
         });
       });
+
+      describe("#searchLargeScaleWebinarAttendees", () => {
+        const attendeeSearchUrl = 'https://locusUrl/attendees/search';
+        const params = {
+          queryString: 'queryString',
+          limit: 50,
+          next: null,
+        };
+        beforeEach(() => {
+          // @ts-ignore
+          webinar.webex.meetings = {
+            getMeetingByType: sinon.stub().returns({
+              id: 'meeting-id',
+              locusInfo: {
+                links:{
+                  resources: {
+                    attendeeSearch: {
+                      url: attendeeSearchUrl
+                    }
+                  }
+                }
+              }
+            })
+          };
+        });
+
+        it('throws an error if attendeeSearchUrl is not available', async () => {
+          webinar.webex.meetings = {
+            getMeetingByType: sinon.stub().returns({
+              id: 'meeting-id',
+              locusInfo: {
+                links:{
+                  resources: {
+                    attendeeSearch: {
+                      url: null
+                    }
+                  }
+                }
+              }
+            })
+          };
+          try {
+            await webinar.searchLargeScaleWebinarAttendees(params);
+            assert.fail('searchLargeScaleWebinarAttendees should throw an error');
+          } catch (error) {
+            assert.equal(error.message,'Meeting:webinar5k#Attendee search url is not available', 'should throw the correct error');
+          }
+        });
+
+        it('sends a GET request to search the large scale webinar attendees', async () => {
+          const result = await webinar.searchLargeScaleWebinarAttendees(params);
+          assert.calledOnce(webex.request);
+          assert.calledWith(webex.request, {
+            method: 'GET',
+            uri: `${attendeeSearchUrl}?search_text=${encodeURIComponent(params.queryString)}&limit=50`,
+            headers: {
+              authorization: 'test-token',
+              trackingId: 'webex-js-sdk_test-uuid',
+            },
+          });
+          assert.equal(
+            result,
+            'REQUEST_RETURN_VALUE',
+            'should return the resolved value from the request'
+          );
+        });
+
+        it('queryString is empty string', async () => {
+          params.queryString = '';
+          const result = await webinar.searchLargeScaleWebinarAttendees(params);
+          assert.calledOnce(webex.request);
+          assert.calledWith(webex.request, {
+            method: 'GET',
+            uri: `${attendeeSearchUrl}?limit=50`,
+            headers: {
+              authorization: 'test-token',
+              trackingId: 'webex-js-sdk_test-uuid',
+            },
+          });
+          assert.equal(
+            result,
+            'REQUEST_RETURN_VALUE',
+            'should return the resolved value from the request'
+          );
+        });
+
+        it('handles API call failures gracefully', async () => {
+          webex.request.rejects(new Error('API_ERROR'));
+          const errorLogger = sinon.stub(LoggerProxy.logger, 'error');
+
+          try {
+            await webinar.searchLargeScaleWebinarAttendees(params);
+            assert.fail('searchLargeScaleWebinarAttendees should throw an error');
+          } catch (error) {
+            assert.equal(error.message, 'API_ERROR', 'should throw the correct error');
+            assert.calledOnce(errorLogger);
+            assert.calledWith(
+              errorLogger,
+              'Meeting:webinar5k#searchLargeScaleWebinarAttendees failed',
+              sinon.match.instanceOf(Error)
+            );
+          } finally {
+            errorLogger.restore();
+          }
+        });
+      });
     })
 })

package/test/unit/spec/webinar/utils.ts

@@ -0,0 +1,39 @@
+import chai from 'chai';
+import {sanitizeParams} from '@webex/plugin-meetings/src/webinar/utils';
+
+const {assert} = chai;
+
+describe('plugin-meetings', () => {
+  describe('webinar utils', () => {
+    describe('#sanitizeParams', () => {
+      it('sanitizes params by removing undefined, "", or null values', () => {
+        const input = {
+          a: 1,
+          b: undefined,
+          c: null,
+          d: 'test',
+          e: false,
+          f: '',
+        };
+        const expectedOutput = {
+          a: 1,
+          d: 'test',
+          e: false,
+        };
+        const result = sanitizeParams(input);
+        assert.deepEqual(result, expectedOutput);
+      });
+
+      it('returns an empty object when all values are invalid', () => {
+        const input = {
+          a: undefined,
+          b: null,
+          c: '',
+        };
+        const expectedOutput = {};
+        const result = sanitizeParams(input);
+        assert.deepEqual(result, expectedOutput);
+      });
+    });
+  });
+});