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

package/test/unit/spec/meeting/index.js

@@ -1552,6 +1552,22 @@ describe('plugin-meetings', () => {
             EVENT_TRIGGERS.MEETING_STOPPED_RECEIVING_TRANSCRIPTION
           );
         });
+
+        it('should stop listening to voicea events even when transcription is undefined', () => {
+          meeting.transcription = undefined;
+          meeting.stopTranscription();
+          assert.equal(webex.internal.voicea.off.callCount, 4);
+          assert.equal(meeting.areVoiceaEventsSetup, false);
+          assert.calledWith(
+            TriggerProxy.trigger,
+            sinon.match.instanceOf(Meeting),
+            {
+              file: 'meeting/index',
+              function: 'triggerStopReceivingTranscriptionEvent',
+            },
+            EVENT_TRIGGERS.MEETING_STOPPED_RECEIVING_TRANSCRIPTION
+          );
+        });
       });
 
       describe('#setCaptionLanguage', () => {
@@ -12745,6 +12761,93 @@ describe('plugin-meetings', () => {
         });
       });
 
+      describe('#saveDataChannelToken', () => {
+        beforeEach(() => {
+          webex.internal.llm.setDatachannelToken = sinon.stub();
+        });
+
+        it('saves datachannelToken into LLM as Default', () => {
+          meeting.saveDataChannelToken({
+            locus: {
+              self: {datachannelToken: 'default-token'},
+            },
+          });
+
+          assert.calledWithExactly(
+            webex.internal.llm.setDatachannelToken,
+            'default-token',
+            'llm-default-session'
+          );
+        });
+
+        it('saves practiceSessionDatachannelToken into LLM as PracticeSession', () => {
+          meeting.saveDataChannelToken({
+            locus: {
+              self: {practiceSessionDatachannelToken: 'ps-token'},
+            },
+          });
+
+          assert.calledWithExactly(
+            webex.internal.llm.setDatachannelToken,
+            'ps-token',
+            'llm-practice-session'
+          );
+        });
+
+        it('saves both tokens when both are present', () => {
+          meeting.saveDataChannelToken({
+            locus: {
+              self: {
+                datachannelToken: 'default-token',
+                practiceSessionDatachannelToken: 'ps-token',
+              },
+            },
+          });
+
+          assert.calledTwice(webex.internal.llm.setDatachannelToken);
+          assert.calledWithExactly(
+            webex.internal.llm.setDatachannelToken,
+            'default-token',
+            'llm-default-session'
+          );
+          assert.calledWithExactly(
+            webex.internal.llm.setDatachannelToken,
+            'ps-token',
+            'llm-practice-session'
+          );
+        });
+
+        it('does not call setDatachannelToken when no tokens are present', () => {
+          meeting.saveDataChannelToken({locus: {self: {}}});
+
+          assert.notCalled(webex.internal.llm.setDatachannelToken);
+        });
+
+        it('handles undefined join gracefully', () => {
+          meeting.saveDataChannelToken(undefined);
+
+          assert.notCalled(webex.internal.llm.setDatachannelToken);
+        });
+
+        it('handles missing locus.self gracefully', () => {
+          meeting.saveDataChannelToken({locus: {}});
+
+          assert.notCalled(webex.internal.llm.setDatachannelToken);
+        });
+      });
+
+      describe('#clearDataChannelToken', () => {
+        beforeEach(() => {
+          webex.internal.llm.resetDatachannelTokens = sinon.stub();
+        });
+
+        it('calls resetDatachannelTokens on LLM', () => {
+          meeting.clearDataChannelToken();
+
+          assert.calledOnce(webex.internal.llm.resetDatachannelTokens);
+        });
+      });
+
       describe('#updateLLMConnection', () => {
         beforeEach(() => {
           webex.internal.llm.isConnected = sinon.stub().returns(false);
@@ -13011,15 +13114,14 @@ describe('plugin-meetings', () => {
             undefined
           );
         });
-        it('passes dataChannelToken to registerAndConnect', async () => {
+        it('passes dataChannelToken from LLM to registerAndConnect', async () => {
           meeting.joinedWith = {state: 'JOINED'};
           meeting.locusInfo = {
             url: 'a url',
             info: {datachannelUrl: 'a datachannel url'},
-            self: {datachannelToken: 'token-123'},
           };
 
-          webex.internal.llm.getDatachannelToken.returns(undefined);
+          webex.internal.llm.getDatachannelToken.withArgs('llm-default-session').returns('token-123');
 
           await meeting.updateLLMConnection();
 
@@ -13029,17 +13131,16 @@ describe('plugin-meetings', () => {
             'a datachannel url',
             'token-123'
           );
-          assert.calledWithExactly(webex.internal.llm.setDatachannelToken, 'token-123', 'llm-default-session');
+          assert.notCalled(webex.internal.llm.setDatachannelToken);
         });
-        it('prefers refreshed token over locus self token', async () => {
+        it('passes undefined token when LLM has no token stored', async () => {
           meeting.joinedWith = {state: 'JOINED'};
           meeting.locusInfo = {
             url: 'a url',
             info: {datachannelUrl: 'a datachannel url'},
-            self: {datachannelToken: 'locus-token'},
           };
 
-          webex.internal.llm.getDatachannelToken.withArgs('llm-default-session').returns('refreshed-token');
+          webex.internal.llm.getDatachannelToken.returns(undefined);
 
           await meeting.updateLLMConnection();
 
@@ -13047,7 +13148,7 @@ describe('plugin-meetings', () => {
             webex.internal.llm.registerAndConnect,
             'a url',
             'a datachannel url',
-            'refreshed-token'
+            undefined
           );
 
           assert.notCalled(webex.internal.llm.setDatachannelToken);
@@ -13058,7 +13159,6 @@ describe('plugin-meetings', () => {
           meeting.locusInfo = {
             url: 'a url',
             info: {datachannelUrl: 'a datachannel url'},
-            self: {datachannelToken: 'token-123'},
           };
 
           webex.internal.llm.getDatachannelToken.returns(undefined);
@@ -13070,9 +13170,9 @@ describe('plugin-meetings', () => {
             webex.internal.llm.registerAndConnect,
             'a url',
             'a datachannel url',
-            'token-123'
+            undefined
           );
-          assert.calledWithExactly(webex.internal.llm.setDatachannelToken, 'token-123', 'llm-default-session');
+          assert.notCalled(webex.internal.llm.setDatachannelToken);
         });
 
         describe('#clearMeetingData', () => {
@@ -13083,7 +13183,7 @@ describe('plugin-meetings', () => {
             meeting.annotation.deregisterEvents = sinon.stub();
             meeting.clearLLMHealthCheckTimer = sinon.stub();
             meeting.stopTranscription = sinon.stub();
-            meeting.transcription = {};
+            meeting.clearDataChannelToken = sinon.stub();
             meeting.shareStatus = 'no-share';
           });
 
@@ -13107,6 +13207,8 @@ describe('plugin-meetings', () => {
             );
             assert.calledOnce(meeting.clearLLMHealthCheckTimer);
             assert.calledOnce(meeting.stopTranscription);
+            assert.isUndefined(meeting.transcription);
+            assert.calledOnce(meeting.clearDataChannelToken);
             assert.calledOnce(meeting.annotation.deregisterEvents);
           });
           it('continues cleanup when disconnectLLM fails during meeting data cleanup', async () => {
@@ -13127,8 +13229,19 @@ describe('plugin-meetings', () => {
             );
             assert.calledOnce(meeting.clearLLMHealthCheckTimer);
             assert.calledOnce(meeting.stopTranscription);
+            assert.isUndefined(meeting.transcription);
+            assert.calledOnce(meeting.clearDataChannelToken);
             assert.calledOnce(meeting.annotation.deregisterEvents);
           });
+          it('always calls stopTranscription even when transcription is undefined', async () => {
+            meeting.transcription = undefined;
+
+            await meeting.clearMeetingData();
+
+            assert.calledOnce(meeting.stopTranscription);
+            assert.isUndefined(meeting.transcription);
+            assert.calledOnce(meeting.clearDataChannelToken);
+          });
         });
       });
 

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

@@ -210,6 +210,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 +244,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;
@@ -284,11 +314,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 +326,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 +388,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 +492,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 +547,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: {