@webex/plugin-meetings 3.12.0-next.1 → 3.12.0-next.11

package/test/unit/spec/multistream/sendSlotManager.ts

@@ -1,19 +1,28 @@
 import 'jsdom-global/register';
 import SendSlotManager from '@webex/plugin-meetings/src/multistream/sendSlotManager';
-import { LocalStream, MediaType, MultistreamRoapMediaConnection } from "@webex/internal-media-core";
-import {expect} from '@webex/test-helper-chai';
+import { LocalStream, MediaType, MultistreamRoapMediaConnection, MediaCodecMimeType } from "@webex/internal-media-core";
+import {assert, expect} from '@webex/test-helper-chai';
 import sinon from 'sinon';
+import Metrics from '@webex/plugin-meetings/src/metrics';
+import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
 
 describe('SendSlotsManager', () => {
     let sendSlotsManager: SendSlotManager;
     const LoggerProxy = {
         logger: {
             info: sinon.stub(),
+            warn: sinon.stub(),
+            error: sinon.stub(),
         },
     };
 
     beforeEach(() => {
         sendSlotsManager = new SendSlotManager(LoggerProxy);
+        sinon.stub(Metrics, 'sendBehavioralMetric');
+    });
+
+    afterEach(() => {
+        sinon.restore();
     });
 
     describe('createSlot', () => {
@@ -29,13 +38,13 @@ describe('SendSlotsManager', () => {
         it('should create a slot for the given mediaType', () => {
             sendSlotsManager.createSlot(mediaConnection, mediaType);
 
-            expect(mediaConnection.createSendSlot.calledWith(mediaType, true));
+            assert.calledWith(mediaConnection.createSendSlot, mediaType, true);
         });
 
         it('should create a slot for the given mediaType & active state', () => {
             sendSlotsManager.createSlot(mediaConnection, mediaType, false);
 
-            expect(mediaConnection.createSendSlot.calledWith(mediaType, false));
+            assert.calledWith(mediaConnection.createSendSlot, mediaType, false);
         });
 
         it('should throw an error if a slot for the given mediaType already exists', () => {
@@ -86,14 +95,12 @@ describe('SendSlotsManager', () => {
 
             await sendSlotsManager.publishStream(mediaType, stream);
 
-            expect(slot.publishStream.calledWith(stream));
+            assert.calledWith(slot.publishStream, stream);
         });
 
-        it('should throw an error if a slot for the given mediaType does not exist', (done) => {
-            sendSlotsManager.publishStream(mediaType, stream).catch((error) => {
-                expect(error.message).to.equal(`Slot for ${mediaType} does not exist`);
-                done();
-            });
+        it('should throw an error if a slot for the given mediaType does not exist', async () => {
+            await expect(sendSlotsManager.publishStream(mediaType, stream))
+                .to.be.rejectedWith(`Slot for ${mediaType} does not exist`);
         });
     });
 
@@ -116,14 +123,12 @@ describe('SendSlotsManager', () => {
 
             await sendSlotsManager.unpublishStream(mediaType);
 
-            expect(slot.unpublishStream.called);
+            assert.called(slot.unpublishStream);
         });
 
-        it('should throw an error if a slot for the given mediaType does not exist',(done) => {
-            sendSlotsManager.unpublishStream(mediaType).catch((error) => {
-                expect(error.message).to.equal(`Slot for ${mediaType} does not exist`);
-                done();
-            });
+        it('should throw an error if a slot for the given mediaType does not exist', async () => {
+            await expect(sendSlotsManager.unpublishStream(mediaType))
+                .to.be.rejectedWith(`Slot for ${mediaType} does not exist`);
         });
     });
 
@@ -147,7 +152,7 @@ describe('SendSlotsManager', () => {
 
       await sendSlotsManager.setNamedMediaGroups(mediaType, groups);
 
-      expect(slot.setNamedMediaGroups.calledWith(groups));
+      assert.calledWith(slot.setNamedMediaGroups, groups);
     });
 
     it('should throw an error if the given mediaType is not audio', () => {
@@ -169,16 +174,16 @@ describe('SendSlotsManager', () => {
             } as MultistreamRoapMediaConnection;
         });
 
-        it('should set the active state of the sendSlot for the given mediaType', async () => {
+        it('should set the active state of the sendSlot for the given mediaType', () => {
             const slot = {
-                setActive: sinon.stub().resolves(),
+                active: false,
             };
             mediaConnection.createSendSlot.returns(slot);
             sendSlotsManager.createSlot(mediaConnection, mediaType);
 
-            await sendSlotsManager.setActive(mediaType,true);
+            sendSlotsManager.setActive(mediaType, true);
 
-            expect(slot.setActive.called);
+            expect(slot.active).to.be.true;
         });
 
         it('should throw an error if a slot for the given mediaType does not exist', () => {
@@ -197,7 +202,7 @@ describe('SendSlotsManager', () => {
             } as MultistreamRoapMediaConnection;
         });
 
-        it('should set the codec parameters of the sendSlot for the given mediaType', async () => {
+        it('should delegate to slot.setCodecParameters, log deprecation warning and send deprecation metric', async () => {
             const slot = {
                 setCodecParameters: sinon.stub().resolves(),
             };
@@ -206,14 +211,17 @@ describe('SendSlotsManager', () => {
 
             await sendSlotsManager.setCodecParameters(mediaType, codecParameters);
 
-            expect(slot.setCodecParameters.calledWith(codecParameters));
+            assert.calledWith(slot.setCodecParameters, codecParameters);
+            assert.called(LoggerProxy.logger.warn);
+            assert.calledWith(Metrics.sendBehavioralMetric as sinon.SinonStub,
+                BEHAVIORAL_METRICS.DEPRECATED_SET_CODEC_PARAMETERS_USED,
+                { mediaType, codecParameters }
+            );
         });
 
-        it('should throw an error if a slot for the given mediaType does not exist', (done) => {
-            sendSlotsManager.setCodecParameters(mediaType, codecParameters).catch((error) => {
-                expect(error.message).to.equal(`Slot for ${mediaType} does not exist`);
-                done();
-            });
+        it('should throw an error if a slot for the given mediaType does not exist', async () => {
+            await expect(sendSlotsManager.setCodecParameters(mediaType, codecParameters))
+                .to.be.rejectedWith(`Slot for ${mediaType} does not exist`);
         });
     });
 
@@ -227,23 +235,114 @@ describe('SendSlotsManager', () => {
             } as MultistreamRoapMediaConnection;
         });
 
-        it('should delete the codec parameters of the sendSlot for the given mediaType', async () => {
+        it('should delegate to slot.deleteCodecParameters, log deprecation warning and send deprecation metric', async () => {
             const slot = {
                 deleteCodecParameters: sinon.stub().resolves(),
             };
             mediaConnection.createSendSlot.returns(slot);
             sendSlotsManager.createSlot(mediaConnection, mediaType);
 
-            await sendSlotsManager.deleteCodecParameters(mediaType,[]);
+            await sendSlotsManager.deleteCodecParameters(mediaType, []);
+
+            assert.calledWith(slot.deleteCodecParameters, []);
+            assert.called(LoggerProxy.logger.warn);
+            assert.calledWith(Metrics.sendBehavioralMetric as sinon.SinonStub,
+                BEHAVIORAL_METRICS.DEPRECATED_DELETE_CODEC_PARAMETERS_USED,
+                { mediaType, parameters: [] }
+            );
+        });
+
+        it('should throw an error if a slot for the given mediaType does not exist', async () => {
+            await expect(sendSlotsManager.deleteCodecParameters(mediaType, []))
+                .to.be.rejectedWith(`Slot for ${mediaType} does not exist`);
+        });
+    });
+
+    describe('setCustomCodecParameters', () => {
+        let mediaConnection;
+        const mediaType = MediaType.AudioMain;
+        const codecMimeType = MediaCodecMimeType.OPUS;
+        const parameters = { maxaveragebitrate: '64000' };
+
+        beforeEach(() => {
+            mediaConnection = {
+                createSendSlot: sinon.stub(),
+            } as MultistreamRoapMediaConnection;
+        });
+
+        it('should set custom codec parameters on the sendSlot for the given mediaType and codec, log info and send metric', async () => {
+            const slot = {
+                setCustomCodecParameters: sinon.stub().resolves(),
+            };
+            mediaConnection.createSendSlot.returns(slot);
+            sendSlotsManager.createSlot(mediaConnection, mediaType);
+
+            await sendSlotsManager.setCustomCodecParameters(mediaType, codecMimeType, parameters);
+
+            assert.calledWith(slot.setCustomCodecParameters, codecMimeType, parameters);
+            assert.called(LoggerProxy.logger.info);
+            assert.calledWith(Metrics.sendBehavioralMetric as sinon.SinonStub,
+                BEHAVIORAL_METRICS.SET_CUSTOM_CODEC_PARAMETERS_USED,
+                { mediaType, codecMimeType, parameters }
+            );
+        });
+
+        it('should throw an error if a slot for the given mediaType does not exist', async () => {
+            await expect(sendSlotsManager.setCustomCodecParameters(mediaType, codecMimeType, parameters))
+                .to.be.rejectedWith(`Slot for ${mediaType} does not exist`);
+        });
+
+        it('should throw and log error when setCustomCodecParameters fails', async () => {
+            const error = new Error('codec parameter failure');
+            const slot = {
+                setCustomCodecParameters: sinon.stub().rejects(error),
+            };
+            mediaConnection.createSendSlot.returns(slot);
+            sendSlotsManager.createSlot(mediaConnection, mediaType);
+
+            await expect(sendSlotsManager.setCustomCodecParameters(mediaType, codecMimeType, parameters))
+                .to.be.rejectedWith('codec parameter failure');
+
+            assert.called(LoggerProxy.logger.error);
+            assert.calledWith(Metrics.sendBehavioralMetric as sinon.SinonStub,
+                BEHAVIORAL_METRICS.SET_CUSTOM_CODEC_PARAMETERS_USED,
+                { mediaType, codecMimeType, parameters }
+            );
+        });
+    });
+
+    describe('markCustomCodecParametersForDeletion', () => {
+        let mediaConnection;
+        const mediaType = MediaType.AudioMain;
+        const codecMimeType = MediaCodecMimeType.OPUS;
+        const parameters = ['maxaveragebitrate', 'maxplaybackrate'];
+
+        beforeEach(() => {
+            mediaConnection = {
+                createSendSlot: sinon.stub(),
+            } as MultistreamRoapMediaConnection;
+        });
+
+        it('should mark custom codec parameters for deletion on the sendSlot for the given mediaType and codec, log info and send metric', async () => {
+            const slot = {
+                markCustomCodecParametersForDeletion: sinon.stub().resolves(),
+            };
+            mediaConnection.createSendSlot.returns(slot);
+            sendSlotsManager.createSlot(mediaConnection, mediaType);
+
+            await sendSlotsManager.markCustomCodecParametersForDeletion(mediaType, codecMimeType, parameters);
 
-            expect(slot.deleteCodecParameters.called);
+            assert.calledWith(slot.markCustomCodecParametersForDeletion, codecMimeType, parameters);
+            assert.called(LoggerProxy.logger.info);
+            assert.calledWith(Metrics.sendBehavioralMetric as sinon.SinonStub,
+                BEHAVIORAL_METRICS.MARK_CUSTOM_CODEC_PARAMETERS_FOR_DELETION_USED,
+                { mediaType, codecMimeType, parameters }
+            );
         });
 
-        it('should throw an error if a slot for the given mediaType does not exist', (done) => {
-            sendSlotsManager.deleteCodecParameters(mediaType,[]).catch((error) => {
-                expect(error.message).to.equal(`Slot for ${mediaType} does not exist`);
-                done();
-            });
+        it('should throw an error if a slot for the given mediaType does not exist', async () => {
+            await expect(sendSlotsManager.markCustomCodecParametersForDeletion(mediaType, codecMimeType, parameters))
+                .to.be.rejectedWith(`Slot for ${mediaType} does not exist`);
         });
     });
 

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

@@ -33,6 +33,7 @@ describe('plugin-meetings', () => {
       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(),
@@ -210,6 +211,26 @@ describe('plugin-meetings', () => {
           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', () => {
@@ -224,12 +245,22 @@ describe('plugin-meetings', () => {
           locusInfo: {
             url: 'locus-url',
             info: {practiceSessionDatachannelUrl: 'dc-url'},
-            self: {practiceSessionDatachannelToken: 'ps-token'},
           },
         };
 
         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;
@@ -237,6 +268,65 @@ describe('plugin-meetings', () => {
         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();
@@ -284,11 +374,6 @@ describe('plugin-meetings', () => {
       it('connects when eligible', async () => {
         const result = await webinar.updatePSDataChannel();
 
-        assert.calledOnceWithExactly(
-          webex.internal.llm.setDatachannelToken,
-          'ps-token',
-          DataChannelTokenType.PracticeSession
-        );
         assert.calledOnce(webex.internal.llm.registerAndConnect);
         assert.calledWith(
           webex.internal.llm.registerAndConnect,
@@ -301,8 +386,11 @@ describe('plugin-meetings', () => {
         assert.equal(result, 'REGISTER_AND_CONNECT_RESULT');
       });
 
-      it('uses cached token when available', async () => {
-        webex.internal.llm.getDatachannelToken.returns('cached-token');
+      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();
 
@@ -360,6 +448,101 @@ describe('plugin-meetings', () => {
 
         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', () => {
@@ -369,6 +552,7 @@ describe('plugin-meetings', () => {
           webinar.webex.meetings = {
             getMeetingByType: sinon.stub().returns({
               id: 'meeting-id',
+              isJoined: sinon.stub().returns(false),
               updateLLMConnection: sinon.stub(),
               shareStatus: SHARE_STATUS.WHITEBOARD_SHARE_ACTIVE,
               locusInfo: {
@@ -423,6 +607,7 @@ describe('plugin-meetings', () => {
           webinar.webex.meetings = {
             getMeetingByType: sinon.stub().returns({
               id: 'meeting-id',
+              isJoined: sinon.stub().returns(false),
               updateLLMConnection: sinon.stub(),
               shareStatus: SHARE_STATUS.REMOTE_SHARE_ACTIVE,
               locusInfo: {