@webex/plugin-meetings 3.12.0-next.88 → 3.12.0-next.89

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'));