@webex/plugin-meetings 3.12.0-next.7 → 3.12.0-next.70

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

@@ -11,6 +11,7 @@ describe('plugin-meetings', () => {
   let audio;
   let video;
   let originalRemoteUpdateAudioVideo;
+  let originalUpdateLocusFromApiResponse;
 
   const fakeLocusResponse = {body: {locus: {info: 'this is a fake locus'}}};
 
@@ -45,6 +46,7 @@ describe('plugin-meetings', () => {
     };
 
     originalRemoteUpdateAudioVideo = MeetingUtil.remoteUpdateAudioVideo;
+    originalUpdateLocusFromApiResponse = MeetingUtil.updateLocusFromApiResponse;
 
     MeetingUtil.remoteUpdateAudioVideo = sinon.stub().resolves(fakeLocusResponse);
     MeetingUtil.updateLocusFromApiResponse = sinon.stub();
@@ -57,6 +59,7 @@ describe('plugin-meetings', () => {
 
   afterEach(() => {
     MeetingUtil.remoteUpdateAudioVideo = originalRemoteUpdateAudioVideo;
+    MeetingUtil.updateLocusFromApiResponse = originalUpdateLocusFromApiResponse;
   });
 
   describe('mute state library', () => {
@@ -109,6 +112,82 @@ describe('plugin-meetings', () => {
       assert.isTrue(audio.isRemotelyMuted());
     });
 
+    it('does not unmute the local stream when server clears remote mute while user is locally muted (breakout -> main regression)', async () => {
+      // Panelist is locally muted before joining a breakout.
+      meeting.mediaProperties.audioStream.userMuted = true;
+      audio.handleLocalStreamChange(meeting);
+      await testUtils.flushPromises();
+
+      // Server applied a remote mute at some point.
+      audio.handleServerRemoteMuteUpdate(meeting, true, true);
+      assert.isTrue(audio.isRemotelyMuted());
+
+      meeting.mediaProperties.audioStream.setServerMuted.resetHistory();
+
+      // Now the user returns from breakout to main, and Locus clears the remote mute.
+      audio.handleServerRemoteMuteUpdate(meeting, false, true);
+
+      // Stream must NOT be force-unmuted - user's local mute intent must be preserved.
+      // The stale remoteMute=false must not trigger setServerMuted again.
+      assert.notCalled(meeting.mediaProperties.audioStream.setServerMuted);
+      assert.isFalse(audio.isRemotelyMuted());
+      assert.isTrue(audio.isMuted());
+    });
+
+    it('does not touch the local stream when remote mute stays false (no transition)', async () => {
+      // No remote mute has been applied yet (initial state has server.remoteMute=false).
+      meeting.mediaProperties.audioStream.setServerMuted.resetHistory();
+
+      audio.handleServerRemoteMuteUpdate(meeting, false, true);
+
+      // setServerMuted must not be called - there is no remoteMute transition to act on.
+      assert.notCalled(meeting.mediaProperties.audioStream.setServerMuted);
+    });
+
+    it('keeps isMuted() true when a stale remoteMute=false replays after remote mute', async () => {
+      // User was unmuted by host (userMuted=false locally).
+      meeting.mediaProperties.audioStream.userMuted = false;
+      audio.handleLocalStreamChange(meeting);
+      await testUtils.flushPromises();
+
+      // Host then hard-mutes the user.
+      audio.handleServerRemoteMuteUpdate(meeting, true, true);
+      await testUtils.flushPromises();
+      assert.isTrue(audio.isMuted());
+
+      meeting.mediaProperties.audioStream.setServerMuted.resetHistory();
+
+      // BO -> main replays a stale remoteMute=false from the locus cache.
+      audio.handleServerRemoteMuteUpdate(meeting, false, true);
+
+      // isMuted() must remain true (client.localMute is the safety net),
+      // and the stream must not be force-unmuted.
+      assert.isTrue(audio.isMuted());
+      assert.isFalse(audio.isRemotelyMuted());
+      assert.notCalled(meeting.mediaProperties.audioStream.setServerMuted);
+    });
+
+    it('syncs client mute intent back to server on stale remoteMute=false', async () => {
+      // client wants mute (localMute=true) but server's
+      // local-mute is out of sync (=false) - e.g. an attendee promoted to panelist whose
+      // server-side mute state got mis-set during promotion. remoteMute is currently true.
+      audio.state.client.localMute = true;
+      audio.state.server.localMute = false;
+      audio.state.server.remoteMute = true;
+
+      MeetingUtil.remoteUpdateAudioVideo.resetHistory();
+
+      // Stale event after BO -> main clears remoteMute.
+      audio.handleServerRemoteMuteUpdate(meeting, false, true);
+      await testUtils.flushPromises();
+
+      // applyClientStateToServer must detect the mismatch and push local mute back
+      // to server, so server.controls.audio.muted stays true for other participants' tiles.
+      assert.calledOnce(MeetingUtil.remoteUpdateAudioVideo);
+      assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, meeting, true, undefined);
+      assert.isTrue(audio.isMuted());
+    });
+
     it('does local audio unmute if localAudioUnmuteRequired is received', async () => {
       // first we need to have the local stream user muted
       meeting.mediaProperties.audioStream.userMuted = true;
@@ -826,6 +905,8 @@ describe('plugin-meetings', () => {
       it('does not do anything if current state is already the same', async () => {
         // set it up so that we are remotely muted (so that a sync to server would do a remote unmute)
         audio.handleServerRemoteMuteUpdate(meeting, true, true);
+        await testUtils.flushPromises();
+        resetStubHistory();
 
         // audio is already enabled and we call to enable it again
         audio.enable(meeting, true);

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

@@ -347,6 +347,18 @@ describe('plugin-meetings', () => {
           'ANNOTATION_ON_SHARE_SUPPORTED',
         ]);
       });
+      it('adds deviceCapabilities to request when simultaneous interpretation is enabled', async () => {
+        await meetingsRequest.joinMeeting({
+          enableSimultaneousInterpretation: true,
+        });
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
+        assert.deepEqual(requestParams.body.deviceCapabilities, [
+          'HOST_CONTROL_SI_SUPPORTED',
+          'INTERPRETER_CONTROL_SI_SUPPORTED',
+          'SI_HANDOVER_SUPPORTED',
+          'SIGN_INTERPRETER_SUPPORTED',
+        ]);
+      });
       it('does not add deviceCapabilities to request when breakouts and live annotation are not supported', async () => {
         await meetingsRequest.joinMeeting({});
 

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

@@ -60,6 +60,7 @@ describe('plugin-meetings', () => {
       meeting.annotaion = {cleanUp: sinon.stub()};
       meeting.getWebexObject = sinon.stub().returns(webex);
       meeting.simultaneousInterpretation = {cleanUp: sinon.stub()};
+      meeting.locusInfo = {cleanUp: sinon.stub()};
       meeting.trigger = sinon.stub();
       meeting.webex = webex;
       meeting.webex.internal.newMetrics.callDiagnosticMetrics =
@@ -89,6 +90,7 @@ describe('plugin-meetings', () => {
         assert.calledOnceWithExactly(meeting.cleanupLLMConneciton, {throwOnError: false});
         assert.calledOnce(meeting.breakouts.cleanUp);
         assert.calledOnce(meeting.simultaneousInterpretation.cleanUp);
+        assert.calledOnce(meeting.locusInfo.cleanUp);
         assert.calledOnce(webex.internal.device.meetingEnded);
         assert.calledOnceWithExactly(
           meeting.webex.internal.newMetrics.callDiagnosticMetrics.clearEventLimitsForCorrelationId,
@@ -110,6 +112,7 @@ describe('plugin-meetings', () => {
         assert.notCalled(meeting.cleanupLLMConneciton);
         assert.calledOnce(meeting.breakouts.cleanUp);
         assert.calledOnce(meeting.simultaneousInterpretation.cleanUp);
+        assert.calledOnce(meeting.locusInfo.cleanUp);
         assert.calledOnce(webex.internal.device.meetingEnded);
         assert.calledOnceWithExactly(
           meeting.webex.internal.newMetrics.callDiagnosticMetrics.clearEventLimitsForCorrelationId,
@@ -130,6 +133,7 @@ describe('plugin-meetings', () => {
         assert.notCalled(meeting.cleanupLLMConneciton);
         assert.calledOnce(meeting.breakouts.cleanUp);
         assert.calledOnce(meeting.simultaneousInterpretation.cleanUp);
+        assert.calledOnce(meeting.locusInfo.cleanUp);
         assert.calledOnce(webex.internal.device.meetingEnded);
         assert.calledOnceWithExactly(
           meeting.webex.internal.newMetrics.callDiagnosticMetrics.clearEventLimitsForCorrelationId,
@@ -272,6 +276,31 @@ describe('plugin-meetings', () => {
         assert.notCalled(meeting.locusInfo.handleLocusAPIResponse);
       });
 
+      it('should call handleLocusAPIResponse when response body is an unwrapped LocusDTO', () => {
+        const meeting = {
+          locusInfo: {
+            handleLocusAPIResponse: sinon.stub(),
+          },
+        };
+
+        const originalResponse = {
+          body: {
+            url: 'https://locus-a.wbx2.com/locus/api/v1/loci/some-id',
+            participants: [],
+            self: {},
+          },
+        };
+
+        const response = MeetingUtil.updateLocusFromApiResponse(meeting, originalResponse);
+
+        assert.deepEqual(response, originalResponse);
+        assert.calledOnceWithExactly(
+          meeting.locusInfo.handleLocusAPIResponse,
+          meeting,
+          originalResponse.body
+        );
+      });
+
       it('should work with an undefined meeting', () => {
         const originalResponse = {
           body: {
@@ -1146,6 +1175,10 @@ describe('plugin-meetings', () => {
       {functionName: 'canSelectSpokenLanguages', displayHint: 'DISPLAY_NON_ENGLISH_ASR'},
       {functionName: 'waitingForOthersToJoin', displayHint: 'WAITING_FOR_OTHERS'},
       {functionName: 'showAutoEndMeetingWarning', displayHint: 'SHOW_AUTO_END_MEETING_WARNING'},
+      {
+        functionName: 'isAnonymizeDisplayNamesEnabled',
+        displayHint: 'ANONYMOUS_DISPLAY_NAMES_ENABLED',
+      },
     ].forEach(({functionName, displayHint}) => {
       describe(functionName, () => {
         it('works as expected', () => {

package/test/unit/spec/meeting-info/meetinginfov2.js

@@ -654,7 +654,7 @@ describe('plugin-meetings', () => {
           meetingInfo.createAdhocSpaceMeeting,
           'conversationUrl',
           installedOrgID,
-          null,
+          null
         );
         assert.notCalled(webex.request);
         meetingInfo.createAdhocSpaceMeeting.restore();
@@ -1068,13 +1068,16 @@ describe('plugin-meetings', () => {
           await runTest(423006, true);
         });
 
+        it('should throw MeetingInfoV2CaptchaError for 423 response (wbxappapi code 423008)', async () => {
+          await runTest(423008, true);
+        });
+
         it('should throw MeetingInfoV2CaptchaError for 423 response (wbxappapi code 423001)', async () => {
           await runTest(423001, false);
         });
       });
 
       describe('should stop call fetchMeetingInfo if siteFullUrl is empty for 404 response', () => {
-
         const runTest = async (wbxAppApiCode, expectedIsPasswordRequired) => {
           webex.request = sinon.stub().rejects({
             statusCode: 404,
@@ -1082,12 +1085,11 @@ describe('plugin-meetings', () => {
               code: wbxAppApiCode,
               message: 'Alternate Meeting Server',
               data: {
-                'siteFullUrl': ''
-              }
+                siteFullUrl: '',
+              },
             },
           });
 
-
           try {
             await meetingInfo.fetchMeetingInfo('1234323', DESTINATION_TYPE.MEETING_ID, 'abc', {
               id: '999',
@@ -1097,7 +1099,7 @@ describe('plugin-meetings', () => {
           } catch (err) {
             assert(Metrics.sendBehavioralMetric.calledOnce);
             assert.deepEqual(err.body.data, {
-              siteFullUrl: ''
+              siteFullUrl: '',
             });
           }
         };
@@ -1107,7 +1109,6 @@ describe('plugin-meetings', () => {
         });
       });
 
-
       it('should throw an error and not fetch with an "empty" body', async () => {
         const body = {supportHostKey: 'foo', supportCountryList: 'bar'};
         const requestResponse = {statusCode: 200, body};
@@ -1176,7 +1177,11 @@ describe('plugin-meetings', () => {
           body: conversation,
         });
 
-        const result = await meetingInfo.createAdhocSpaceMeeting(conversationUrl, installedOrgID, classificationId);
+        const result = await meetingInfo.createAdhocSpaceMeeting(
+          conversationUrl,
+          installedOrgID,
+          classificationId
+        );
 
         assert.calledWith(webex.request, {
           uri: conversationUrl,
@@ -1210,7 +1215,11 @@ describe('plugin-meetings', () => {
         webex.request = sinon.stub().resolves({
           body: conversation,
         });
-        await meetingInfo.createAdhocSpaceMeeting(conversationUrl, installedOrgID, classificationId);
+        await meetingInfo.createAdhocSpaceMeeting(
+          conversationUrl,
+          installedOrgID,
+          classificationId
+        );
 
         assert.calledWith(webex.request, {
           uri: conversationUrl,
@@ -1282,7 +1291,7 @@ describe('plugin-meetings', () => {
           {errorCode: 423007},
           {errorCode: 403026},
           {errorCode: 403037},
-          {errorCode: 403137},
+          {errorCode: 403106},
         ],
         ({errorCode}) => {
           it(`should throw a MeetingInfoV2JoinWebinarError for error code ${errorCode}`, async () => {