@webex/plugin-meetings 3.1.0 → 3.2.0

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

@@ -12,6 +12,7 @@ import {Credentials, Token, WebexPlugin} from '@webex/webex-core';
 import Support from '@webex/internal-plugin-support';
 import MockWebex from '@webex/test-helper-mock-webex';
 import StaticConfig from '@webex/plugin-meetings/src/common/config';
+import ReconnectionNotStartedError from '@webex/plugin-meetings/src/common/errors/reconnection-not-started';
 import {Defer} from '@webex/common';
 import {
   FLOOR_ACTION,
@@ -658,6 +659,9 @@ describe('plugin-meetings', () => {
           assert.calledOnceWithExactly(meeting.addMedia, mediaOptions, fakeTurnServerInfo);
 
           assert.deepEqual(result, {join: fakeJoinResult, media: test4});
+
+          // resets joinWithMediaRetryInfo
+          assert.deepEqual(meeting.joinWithMediaRetryInfo, {isRetry: false, prevJoinResponse: undefined});
         });
 
         it("should not call handleTurnDiscoveryHttpResponse if we don't send a TURN discovery request with join", async () => {
@@ -719,8 +723,9 @@ describe('plugin-meetings', () => {
 
           await assert.isRejected(meeting.joinWithMedia({mediaOptions: {allowMediaInLobby: true}}));
 
-          assert.calledOnceWithExactly(abortTurnDiscoveryStub);
+          assert.calledTwice(abortTurnDiscoveryStub);
 
+          assert.calledTwice(Metrics.sendBehavioralMetric);
           assert.calledWith(
             Metrics.sendBehavioralMetric,
             BEHAVIORAL_METRICS.JOIN_WITH_MEDIA_FAILURE,
@@ -730,11 +735,67 @@ describe('plugin-meetings', () => {
               reason: error.message,
               stack: error.stack,
               leaveErrorReason: undefined,
+              isRetry: false,
             },
             {
               type: error.name,
             }
           );
+          assert.calledWith(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.JOIN_WITH_MEDIA_FAILURE,
+            {
+              correlation_id: meeting.correlationId,
+              locus_id: undefined,
+              reason: error.message,
+              stack: error.stack,
+              leaveErrorReason: undefined,
+              isRetry: true,
+            },
+            {
+              type: error.name,
+            }
+          );
+
+          // resets joinWithMediaRetryInfo
+          assert.deepEqual(meeting.joinWithMediaRetryInfo, {isRetry: false, prevJoinResponse: undefined});
+        });
+
+        it('should resolve if join() fails the first time but succeeds the second time', async () => {
+          const error = new Error('fake');
+          meeting.join = sinon.stub().onFirstCall().returns(Promise.reject(error)).onSecondCall().returns(Promise.resolve(fakeJoinResult));
+          const leaveStub = sinon.stub(meeting, 'leave').resolves();
+
+          const result = await meeting.joinWithMedia({
+            joinOptions,
+            mediaOptions,
+          });
+
+          assert.calledOnce(abortTurnDiscoveryStub);
+          assert.calledTwice(meeting.join);
+          assert.notCalled(leaveStub);
+
+          assert.calledOnce(Metrics.sendBehavioralMetric);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric.firstCall,
+            BEHAVIORAL_METRICS.JOIN_WITH_MEDIA_FAILURE,
+            {
+              correlation_id: meeting.correlationId,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              reason: error.message,
+              stack: error.stack,
+              leaveErrorReason: undefined,
+              isRetry: false,
+            },
+            {
+              type: error.name,
+            }
+          );
+
+          assert.deepEqual(result, {join: fakeJoinResult, media: test4});
+
+          // resets joinWithMediaRetryInfo
+          assert.deepEqual(meeting.joinWithMediaRetryInfo, {isRetry: false, prevJoinResponse: undefined});
         });
 
         it('should fail if called with allowMediaInLobby:false', async () => {
@@ -767,8 +828,26 @@ describe('plugin-meetings', () => {
             reason: 'joinWithMedia failure',
           });
 
+
+          // Behavioral metric is sent on both calls of joinWithMedia
+          assert.calledTwice(Metrics.sendBehavioralMetric);
           assert.calledWith(
-            Metrics.sendBehavioralMetric,
+            Metrics.sendBehavioralMetric.firstCall,
+            BEHAVIORAL_METRICS.JOIN_WITH_MEDIA_FAILURE,
+            {
+              correlation_id: meeting.correlationId,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              reason: addMediaError.message,
+              stack: addMediaError.stack,
+              leaveErrorReason: undefined,
+              isRetry: false,
+            },
+            {
+              type: addMediaError.name,
+            }
+          );
+          assert.calledWith(
+            Metrics.sendBehavioralMetric.secondCall,
             BEHAVIORAL_METRICS.JOIN_WITH_MEDIA_FAILURE,
             {
               correlation_id: meeting.correlationId,
@@ -776,6 +855,47 @@ describe('plugin-meetings', () => {
               reason: addMediaError.message,
               stack: addMediaError.stack,
               leaveErrorReason: leaveError.message,
+              isRetry: true,
+            },
+            {
+              type: addMediaError.name,
+            }
+          );
+        });
+
+        it('should not call leave() if addMedia fails the first time and succeeds the second time and should only call join() once', async () => {
+          const addMediaError = new Error('fake addMedia error');
+          const leaveError = new Error('leave error');
+          const leaveStub = sinon.stub(meeting, 'leave').rejects(leaveError);
+
+          meeting.addMedia = sinon
+            .stub()
+            .onFirstCall()
+            .rejects(addMediaError)
+            .onSecondCall()
+            .resolves(test4);
+
+          const result = await meeting.joinWithMedia({
+            joinOptions,
+            mediaOptions,
+          });
+
+          assert.deepEqual(result, {join: fakeJoinResult, media: test4});
+
+          assert.calledOnce(meeting.join);
+          assert.notCalled(leaveStub);
+
+          assert.calledOnce(Metrics.sendBehavioralMetric);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric.firstCall,
+            BEHAVIORAL_METRICS.JOIN_WITH_MEDIA_FAILURE,
+            {
+              correlation_id: meeting.correlationId,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              reason: addMediaError.message,
+              stack: addMediaError.stack,
+              leaveErrorReason: undefined,
+              isRetry: false,
             },
             {
               type: addMediaError.name,
@@ -786,12 +906,12 @@ describe('plugin-meetings', () => {
 
       describe('#isTranscriptionSupported', () => {
         it('should return false if the feature is not supported for the meeting', () => {
-          meeting.locusInfo.controls = {transcribe: {transcribing: false}};
+          meeting.locusInfo.controls = {transcribe: {caption: false}};
 
           assert.equal(meeting.isTranscriptionSupported(), false);
         });
         it('should return true if webex assitant is enabled', () => {
-          meeting.locusInfo.controls = {transcribe: {transcribing: true}};
+          meeting.locusInfo.controls = {transcribe: {caption: true}};
 
           assert.equal(meeting.isTranscriptionSupported(), true);
         });
@@ -802,7 +922,7 @@ describe('plugin-meetings', () => {
           webex.internal.voicea.on = sinon.stub();
           webex.internal.voicea.off = sinon.stub();
           webex.internal.voicea.listenToEvents = sinon.stub();
-          webex.internal.voicea.toggleTranscribing = sinon.stub();
+          webex.internal.voicea.turnOnCaptions = sinon.stub();
         });
 
         it('should subscribe to events for the first time and avoid subscribing for future transcription starts', async () => {
@@ -817,17 +937,16 @@ describe('plugin-meetings', () => {
           assert.equal(webex.internal.voicea.on.callCount, 4);
           assert.equal(meeting.areVoiceaEventsSetup, true);
           assert.equal(webex.internal.voicea.listenToEvents.callCount, 1);
-          assert.calledWith(webex.internal.voicea.toggleTranscribing, true);
+          assert.called(webex.internal.voicea.turnOnCaptions);
 
           await meeting.startTranscription();
           assert.equal(webex.internal.voicea.on.callCount, 4);
           assert.equal(meeting.areVoiceaEventsSetup, true);
           assert.equal(webex.internal.voicea.listenToEvents.callCount, 1);
-          assert.calledTwice(webex.internal.voicea.toggleTranscribing);
-          assert.calledWith(webex.internal.voicea.toggleTranscribing, true);
+          assert.calledTwice(webex.internal.voicea.turnOnCaptions);
         });
 
-        it('should listen to events and not toggleTranscribing if the user is not a host', async () => {
+        it('should listen to events and not turnOnCaptions if the user is not a host', async () => {
           meeting.joinedWith = {
             state: 'JOINED',
           };
@@ -839,7 +958,7 @@ describe('plugin-meetings', () => {
           assert.equal(webex.internal.voicea.on.callCount, 4);
           assert.equal(meeting.areVoiceaEventsSetup, true);
           assert.equal(webex.internal.voicea.listenToEvents.callCount, 1);
-          assert.notCalled(webex.internal.voicea.toggleTranscribing);
+          assert.notCalled(webex.internal.voicea.turnOnCaptions);
         });
 
         it("should throw error if request doesn't work", async () => {
@@ -858,7 +977,7 @@ describe('plugin-meetings', () => {
           webex.internal.voicea.on = sinon.stub();
           webex.internal.voicea.off = sinon.stub();
           webex.internal.voicea.listenToEvents = sinon.stub();
-          webex.internal.voicea.toggleTranscribing = sinon.stub();
+          webex.internal.voicea.turnOnCaptions = sinon.stub();
         });
 
         it('should stop listening to voicea events and also trigger a stop event', () => {
@@ -1183,6 +1302,31 @@ describe('plugin-meetings', () => {
           );
         });
       });
+
+      describe('#handleLLMOnline', () => {
+        beforeEach(() => {
+          webex.internal.llm.off = sinon.stub();
+        });
+
+        it('turns off llm online, emits transcription connected events', () => {
+          meeting.handleLLMOnline();
+          assert.calledOnceWithExactly(
+            webex.internal.llm.off,
+            'online',
+            meeting.handleLLMOnline
+          );
+          assert.calledWith(
+            TriggerProxy.trigger,
+            sinon.match.instanceOf(Meeting),
+            {
+              file: 'meeting/index',
+              function: 'handleLLMOnline',
+            },
+            EVENT_TRIGGERS.MEETING_TRANSCRIPTION_CONNECTED
+          );
+        });
+      });
+
       describe('#join', () => {
         let sandbox = null;
         let setCorrelationIdSpy;
@@ -1232,15 +1376,10 @@ describe('plugin-meetings', () => {
             assert.calledOnce(MeetingUtil.joinMeeting);
             assert.calledOnce(meeting.setLocus);
             assert.equal(result, joinMeetingResult);
-
             assert.calledWith(
-              TriggerProxy.trigger,
-              sinon.match.instanceOf(Meeting),
-              {
-                file: 'meeting/index',
-                function: 'join',
-              },
-              EVENT_TRIGGERS.MEETING_TRANSCRIPTION_CONNECTED
+              webex.internal.llm.on,
+              'online',
+              meeting.handleLLMOnline
             );
           });
 
@@ -1531,7 +1670,7 @@ describe('plugin-meetings', () => {
           };
           meeting.mediaProperties.setMediaDirection = sinon.stub().returns(true);
           meeting.mediaProperties.waitForMediaConnectionConnected = sinon.stub().resolves();
-          meeting.mediaProperties.getCurrentConnectionType = sinon.stub().resolves('udp');
+          meeting.mediaProperties.getCurrentConnectionInfo = sinon.stub().resolves({connectionType: 'udp', selectedCandidatePairChanges: 2, numTransports: 1});
           meeting.audio = muteStateStub;
           meeting.video = muteStateStub;
           sinon.stub(Media, 'createMediaConnection').returns(fakeMediaConnection);
@@ -1631,11 +1770,14 @@ describe('plugin-meetings', () => {
               turnServerUsed: true,
               retriedWithTurnServer: false,
               isMultistream: false,
+              isJoinWithMediaRetry: false,
               signalingState: 'unknown',
               connectionState: 'unknown',
               iceConnectionState: 'unknown',
               someReachabilityMetric1: 'some value1',
               someReachabilityMetric2: 'some value2',
+              selectedCandidatePairChanges: 2,
+              numTransports: 1,
             }
           );
         });
@@ -1735,11 +1877,14 @@ describe('plugin-meetings', () => {
               turnServerUsed: true,
               retriedWithTurnServer: false,
               isMultistream: false,
+              isJoinWithMediaRetry: false,
               signalingState: 'unknown',
               connectionState: 'unknown',
               iceConnectionState: 'unknown',
               someReachabilityMetric1: 'some value1',
               someReachabilityMetric2: 'some value2',
+              selectedCandidatePairChanges: 2,
+              numTransports: 1,
             }
           );
         });
@@ -2213,9 +2358,12 @@ describe('plugin-meetings', () => {
               turnServerUsed: true,
               retriedWithTurnServer: true,
               isMultistream: false,
+              isJoinWithMediaRetry: false,
               signalingState: 'unknown',
               connectionState: 'unknown',
               iceConnectionState: 'unknown',
+              selectedCandidatePairChanges: 2,
+              numTransports: 1,
             },
           ]);
 
@@ -2394,8 +2542,11 @@ describe('plugin-meetings', () => {
               correlation_id: meeting.correlationId,
               locus_id: meeting.locusUrl.split('/').pop(),
               connectionType: 'udp',
+              selectedCandidatePairChanges: 2,
+              numTransports: 1,
               isMultistream: false,
               retriedWithTurnServer: true,
+              isJoinWithMediaRetry: false,
             },
           ]);
           meeting.roap.doTurnDiscovery;
@@ -2536,8 +2687,11 @@ describe('plugin-meetings', () => {
               correlation_id: meeting.correlationId,
               locus_id: meeting.locusUrl.split('/').pop(),
               connectionType: 'udp',
+              selectedCandidatePairChanges: 2,
+              numTransports: 1,
               isMultistream: false,
               retriedWithTurnServer: false,
+              isJoinWithMediaRetry: false,
               someReachabilityMetric1: 'some value1',
               someReachabilityMetric2: 'some value2',
             }
@@ -2596,9 +2750,12 @@ describe('plugin-meetings', () => {
               turnServerUsed: true,
               retriedWithTurnServer: false,
               isMultistream: false,
+              isJoinWithMediaRetry: false,
               signalingState: 'unknown',
               connectionState: 'unknown',
               iceConnectionState: 'unknown',
+              selectedCandidatePairChanges: 2,
+              numTransports: 1,
             }
           );
 
@@ -3017,7 +3174,7 @@ describe('plugin-meetings', () => {
             meeting.mediaId = 'fake media id';
             meeting.selfUrl = 'selfUrl';
             meeting.mediaProperties.waitForMediaConnectionConnected = sinon.stub().resolves();
-            meeting.mediaProperties.getCurrentConnectionType = sinon.stub().resolves('udp');
+            meeting.mediaProperties.getCurrentConnectionInfo = sinon.stub().resolves({connectionType: 'udp', selectedCandidatePairChanges: 2, numTransports: 1});
             meeting.setMercuryListener = sinon.stub();
             meeting.locusInfo.onFullLocus = sinon.stub();
             meeting.webex.meetings.geoHintInfo = {regionCode: 'EU', countryCode: 'UK'};
@@ -6029,11 +6186,22 @@ describe('plugin-meetings', () => {
 
         beforeEach(() => {
           sandbox = sinon.createSandbox();
-          sandbox.stub(meeting, 'cleanupLocalStreams');
+          meeting.statsAnalyzer = {
+            stopAnalyzer: sinon.stub().returns(Promise.resolve())
+          };
 
-          sandbox.stub(meeting.mediaProperties, 'setMediaDirection');
+          meeting.reconnectionManager = {
+            cleanUp: sinon.stub()
+          };
+
+          meeting.cleanupLocalStreams=sinon.stub();
+          meeting.closeRemoteStreams = sinon.stub().returns(Promise.resolve());
+          meeting.closePeerConnections = sinon.stub().returns(Promise.resolve());
+          meeting.unsetRemoteStreams = sinon.stub();
+          meeting.unsetPeerConnections = sinon.stub();
+          meeting.addMedia = sinon.stub().returns(Promise.resolve());
+          meeting.mediaProperties.setMediaDirection = sinon.stub();
 
-          sandbox.stub(meeting.reconnectionManager, 'reconnectMedia').returns(Promise.resolve());
           sandbox
             .stub(MeetingUtil, 'joinMeeting')
             .returns(
@@ -6095,9 +6263,11 @@ describe('plugin-meetings', () => {
           });
         });
 
-        it('should reconnectMedia after DX joins after moveTo', async () => {
+        it('should cleanup on moveTo & addMedia after', async () => {
           await meeting.moveTo('resourceId');
 
+          assert.equal(meeting.isMoveToInProgress, true);
+
           await meeting.locusInfo.emitScoped(
             {
               file: 'locus-info',
@@ -6105,26 +6275,26 @@ describe('plugin-meetings', () => {
             },
             'SELF_OBSERVING'
           );
+          
 
-          // beacuse we are calling callback so we need to wait
-
-          assert.called(meeting.cleanupLocalStreams);
-
-          // give queued Promise callbacks a chance to run
-          await Promise.resolve();
-
-          assert.called(meeting.mediaProperties.setMediaDirection);
-
-          assert.calledWith(meeting.reconnectionManager.reconnectMedia, {
-            mediaDirection: {
-              sendVideo: false,
-              receiveVideo: false,
-              sendAudio: false,
-              receiveAudio: false,
-              sendShare: false,
-              receiveShare: true,
-            },
-          });
+          // Verify that the event handler behaves as expected
+          expect(meeting.statsAnalyzer.stopAnalyzer.calledOnce).to.be.true;
+          expect(meeting.closeRemoteStreams.calledOnce).to.be.true;
+          await testUtils.flushPromises();
+          expect(meeting.closePeerConnections.calledOnce).to.be.true;
+          await testUtils.flushPromises();
+          expect(meeting.cleanupLocalStreams.calledOnce).to.be.true;
+          expect(meeting.unsetRemoteStreams.calledOnce).to.be.true;
+          expect(meeting.unsetPeerConnections.calledOnce).to.be.true;
+          expect(meeting.reconnectionManager.cleanUp.calledOnce).to.be.true;
+          expect(meeting.mediaProperties.setMediaDirection.calledOnce).to.be.true;
+          expect(meeting.addMedia.calledOnceWithExactly({
+            audioEnabled: false,
+            videoEnabled: false,
+            shareVideoEnabled: true
+          })).to.be.true;
+          await testUtils.flushPromises();
+          assert.equal(meeting.isMoveToInProgress, false);
         });
 
         it('should throw an error if moveTo call fails', async () => {
@@ -6132,6 +6302,7 @@ describe('plugin-meetings', () => {
           try {
             await meeting.moveTo('resourceId');
           } catch {
+            assert.equal(meeting.isMoveToInProgress, false);
             assert.calledOnce(Metrics.sendBehavioralMetric);
             assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.MOVE_TO_FAILURE, {
               correlation_id: meeting.correlationId,
@@ -6153,6 +6324,7 @@ describe('plugin-meetings', () => {
               'SELF_OBSERVING'
             );
           } catch {
+            assert.equal(meeting.isMoveToInProgress, false);
             assert.calledOnce(Metrics.sendBehavioralMetric);
             assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.MOVE_TO_FAILURE, {
               correlation_id: meeting.correlationId,
@@ -6778,21 +6950,13 @@ describe('plugin-meetings', () => {
               }),
             };
             meeting.setupMediaConnectionListeners();
-            meeting.deferSDPAnswer = {
-              resolve: sinon.stub(),
-              reject: sinon.stub(),
-            };
             meeting.sdpResponseTimer = '1234';
-            meeting.mediaProperties.waitForMediaConnectionConnected = sinon.stub().resolves();
+            sinon.stub(meeting.mediaProperties, 'waitForMediaConnectionConnected').resolves();
 
-            eventListeners[Event.REMOTE_SDP_ANSWER_PROCESSED]();
             meeting.config.reconnection.enabled = true;
             meeting.currentMediaStatus = {audio: true};
             meeting.reconnectionManager = new ReconnectionManager(meeting);
-            meeting.reconnectionManager.reconnect = sinon.stub().returns(Promise.resolve());
-            meeting.reconnectionManager.reset = sinon.stub().returns(true);
-            meeting.reconnectionManager.cleanup = sinon.stub().returns(true);
-            meeting.reconnectionManager.setStatus = sinon.stub();
+            sinon.stub(meeting.reconnectionManager, 'reconnect').returns(Promise.resolve());
           });
 
           it('should throw error if media not established before trying reconnect', async () => {
@@ -6812,87 +6976,72 @@ describe('plugin-meetings', () => {
             }
           });
 
-          it('should trigger reconnection success and send CA metric', async () => {
-            await meeting.reconnect();
+          it('should call the right functions', async () => {
+            const options = {id: 'fake options'};
+            await meeting.reconnect(options);
+
+            sinon.stub(meeting, 'waitForRemoteSDPAnswer').resolves();
 
-            assert.calledWith(
-              TriggerProxy.trigger,
-              sinon.match.instanceOf(Meeting),
-              {file: 'meeting/index', function: 'reconnect'},
-              'meeting:reconnectionSuccess'
-            );
-            assert.calledWithMatch(webex.internal.newMetrics.submitClientEvent, {
-              name: 'client.media.recovered',
-              payload: {
-                recoveredBy: 'new',
-              },
-              options: {
-                meetingId: meeting.id,
-              },
-            });
             assert.calledOnceWithExactly(
-              meeting.reconnectionManager.setStatus,
-              RECONNECTION.STATE.COMPLETE
+              meeting.reconnectionManager.reconnect,
+              options,
+              sinon.match.any
             );
-          });
+            const callback = meeting.reconnectionManager.reconnect.getCalls()[0].args[1];
 
-          it('should reset after reconnection success', async () => {
-            await meeting.reconnect();
-            assert.calledOnce(meeting.reconnectionManager.reset);
+            // call the completion callback
+            assert.isFunction(callback);
+            await callback();
+
+            // check that the right things were called by the callback
+            assert.calledOnceWithExactly(meeting.waitForRemoteSDPAnswer);
+            assert.calledOnceWithExactly(meeting.mediaProperties.waitForMediaConnectionConnected);
           });
         });
 
         describe('unsuccessful reconnect', () => {
+          let logUploadSpy;
+
           beforeEach(() => {
-            meeting.config.reconnection.enabled = true;
+            logUploadSpy = sinon.spy(meeting, 'uploadLogs');
             meeting.currentMediaStatus = {audio: true};
             meeting.reconnectionManager = new ReconnectionManager(meeting);
             meeting.reconnectionManager.reconnect = sinon
               .stub()
               .returns(Promise.reject(new Error()));
-            meeting.reconnectionManager.reset = sinon.stub().returns(true);
           });
 
-          it('should trigger an unsuccessful reconnection', async () => {
+          it('should upload logs on reconnect failure', async () => {
             await assert.isRejected(meeting.reconnect());
             assert.calledWith(
               TriggerProxy.trigger,
               sinon.match.instanceOf(Meeting),
               {file: 'meeting/index', function: 'reconnect'},
-              'meeting:reconnectionFailure',
-              {error: sinon.match.any}
+              EVENTS.REQUEST_UPLOAD_LOGS,
+              sinon.match.instanceOf(Meeting)
             );
           });
 
-          it('should send metrics on reconnect failure', async () => {
+          it('should fail without uploading logs if there is no reconnectionManager', async () => {
+            meeting.reconnectionManager = null;
             await assert.isRejected(meeting.reconnect());
-            assert(Metrics.sendBehavioralMetric.calledOnce);
-            assert.calledWith(
-              Metrics.sendBehavioralMetric,
-              BEHAVIORAL_METRICS.MEETING_RECONNECT_FAILURE,
-              {
-                correlation_id: meeting.correlationId,
-                locus_id: meeting.locusUrl.split('/').pop(),
-                reason: sinon.match.any,
-                stack: sinon.match.any,
-              }
-            );
+            assert.notCalled(logUploadSpy);
           });
 
-          it('should upload logs on reconnect failure', async () => {
+          it('should fail without uploading logs if there is no media established', async () => {
+            meeting.currentMediaStatus = null;
             await assert.isRejected(meeting.reconnect());
-            assert.calledWith(
-              TriggerProxy.trigger,
-              sinon.match.instanceOf(Meeting),
-              {file: 'meeting/index', function: 'reconnect'},
-              EVENTS.REQUEST_UPLOAD_LOGS,
-              sinon.match.instanceOf(Meeting)
-            );
+            assert.notCalled(logUploadSpy);
           });
 
-          it('should reset after an unsuccessful reconnection', async () => {
-            await assert.isRejected(meeting.reconnect());
-            assert.calledOnce(meeting.reconnectionManager.reset);
+          it('should resolve if the error is ReconnectionNotStartedError', async () => {
+            meeting.reconnectionManager.reconnect.returns(
+              Promise.reject(new ReconnectionNotStartedError())
+            );
+            await meeting.reconnect();
+
+            // logs shouldn't be uploaded
+            assert.notCalled(logUploadSpy);
           });
         });
       });
@@ -7738,6 +7887,7 @@ describe('plugin-meetings', () => {
       describe('#setUpLocusInfoSelfListener', () => {
         it('listens to the self unadmitted guest event', (done) => {
           meeting.startKeepAlive = sinon.stub();
+          meeting.updateLLMConnection = sinon.stub();
           meeting.locusInfo.emit({function: 'test', file: 'test'}, 'SELF_UNADMITTED_GUEST', test1);
           assert.calledOnceWithExactly(meeting.startKeepAlive);
           assert.calledThrice(TriggerProxy.trigger);
@@ -7748,6 +7898,7 @@ describe('plugin-meetings', () => {
             'meeting:self:lobbyWaiting',
             {payload: test1}
           );
+          assert.calledOnce(meeting.updateLLMConnection);
           done();
         });
         it('listens to the self admitted guest event', (done) => {
@@ -8100,6 +8251,21 @@ describe('plugin-meetings', () => {
             EVENT_TRIGGERS.MEETING_INTERPRETATION_UPDATE
           );
         });
+
+        it('listens to the locus manual caption update event', () => {
+          meeting.locusInfo.emit(
+            {function: 'test', file: 'test'},
+            'CONTROLS_MEETING_MANUAL_CAPTION_UPDATED',
+            {enable: true}
+          );
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setupLocusControlsListener'},
+            EVENT_TRIGGERS.MEETING_MANUAL_CAPTION_UPDATED
+          );
+        });
       });
 
       describe('#setUpLocusUrlListener', () => {