@webex/plugin-meetings 3.12.0-next.9 → 3.12.0-next.91

package/test/unit/spec/meeting/locusMediaRequest.ts

@@ -13,11 +13,15 @@ import {
 import testUtils from '../../../utils/testUtils';
 import {Defer} from '@webex/common';
 import {IP_VERSION} from '../../../../src/constants';
+import Metrics from '../../../../src/metrics';
+import BEHAVIORAL_METRICS from '../../../../src/metrics/constants';
 
 describe('LocusMediaRequest.send()', () => {
   let locusMediaRequest: LocusMediaRequest;
   let webexRequestStub;
   let mockWebex;
+  let sendBehavioralMetricStub;
+  const waitForSelfUrlChange = () => Promise.resolve();
 
   const fakeLocusResponse = {
     locus: {something: 'whatever'},
@@ -50,8 +54,16 @@ describe('LocusMediaRequest.send()', () => {
       },
       ipver: IP_VERSION.only_ipv4,
       reachability: {
-        version: '1',
-        result: 'some fake reachability result',
+        version: 1,
+        result: {
+          usedDiscoveryOptions: {
+            'early-call-min-clusters': 3,
+          },
+          metrics: {
+            'total-duration-ms': 10,
+          },
+          tests: {},
+        },
       },
     },
   };
@@ -78,8 +90,16 @@ describe('LocusMediaRequest.send()', () => {
           timeShot: '2023-05-23T08:03:49Z',
         },
         reachability: {
-          version: '1',
-          result: 'some fake reachability result',
+          version: 1,
+          result: {
+            usedDiscoveryOptions: {
+              'early-call-min-clusters': 3,
+            },
+            metrics: {
+              'total-duration-ms': 10,
+            },
+            tests: {},
+          },
         },
       },
     };
@@ -132,6 +152,7 @@ describe('LocusMediaRequest.send()', () => {
         submitClientEvent: sinon.stub(),
       },
     };
+    sendBehavioralMetricStub = sinon.stub(Metrics, 'sendBehavioralMetric');
 
     locusMediaRequest = new LocusMediaRequest(
       {
@@ -143,6 +164,8 @@ describe('LocusMediaRequest.send()', () => {
         correlationId: 'correlationId',
         meetingId: 'meetingId',
         preferTranscoding: true,
+        getCurrentSelfUrl: () => undefined,
+        waitForSelfUrlChange,
       },
       {
         parent: mockWebex,
@@ -151,6 +174,10 @@ describe('LocusMediaRequest.send()', () => {
     webexRequestStub = sinon.stub(locusMediaRequest, 'request').resolves(fakeLocusResponse);
   });
 
+  afterEach(() => {
+    sendBehavioralMetricStub.restore();
+  });
+
   const sendLocalMute = (muteOptions, overrides = {}) =>
     locusMediaRequest.send({...exampleLocalMuteRequestBody, ...overrides, muteOptions});
 
@@ -167,6 +194,7 @@ describe('LocusMediaRequest.send()', () => {
 
     webexRequestStub.resetHistory();
     mockWebex.internal.newMetrics.submitClientEvent.resetHistory();
+    sendBehavioralMetricStub.resetHistory();
   };
 
   it('sends a roap message', async () => {
@@ -183,6 +211,276 @@ describe('LocusMediaRequest.send()', () => {
     });
   });
 
+  it('uses the latest resolved selfUrl when a queued roap message is sent', async () => {
+    let currentSelfUrl = 'oldSelfUrl';
+    locusMediaRequest = new LocusMediaRequest(
+      {
+        device: {
+          url: 'deviceUrl',
+          deviceType: 'deviceType',
+          regionCode: 'regionCode',
+        },
+        correlationId: 'correlationId',
+        meetingId: 'meetingId',
+        preferTranscoding: true,
+        getCurrentSelfUrl: () => currentSelfUrl,
+        waitForSelfUrlChange,
+      },
+      {
+        parent: mockWebex,
+      }
+    );
+    webexRequestStub = sinon.stub(locusMediaRequest, 'request').resolves(fakeLocusResponse);
+
+    const request = cloneDeep(exampleRoapRequestBody);
+
+    request.selfUrl = 'oldSelfUrl';
+    currentSelfUrl = 'newSelfUrl';
+
+    const result = await locusMediaRequest.send(request);
+
+    assert.equal(result, fakeLocusResponse);
+    assert.calledOnce(webexRequestStub);
+    assert.equal(webexRequestStub.getCall(0).args[0].uri, 'newSelfUrl/media');
+    assert.calledOnceWithExactly(
+      sendBehavioralMetricStub,
+      BEHAVIORAL_METRICS.LOCUS_MEDIA_REQUEST_RETRY,
+      {
+        correlation_id: 'correlationId',
+        reason: 'selfUrlUpdatedBeforeMediaRequest',
+      }
+    );
+  });
+
+  it('retries a roap message with the latest resolved selfUrl after a conflict', async () => {
+    let currentSelfUrl = 'oldSelfUrl';
+    const conflictError = {statusCode: 409, message: 'conflict'};
+
+    locusMediaRequest = new LocusMediaRequest(
+      {
+        device: {
+          url: 'deviceUrl',
+          deviceType: 'deviceType',
+          regionCode: 'regionCode',
+        },
+        correlationId: 'correlationId',
+        meetingId: 'meetingId',
+        preferTranscoding: true,
+        getCurrentSelfUrl: () => currentSelfUrl,
+        waitForSelfUrlChange,
+      },
+      {
+        parent: mockWebex,
+      }
+    );
+    webexRequestStub = sinon.stub(locusMediaRequest, 'request');
+    webexRequestStub.onFirstCall().callsFake(() => {
+      currentSelfUrl = 'newSelfUrl';
+
+      return Promise.reject(conflictError);
+    });
+    webexRequestStub.onSecondCall().resolves(fakeLocusResponse);
+
+    const request = cloneDeep(exampleRoapRequestBody);
+
+    request.selfUrl = 'oldSelfUrl';
+    request.roapMessage.messageType = 'ANSWER';
+
+    const result = await locusMediaRequest.send(request);
+
+    assert.equal(result, fakeLocusResponse);
+    assert.calledTwice(webexRequestStub);
+    assert.equal(webexRequestStub.getCall(0).args[0].uri, 'oldSelfUrl/media');
+    assert.equal(webexRequestStub.getCall(1).args[0].uri, 'newSelfUrl/media');
+    assert.calledWith(sendBehavioralMetricStub, BEHAVIORAL_METRICS.LOCUS_MEDIA_REQUEST_RETRY, {
+      correlation_id: 'correlationId',
+      reason: 'selfUrlUpdatedBeforeMediaRequest',
+    });
+    // The updated selfUrl is detected twice: once while deciding to retry and
+    // again when the request is re-resolved for the actual re-send.
+    assert.calledTwice(sendBehavioralMetricStub);
+  });
+
+  it('does not retry a roap conflict when the resolved selfUrl has not changed', async () => {
+    locusMediaRequest = new LocusMediaRequest(
+      {
+        device: {
+          url: 'deviceUrl',
+          deviceType: 'deviceType',
+          regionCode: 'regionCode',
+        },
+        correlationId: 'correlationId',
+        meetingId: 'meetingId',
+        preferTranscoding: true,
+        getCurrentSelfUrl: () => 'sameSelfUrl',
+        waitForSelfUrlChange,
+      },
+      {
+        parent: mockWebex,
+      }
+    );
+    webexRequestStub = sinon.stub(locusMediaRequest, 'request').rejects({
+      statusCode: 409,
+      message: 'conflict',
+    });
+
+    const request = cloneDeep(exampleRoapRequestBody);
+
+    request.selfUrl = 'sameSelfUrl';
+    request.roapMessage.messageType = 'ANSWER';
+
+    await assert.isRejected(locusMediaRequest.send(request));
+
+    assert.calledOnce(webexRequestStub);
+    assert.equal(webexRequestStub.getCall(0).args[0].uri, 'sameSelfUrl/media');
+    assert.calledWith(sendBehavioralMetricStub, BEHAVIORAL_METRICS.LOCUS_MEDIA_REQUEST_RETRY, {
+      correlation_id: 'correlationId',
+      reason: 'selfUrlNotChangedAfterWait',
+      retryAttempt: 0,
+      roapMessageType: 'ANSWER',
+    });
+  });
+
+  it('retries a roap conflict when selfUrl changes after waiting', async () => {
+    let currentSelfUrl = 'sameSelfUrl';
+    const waitForSelfUrlChangeAndUpdate = async () => {
+      currentSelfUrl = 'newSelfUrlAfterWait';
+    };
+    locusMediaRequest = new LocusMediaRequest(
+      {
+        device: {
+          url: 'deviceUrl',
+          deviceType: 'deviceType',
+          regionCode: 'regionCode',
+        },
+        correlationId: 'correlationId',
+        meetingId: 'meetingId',
+        preferTranscoding: true,
+        getCurrentSelfUrl: () => currentSelfUrl,
+        waitForSelfUrlChange: waitForSelfUrlChangeAndUpdate,
+      },
+      {
+        parent: mockWebex,
+      }
+    );
+    webexRequestStub = sinon.stub(locusMediaRequest, 'request');
+    webexRequestStub.onFirstCall().rejects({statusCode: 409, message: 'conflict'});
+    webexRequestStub.onSecondCall().resolves(fakeLocusResponse);
+
+    const request = cloneDeep(exampleRoapRequestBody);
+
+    request.selfUrl = 'sameSelfUrl';
+    request.roapMessage.messageType = 'ANSWER';
+
+    const result = await locusMediaRequest.send(request);
+
+    assert.equal(result, fakeLocusResponse);
+    assert.calledTwice(webexRequestStub);
+    assert.equal(webexRequestStub.getCall(0).args[0].uri, 'sameSelfUrl/media');
+    assert.equal(webexRequestStub.getCall(1).args[0].uri, 'newSelfUrlAfterWait/media');
+    assert.calledWith(sendBehavioralMetricStub, BEHAVIORAL_METRICS.LOCUS_MEDIA_REQUEST_RETRY, {
+      correlation_id: 'correlationId',
+      reason: 'selfUrlChangedAfterWait',
+      retryAttempt: 0,
+      roapMessageType: 'ANSWER',
+    });
+  });
+
+  it('retries a local mute request with the latest resolved selfUrl after a conflict', async () => {
+    let currentSelfUrl = 'oldSelfUrl';
+
+    locusMediaRequest = new LocusMediaRequest(
+      {
+        device: {
+          url: 'deviceUrl',
+          deviceType: 'deviceType',
+          regionCode: 'regionCode',
+        },
+        correlationId: 'correlationId',
+        meetingId: 'meetingId',
+        preferTranscoding: true,
+        getCurrentSelfUrl: () => currentSelfUrl,
+        waitForSelfUrlChange,
+      },
+      {
+        parent: mockWebex,
+      }
+    );
+    webexRequestStub = sinon.stub(locusMediaRequest, 'request').resolves(fakeLocusResponse);
+
+    // Create the confluence on this instance, otherwise the LocalMute request
+    // short-circuits (resolves without sending) while confluence is "not created".
+    await ensureConfluenceCreated();
+
+    webexRequestStub.reset();
+    webexRequestStub.onFirstCall().callsFake(() => {
+      currentSelfUrl = 'newSelfUrl';
+
+      return Promise.reject({statusCode: 409, message: 'conflict'});
+    });
+    webexRequestStub.onSecondCall().resolves(fakeLocusResponse);
+
+    const result = await locusMediaRequest.send({
+      ...exampleLocalMuteRequestBody,
+      selfUrl: 'oldSelfUrl',
+      muteOptions: {audioMuted: false, videoMuted: true},
+    });
+
+    assert.equal(result, fakeLocusResponse);
+    assert.calledTwice(webexRequestStub);
+    assert.equal(webexRequestStub.getCall(0).args[0].uri, 'oldSelfUrl/media');
+    assert.equal(webexRequestStub.getCall(1).args[0].uri, 'newSelfUrl/media');
+  });
+
+  it('stops retrying roap conflicts after the selfUrl retry limit', async () => {
+    let currentSelfUrl = 'oldSelfUrl';
+    locusMediaRequest = new LocusMediaRequest(
+      {
+        device: {
+          url: 'deviceUrl',
+          deviceType: 'deviceType',
+          regionCode: 'regionCode',
+        },
+        correlationId: 'correlationId',
+        meetingId: 'meetingId',
+        preferTranscoding: true,
+        getCurrentSelfUrl: () => currentSelfUrl,
+        waitForSelfUrlChange,
+      },
+      {
+        parent: mockWebex,
+      }
+    );
+    webexRequestStub = sinon.stub(locusMediaRequest, 'request');
+    webexRequestStub.onFirstCall().callsFake(() => {
+      currentSelfUrl = 'secondSelfUrl';
+
+      return Promise.reject({statusCode: 409, message: 'conflict'});
+    });
+    webexRequestStub.onSecondCall().callsFake(() => {
+      currentSelfUrl = 'thirdSelfUrl';
+
+      return Promise.reject({statusCode: 409, message: 'conflict'});
+    });
+    webexRequestStub.onThirdCall().callsFake(() => {
+      currentSelfUrl = 'fourthSelfUrl';
+
+      return Promise.reject({statusCode: 409, message: 'conflict'});
+    });
+
+    const request = cloneDeep(exampleRoapRequestBody);
+
+    request.selfUrl = 'oldSelfUrl';
+    request.roapMessage.messageType = 'ANSWER';
+
+    await assert.isRejected(locusMediaRequest.send(request));
+
+    assert.calledThrice(webexRequestStub);
+    assert.equal(webexRequestStub.getCall(0).args[0].uri, 'oldSelfUrl/media');
+    assert.equal(webexRequestStub.getCall(1).args[0].uri, 'secondSelfUrl/media');
+    assert.equal(webexRequestStub.getCall(2).args[0].uri, 'thirdSelfUrl/media');
+  });
+
   it('sends correct metric event when roap message fails', async () => {
     webexRequestStub.rejects({code: 300, message: 'fake error'});
     await assert.isRejected(sendRoapMessage('OFFER'));

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({});