@webex/plugin-meetings 3.11.0-next.42 → 3.11.0-next.44

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

@@ -7,6 +7,7 @@ import LLMChannel from '@webex/internal-plugin-llm';
 
 import AnnotationService from '../../../../src/annotation/index';
 import {ANNOTATION_RELAY_TYPES, ANNOTATION_REQUEST_TYPE, EVENT_TRIGGERS} from '../../../../src/annotation/constants';
+import {LLM_PRACTICE_SESSION} from '../../../../src/constants';
 
 
 describe('live-annotation', () => {
@@ -28,6 +29,7 @@ describe('live-annotation', () => {
       annotationService = webex.internal.annotation;
       annotationService.connect = sinon.stub().resolves(true);
       annotationService.webex.internal.llm.isConnected = sinon.stub().returns(true);
+      annotationService.webex.internal.llm.getSocket = sinon.stub().returns(undefined);
       annotationService.webex.internal.llm.getBinding = sinon.stub().returns(undefined);
       annotationService.webex.internal.llm.getLocusUrl = sinon.stub().returns(locusUrl);
       annotationService.approvalUrl = 'url/approval';
@@ -183,7 +185,13 @@ describe('live-annotation', () => {
 
         annotationService.listenToEvents();
 
-        assert.calledOnceWithExactly(spy, 'event:relay.event', sinon.match.func,sinon.match.object);
+        assert.calledWithExactly(spy.firstCall, 'event:relay.event', sinon.match.func, sinon.match.object);
+        assert.calledWithExactly(
+          spy.secondCall,
+          `event:relay.event:${LLM_PRACTICE_SESSION}`,
+          sinon.match.func,
+          sinon.match.object
+        );
       });
 
     });
@@ -226,14 +234,11 @@ describe('live-annotation', () => {
     });
 
     describe('sendStrokeData', () => {
+      let strokeData;
 
       beforeEach(async () => {
         annotationService.webex.internal.llm.socket = new MockWebSocket();
-      });
-
-
-      it('works on publish Stroke Data', async () => {
-        const strokeData = {
+        strokeData = {
           content: {
             "contentsBuffer": [{
               "contentArray": [{
@@ -249,8 +254,11 @@ describe('live-annotation', () => {
           shareInstanceId: '7fa6fe07-dcb1-41ad-973d-7bcf65fab55d',
           encryptionKeyUrl: "encryptionKeyUrl",
           version: '1',
-        } ;
+        };
+      });
+
 
+      it('works on publish Stroke Data', async () => {
         annotationService.publishEncrypted(strokeData.content, strokeData);
 
         const sendObject = {
@@ -283,6 +291,49 @@ describe('live-annotation', () => {
         assert.calledOnceWithExactly(annotationService.webex.internal.llm.socket.send, sendObject);
       });
 
+      it('uses the practice-session socket and binding only when the practice-session session is connected', () => {
+        const practiceSocket = new MockWebSocket();
+
+        annotationService.webex.internal.llm.isConnected.callsFake((sessionId) =>
+          sessionId === LLM_PRACTICE_SESSION
+        );
+        annotationService.webex.internal.llm.getSocket
+          .withArgs(LLM_PRACTICE_SESSION)
+          .returns(practiceSocket);
+        annotationService.webex.internal.llm.getBinding
+          .withArgs(LLM_PRACTICE_SESSION)
+          .returns('practice-binding');
+
+        annotationService.publishEncrypted(strokeData.content, strokeData);
+
+        assert.calledOnce(practiceSocket.send);
+        assert.notCalled(annotationService.webex.internal.llm.socket.send);
+
+        const sent = practiceSocket.send.getCall(0).args[0];
+        assert.equal(sent.recipients.route, 'practice-binding');
+      });
+
+      it('falls back to the default socket and binding when the practice-session socket exists but is not connected', () => {
+        const practiceSocket = new MockWebSocket();
+
+        annotationService.webex.internal.llm.isConnected.callsFake((sessionId) => !sessionId);
+        annotationService.webex.internal.llm.getSocket
+          .withArgs(LLM_PRACTICE_SESSION)
+          .returns(practiceSocket);
+        annotationService.webex.internal.llm.getBinding
+          .withArgs(LLM_PRACTICE_SESSION)
+          .returns('practice-binding');
+        annotationService.webex.internal.llm.getBinding.returns('default-binding');
+
+        annotationService.publishEncrypted(strokeData.content, strokeData);
+
+        assert.notCalled(practiceSocket.send);
+        assert.calledOnce(annotationService.webex.internal.llm.socket.send);
+
+        const sent = annotationService.webex.internal.llm.socket.send.getCall(0).args[0];
+        assert.equal(sent.recipients.route, 'default-binding');
+      });
+
     });
 
 
@@ -441,10 +492,21 @@ describe('live-annotation', () => {
           annotationService.eventDataProcessor,
           annotationService
         );
+        assert.calledWith(
+          llmOn,
+          `event:relay.event:${LLM_PRACTICE_SESSION}`,
+          annotationService.eventDataProcessor,
+          annotationService
+        );
         assert.match(annotationService.hasSubscribedToEvents, true);
 
         annotationService.deregisterEvents();
         assert.calledWith(llmOff, 'event:relay.event', annotationService.eventDataProcessor);
+        assert.calledWith(
+          llmOff,
+          `event:relay.event:${LLM_PRACTICE_SESSION}`,
+          annotationService.eventDataProcessor
+        );
         assert.calledWith(
           mercuryOff,
           'event:locus.approval_request',

package/test/unit/spec/locus-info/index.js

@@ -934,6 +934,20 @@ describe('plugin-meetings', () => {
             MEETING_REMOVED_REASON.SELF_REMOVED
           );
         });
+
+        // this could happen if meeting gets destroyed while we're doing some async hash tree operation like a sync
+        it('should handle MEETING_ENDED correctly when meeting is not found in the collection', () => {
+          const collectionGetStub = sinon
+            .stub(locusInfo.webex.meetings.meetingCollection, 'get')
+            .returns(null);
+          const destroyStub = sinon.stub(locusInfo.webex.meetings, 'destroy');
+
+          // simulate an update from the HashTreeParser (normally this would be triggered by incoming locus messages)
+          locusInfoUpdateCallback(MEETING_ENDED);
+
+          assert.calledOnceWithExactly(collectionGetStub, locusInfo.meetingId);
+          assert.notCalled(destroyStub);
+        });
       });
     });
 

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

@@ -267,6 +267,7 @@ describe('plugin-meetings', () => {
     };
     webex.internal.llm.isDataChannelTokenEnabled = sinon.stub().resolves(false);
     webex.internal.llm.on = sinon.stub();
+    webex.internal.voicea.announce = sinon.stub();
     webex.internal.newMetrics.callDiagnosticLatencies = new CallDiagnosticLatencies(
       {},
       {parent: webex}
@@ -6400,7 +6401,10 @@ describe('plugin-meetings', () => {
           meeting.statsAnalyzer = {stopAnalyzer: sinon.stub().resolves()};
           meeting.unsetPeerConnections = sinon.stub().returns(true);
           meeting.logger.error = sinon.stub().returns(true);
-          meeting.updateLLMConnection = sinon.stub().returns(Promise.resolve());
+          meeting.clearMeetingData = sinon.stub().callsFake(async () => {
+            meeting.audio = null;
+            meeting.video = null;
+          });
           webex.internal.voicea.off = sinon.stub().returns(true);
           meeting.stopTranscription = sinon.stub();
           meeting.transcription = {};
@@ -6427,9 +6431,7 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting.closePeerConnections);
           assert.calledOnce(meeting.unsetRemoteStreams);
           assert.calledOnce(meeting.unsetPeerConnections);
-          assert.calledOnce(meeting.stopTranscription);
-          assert.calledOnce(meeting.annotation.deregisterEvents);
-          assert.calledWith(webex.internal.llm.off, 'event:relay.event', meeting.processRelayEvent);
+          assert.calledOnce(meeting.clearMeetingData);
         });
 
         it('should reset call diagnostic latencies correctly', async () => {
@@ -8430,7 +8432,10 @@ describe('plugin-meetings', () => {
           meeting.statsAnalyzer = {stopAnalyzer: sinon.stub().resolves()};
           meeting.unsetPeerConnections = sinon.stub().returns(true);
           meeting.logger.error = sinon.stub().returns(true);
-          meeting.updateLLMConnection = sinon.stub().returns(Promise.resolve());
+          meeting.clearMeetingData = sinon.stub().callsFake(async () => {
+            meeting.audio = null;
+            meeting.video = null;
+          });
           meeting.transcription = {};
           meeting.stopTranscription = sinon.stub();
 
@@ -8456,10 +8461,7 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting?.closePeerConnections);
           assert.calledOnce(meeting?.unsetRemoteStreams);
           assert.calledOnce(meeting?.unsetPeerConnections);
-          assert.calledOnce(meeting?.stopTranscription);
-
-          assert.called(meeting.annotation.deregisterEvents);
-          assert.calledWith(webex.internal.llm.off, 'event:relay.event', meeting.processRelayEvent);
+          assert.calledOnce(meeting?.clearMeetingData);
         });
       });
 
@@ -12674,33 +12676,72 @@ describe('plugin-meetings', () => {
 
       describe('#handleDataChannelUrlChange', () => {
         let updateLLMConnectionSpy;
+        let updatePSDataChannelSpy;
 
         beforeEach(() => {
           updateLLMConnectionSpy = sinon.spy(meeting, 'updateLLMConnection');
+          updatePSDataChannelSpy = sinon.stub(meeting.webinar, 'updatePSDataChannel').resolves();
+          meeting.webinar.isJoinPracticeSessionDataChannel = sinon.stub().returns(false);
         });
 
-        const check = (url, expectedCalled) => {
-          meeting.handleDataChannelUrlChange(url);
+        const check = (
+          url,
+          practiceSessionDatachannelUrl,
+          {expectedMainCalled, expectedPracticeCalled}
+        ) => {
+          meeting.handleDataChannelUrlChange(url, practiceSessionDatachannelUrl);
 
-          if (expectedCalled) {
+          if (expectedMainCalled) {
             assert.calledWith(updateLLMConnectionSpy);
           } else {
             assert.notCalled(updateLLMConnectionSpy);
           }
+
+          if (expectedPracticeCalled) {
+            assert.calledWith(updatePSDataChannelSpy);
+          } else {
+            assert.notCalled(updatePSDataChannelSpy);
+          }
         };
 
         it('calls deferred updateLLMConnection if datachannelURL is set and the enableAutomaticLLM is true', () => {
           meeting.config.enableAutomaticLLM = true;
-          check('some url', true);
+          check('some url', undefined, {expectedMainCalled: true, expectedPracticeCalled: false});
         });
 
         it('does not call updateLLMConnection if datachannelURL is undefined', () => {
           meeting.config.enableAutomaticLLM = true;
-          check(undefined, false);
+          check(undefined, undefined, {
+            expectedMainCalled: false,
+            expectedPracticeCalled: false,
+          });
         });
 
         it('does not call updateLLMConnection if enableAutomaticLLM is false', () => {
-          check('some url', false);
+          check('some url', 'some practice url', {
+            expectedMainCalled: false,
+            expectedPracticeCalled: false,
+          });
+        });
+
+        it('calls updatePSDataChannel when practice-session routing is active', () => {
+          meeting.config.enableAutomaticLLM = true;
+          meeting.webinar.isJoinPracticeSessionDataChannel.returns(true);
+
+          check('some url', 'some practice url', {
+            expectedMainCalled: true,
+            expectedPracticeCalled: true,
+          });
+        });
+
+        it('does not call updatePSDataChannel when the main datachannelURL is undefined', () => {
+          meeting.config.enableAutomaticLLM = true;
+          meeting.webinar.isJoinPracticeSessionDataChannel.returns(true);
+
+          check(undefined, 'some practice url', {
+            expectedMainCalled: false,
+            expectedPracticeCalled: false,
+          });
         });
       });
 
@@ -12838,6 +12879,9 @@ describe('plugin-meetings', () => {
             'event:locus.state_message',
             meeting.processLocusLLMEvent
           );
+          assert.isFalse(
+            meeting.webex.internal.llm.off.calledWithExactly('online', meeting.handleLLMOnline)
+          );
         });
         it('disconnects if the data channel url has changed', async () => {
           meeting.joinedWith = {state: 'JOINED'};
@@ -12887,6 +12931,9 @@ describe('plugin-meetings', () => {
             'event:locus.state_message',
             meeting.processLocusLLMEvent
           );
+          assert.isFalse(
+            meeting.webex.internal.llm.off.calledWithExactly('online', meeting.handleLLMOnline)
+          );
         });
         it('disconnects when the state is not JOINED', async () => {
           meeting.joinedWith = {state: 'any other state'};
@@ -12903,8 +12950,48 @@ describe('plugin-meetings', () => {
           });
           assert.notCalled(webex.internal.llm.registerAndConnect);
           assert.equal(result, undefined);
+          assert.isFalse(
+            meeting.webex.internal.llm.off.calledWithExactly('online', meeting.handleLLMOnline)
+          );
+        });
+        it('rethrows disconnect errors during reconnect cleanup after removing relay listeners and timer', async () => {
+          const disconnectError = new Error('disconnect failed');
+
+          meeting.joinedWith = {state: 'JOINED'};
+          webex.internal.llm.isConnected.returns(true);
+          webex.internal.llm.getLocusUrl.returns('a url');
+          webex.internal.llm.disconnectLLM.rejects(disconnectError);
+
+          meeting.locusInfo = {
+            url: 'a different url',
+            info: {datachannelUrl: 'a datachannel url'},
+            self: {},
+          };
+
+          try {
+            await meeting.updateLLMConnection();
+            assert.fail('Expected updateLLMConnection to reject when disconnectLLM fails');
+          } catch (error) {
+            assert.equal(error, disconnectError);
+          }
+
+          assert.notCalled(webex.internal.llm.registerAndConnect);
+          assert.calledWithExactly(
+            meeting.webex.internal.llm.off,
+            'event:relay.event',
+            meeting.processRelayEvent
+          );
+          assert.calledWithExactly(
+            meeting.webex.internal.llm.off,
+            'event:locus.state_message',
+            meeting.processLocusLLMEvent
+          );
+          assert.isFalse(
+            meeting.webex.internal.llm.off.calledWithExactly('online', meeting.handleLLMOnline)
+          );
+          assert.calledOnce(meeting.clearLLMHealthCheckTimer);
         });
-        it('connects practice session data channel when PS started', async () => {
+        it('still need connect main session data channel when PS started', async () => {
           meeting.joinedWith = {state: 'JOINED'};
           meeting.locusInfo = {
             url: 'a url',
@@ -12920,7 +13007,7 @@ describe('plugin-meetings', () => {
           assert.calledWithExactly(
             webex.internal.llm.registerAndConnect,
             'a url',
-            'ps-url',
+            'a datachannel url',
             undefined
           );
         });
@@ -12965,43 +13052,6 @@ describe('plugin-meetings', () => {
 
           assert.notCalled(webex.internal.llm.setDatachannelToken);
         });
-        it('uses practice session token when in PS even if refreshed token exists', async () => {
-          meeting.joinedWith = {state: 'JOINED'};
-
-          meeting.locusInfo = {
-            url: 'a url',
-            info: {
-              datachannelUrl: 'a datachannel url',
-              practiceSessionDatachannelUrl: 'ps-url',
-            },
-            self: {
-              datachannelToken: 'locus-token',
-              practiceSessionDatachannelToken: 'ps-token',
-            },
-          };
-
-          meeting.webinar.isJoinPracticeSessionDataChannel.returns(true);
-
-          webex.internal.llm.getDatachannelToken
-            .withArgs(true)
-            .returns('refreshed-ps-token') // refreshed practice token
-            .withArgs(false)
-            .returns('refreshed-normal-token'); // refreshed normal token
-
-          await meeting.updateLLMConnection();
-
-          assert.calledWithExactly(
-            webex.internal.llm.registerAndConnect,
-            'a url',
-            'ps-url',
-            'ps-token'
-          );
-          assert.calledWithExactly(
-            webex.internal.llm.setDatachannelToken,
-            'ps-token',
-            'practiceSession'
-          );
-        });
 
         it('does not pass token when data channel with jwt token is disabled', async () => {
           meeting.joinedWith = {state: 'JOINED'};
@@ -13024,6 +13074,62 @@ describe('plugin-meetings', () => {
           );
           assert.calledWithExactly(webex.internal.llm.setDatachannelToken, 'token-123', 'default');
         });
+
+        describe('#clearMeetingData', () => {
+          beforeEach(() => {
+            webex.internal.llm.isConnected = sinon.stub().returns(true);
+            webex.internal.llm.disconnectLLM = sinon.stub().resolves();
+            webex.internal.llm.off = sinon.stub();
+            meeting.annotation.deregisterEvents = sinon.stub();
+            meeting.clearLLMHealthCheckTimer = sinon.stub();
+            meeting.stopTranscription = sinon.stub();
+            meeting.transcription = {};
+            meeting.shareStatus = 'no-share';
+          });
+
+          it('disconnects llm and removes online and relay listeners during meeting data cleanup', async () => {
+            await meeting.clearMeetingData();
+
+            assert.calledOnceWithExactly(webex.internal.llm.disconnectLLM, {
+              code: 3050,
+              reason: 'done (permanent)',
+            });
+            assert.calledWithExactly(webex.internal.llm.off, 'online', meeting.handleLLMOnline);
+            assert.calledWithExactly(
+              webex.internal.llm.off,
+              'event:relay.event',
+              meeting.processRelayEvent
+            );
+            assert.calledWithExactly(
+              webex.internal.llm.off,
+              'event:locus.state_message',
+              meeting.processLocusLLMEvent
+            );
+            assert.calledOnce(meeting.clearLLMHealthCheckTimer);
+            assert.calledOnce(meeting.stopTranscription);
+            assert.calledOnce(meeting.annotation.deregisterEvents);
+          });
+          it('continues cleanup when disconnectLLM fails during meeting data cleanup', async () => {
+            webex.internal.llm.disconnectLLM.rejects(new Error('disconnect failed'));
+
+            await meeting.clearMeetingData();
+
+            assert.calledWithExactly(webex.internal.llm.off, 'online', meeting.handleLLMOnline);
+            assert.calledWithExactly(
+              webex.internal.llm.off,
+              'event:relay.event',
+              meeting.processRelayEvent
+            );
+            assert.calledWithExactly(
+              webex.internal.llm.off,
+              'event:locus.state_message',
+              meeting.processLocusLLMEvent
+            );
+            assert.calledOnce(meeting.clearLLMHealthCheckTimer);
+            assert.calledOnce(meeting.stopTranscription);
+            assert.calledOnce(meeting.annotation.deregisterEvents);
+          });
+        });
       });
 
       describe('#setLocus', () => {

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

@@ -54,8 +54,9 @@ describe('plugin-meetings', () => {
       meeting.unsetPeerConnections = sinon.stub();
       meeting.reconnectionManager = {cleanUp: sinon.stub()};
       meeting.stopKeepAlive = sinon.stub();
-      meeting.updateLLMConnection = sinon.stub();
+      meeting.cleanupLLMConneciton = sinon.stub().resolves();
       meeting.breakouts = {cleanUp: sinon.stub()};
+      meeting.webinar = {cleanUp: sinon.stub()};
       meeting.annotaion = {cleanUp: sinon.stub()};
       meeting.getWebexObject = sinon.stub().returns(webex);
       meeting.simultaneousInterpretation = {cleanUp: sinon.stub()};
@@ -85,7 +86,7 @@ describe('plugin-meetings', () => {
         assert.calledOnce(meeting.unsetPeerConnections);
         assert.calledOnce(meeting.reconnectionManager.cleanUp);
         assert.calledOnce(meeting.stopKeepAlive);
-        assert.calledOnce(meeting.updateLLMConnection);
+        assert.calledOnceWithExactly(meeting.cleanupLLMConneciton, {throwOnError: false});
         assert.calledOnce(meeting.breakouts.cleanUp);
         assert.calledOnce(meeting.simultaneousInterpretation.cleanUp);
         assert.calledOnce(webex.internal.device.meetingEnded);
@@ -106,7 +107,7 @@ describe('plugin-meetings', () => {
         assert.calledOnce(meeting.unsetPeerConnections);
         assert.calledOnce(meeting.reconnectionManager.cleanUp);
         assert.calledOnce(meeting.stopKeepAlive);
-        assert.notCalled(meeting.updateLLMConnection);
+        assert.notCalled(meeting.cleanupLLMConneciton);
         assert.calledOnce(meeting.breakouts.cleanUp);
         assert.calledOnce(meeting.simultaneousInterpretation.cleanUp);
         assert.calledOnce(webex.internal.device.meetingEnded);
@@ -126,7 +127,7 @@ describe('plugin-meetings', () => {
         assert.calledOnce(meeting.unsetPeerConnections);
         assert.calledOnce(meeting.reconnectionManager.cleanUp);
         assert.calledOnce(meeting.stopKeepAlive);
-        assert.notCalled(meeting.updateLLMConnection);
+        assert.notCalled(meeting.cleanupLLMConneciton);
         assert.calledOnce(meeting.breakouts.cleanUp);
         assert.calledOnce(meeting.simultaneousInterpretation.cleanUp);
         assert.calledOnce(webex.internal.device.meetingEnded);