@webex/plugin-meetings 3.10.0 → 3.11.0-next.10

package/test/unit/spec/media/MediaConnectionAwaiter.ts

@@ -5,6 +5,8 @@ import {ConnectionState, MediaConnectionEventNames} from '@webex/internal-media-
 import testUtils from '../../../utils/testUtils';
 import {ICE_AND_DTLS_CONNECTION_TIMEOUT} from '@webex/plugin-meetings/src/constants';
 import MediaConnectionAwaiter from '../../../../src/media/MediaConnectionAwaiter';
+import Metrics from '../../../../src/metrics';
+import BEHAVIORAL_METRICS from '../../../../src/metrics/constants';
 
 describe('MediaConnectionAwaiter', () => {
   let mediaConnectionAwaiter;
@@ -14,18 +16,34 @@ describe('MediaConnectionAwaiter', () => {
   beforeEach(() => {
     clock = sinon.useFakeTimers();
 
+    const mockTransportReport = {
+      type: 'transport',
+      dtlsState: 'connecting',
+      iceState: 'checking',
+      packetsSent: 10,
+      packetsReceived: 5,
+    };
+
     mockMC = {
-      getStats: sinon.stub().resolves([]),
+      getStats: sinon.stub().resolves({
+        values: () => [mockTransportReport],
+      }),
       on: sinon.stub(),
       off: sinon.stub(),
       getConnectionState: sinon.stub().returns(ConnectionState.New),
       getIceGatheringState: sinon.stub().returns('new'),
       getIceConnectionState: sinon.stub().returns('new'),
       getPeerConnectionState: sinon.stub().returns('new'),
+      multistreamConnection: {
+        dataChannel: {
+          readyState: 'open',
+        },
+      },
     };
 
     mediaConnectionAwaiter = new MediaConnectionAwaiter({
       webrtcMediaConnection: mockMC,
+      correlationId: 'test-correlation-id',
     });
   });
 
@@ -44,6 +62,8 @@ describe('MediaConnectionAwaiter', () => {
     });
 
     it('rejects after timeout if ice state is not connected', async () => {
+      const sendMetricSpy = sinon.spy(Metrics, 'sendBehavioralMetric');
+
       mockMC.getConnectionState.returns(ConnectionState.Connecting);
       mockMC.getIceGatheringState.returns('gathering');
 
@@ -83,6 +103,18 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, true);
 
       assert.calledThrice(mockMC.off);
+
+      assert.calledOnceWithExactly(sendMetricSpy, BEHAVIORAL_METRICS.MEDIA_STILL_NOT_CONNECTED, {
+        correlation_id: 'test-correlation-id',
+        numTransports: 1,
+        dtlsState: 'connecting',
+        iceState: 'checking',
+        packetsSent: 10,
+        packetsReceived: 5,
+        dataChannelState: 'open',
+      });
+
+      sendMetricSpy.restore();
     });
 
     it('rejects immediately if ice state is FAILED', async () => {
@@ -351,6 +383,8 @@ describe('MediaConnectionAwaiter', () => {
     });
 
     it(`reject with restart timer once if gathering state is not complete`, async () => {
+      const sendMetricSpy = sinon.spy(Metrics, 'sendBehavioralMetric');
+
       mockMC.getConnectionState.returns(ConnectionState.Connecting);
       mockMC.getIceGatheringState.returns('new');
 
@@ -390,6 +424,12 @@ describe('MediaConnectionAwaiter', () => {
 
       assert.calledOnce(clearTimeoutSpy);
       assert.calledTwice(setTimeoutSpy);
+
+      // verify sendMetric was called twice (once for each timeout)
+      assert.calledTwice(sendMetricSpy);
+      assert.calledWith(sendMetricSpy, BEHAVIORAL_METRICS.MEDIA_STILL_NOT_CONNECTED);
+
+      sendMetricSpy.restore();
     });
 
     it(`resolves gathering and connection state complete right after`, async () => {

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

@@ -141,12 +141,12 @@ describe('createMediaConnection', () => {
     const roapMediaConnectionConstructorStub = sinon
       .stub(InternalMediaCoreModule, 'RoapMediaConnection')
       .returns(fakeRoapMediaConnection);
-  
+
     StaticConfig.set({bandwidth: {audio: 123, video: 456, startBitrate: 999}});
-  
+
     const ENABLE_EXTMAP = false;
     const ENABLE_RTX = true;
-  
+
     Media.createMediaConnection(false, 'sendonly-debug-id', 'meetingId', {
       mediaProperties: {
         mediaDirection: {
@@ -168,7 +168,7 @@ describe('createMediaConnection', () => {
       turnServerInfo: undefined,
       iceCandidatesTimeout: undefined,
     });
-  
+
     assert.calledWith(
       roapMediaConnectionConstructorStub,
       sinon.match.any,
@@ -194,12 +194,12 @@ describe('createMediaConnection', () => {
     const roapMediaConnectionConstructorStub = sinon
       .stub(InternalMediaCoreModule, 'RoapMediaConnection')
       .returns(fakeRoapMediaConnection);
-  
+
     StaticConfig.set({bandwidth: {audio: 123, video: 456, startBitrate: 999}});
-  
+
     const ENABLE_EXTMAP = true;
     const ENABLE_RTX = false;
-  
+
     Media.createMediaConnection(false, 'recvonly-debug-id', 'meetingId', {
       mediaProperties: {
         mediaDirection: {
@@ -221,7 +221,7 @@ describe('createMediaConnection', () => {
       turnServerInfo: undefined,
       iceCandidatesTimeout: undefined,
     });
-  
+
     assert.calledWith(
       roapMediaConnectionConstructorStub,
       sinon.match.any,
@@ -242,7 +242,6 @@ describe('createMediaConnection', () => {
       'recvonly-debug-id'
     );
   });
-  
 
   it('creates a MultistreamRoapMediaConnection when multistream is enabled', () => {
     const multistreamRoapMediaConnectionConstructorStub = sinon
@@ -511,6 +510,138 @@ describe('createMediaConnection', () => {
     );
   });
 
+  const testEnableInboundAudioLevelMonitoring = (
+    testName: string,
+    browserStubs: {isChrome?: boolean; isEdge?: boolean; isFirefox?: boolean},
+    isMultistream: boolean,
+    expectedConfig: object,
+    additionalOptions = {}
+  ) => {
+    it(testName, () => {
+      const connectionConstructorStub = isMultistream
+        ? sinon.stub(InternalMediaCoreModule, 'MultistreamRoapMediaConnection')
+        : sinon.stub(InternalMediaCoreModule, 'RoapMediaConnection');
+
+      connectionConstructorStub.returns(fakeRoapMediaConnection);
+
+      // Set up browser stubs
+      sinon.stub(BrowserInfo, 'isChrome').returns(browserStubs.isChrome || false);
+      sinon.stub(BrowserInfo, 'isEdge').returns(browserStubs.isEdge || false);
+      sinon.stub(BrowserInfo, 'isFirefox').returns(browserStubs.isFirefox || false);
+
+      const baseOptions = {
+        mediaProperties: {
+          mediaDirection: {
+            sendAudio: true,
+            sendVideo: true,
+            sendShare: false,
+            receiveAudio: true,
+            receiveVideo: true,
+            receiveShare: true,
+          },
+          ...(isMultistream
+            ? {}
+            : {
+                audioStream: fakeAudioStream,
+                videoStream: fakeVideoStream,
+                shareVideoTrack: null,
+                shareAudioTrack: null,
+              }),
+        },
+        ...(isMultistream
+          ? {}
+          : {
+              remoteQualityLevel: 'HIGH',
+              enableRtx: true,
+              enableExtmap: true,
+            }),
+        ...additionalOptions,
+      };
+
+      if (!isMultistream) {
+        StaticConfig.set({bandwidth: {audio: 123, video: 456, startBitrate: 999}});
+      }
+
+      Media.createMediaConnection(isMultistream, 'debug string', 'meeting id', baseOptions);
+
+      if (isMultistream) {
+        assert.calledOnceWithExactly(
+          connectionConstructorStub,
+          expectedConfig,
+          'meeting id',
+          sinon.match.func,
+          sinon.match.func,
+          sinon.match.func
+        );
+      } else {
+        assert.calledOnceWithExactly(
+          connectionConstructorStub,
+          expectedConfig,
+          sinon.match.object,
+          'debug string'
+        );
+      }
+    });
+  };
+
+  testEnableInboundAudioLevelMonitoring(
+    'enables enableInboundAudioLevelMonitoring for multistream when browser is Chrome',
+    {isChrome: true},
+    true,
+    {
+      iceServers: [],
+      disableAudioTwcc: true,
+      enableInboundAudioLevelMonitoring: true,
+    }
+  );
+
+  testEnableInboundAudioLevelMonitoring(
+    'enables enableInboundAudioLevelMonitoring for multistream when browser is Edge',
+    {isEdge: true},
+    true,
+    {
+      iceServers: [],
+      disableAudioTwcc: true,
+      enableInboundAudioLevelMonitoring: true,
+    }
+  );
+
+  testEnableInboundAudioLevelMonitoring(
+    'does not enable enableInboundAudioLevelMonitoring for multistream when browser is Firefox',
+    {isFirefox: true},
+    true,
+    {
+      iceServers: [],
+      disableAudioTwcc: true,
+      doFullIce: true,
+      stopIceGatheringAfterFirstRelayCandidate: undefined,
+    }
+  );
+
+  testEnableInboundAudioLevelMonitoring(
+    'does not enable enableInboundAudioLevelMonitoring for non-multistream connections even when browser is Chrome',
+    {isChrome: true},
+    false,
+    {
+      iceServers: [],
+      iceCandidatesTimeout: undefined,
+      skipInactiveTransceivers: false,
+      requireH264: true,
+      sdpMunging: {
+        convertPort9to0: false,
+        addContentSlides: true,
+        bandwidthLimits: {
+          audio: 123,
+          video: 456,
+        },
+        startBitrate: 999,
+        periodicKeyframes: 20,
+        disableExtmap: false,
+        disableRtx: false,
+      },
+    }
+  );
+
   [
     {testCase: 'turnServerInfo is undefined', turnServerInfo: undefined},
     {

package/test/unit/spec/media/properties.ts

@@ -41,14 +41,23 @@ describe('MediaProperties', () => {
   describe('waitForMediaConnectionConnected', () => {
     it('resolves if media connection is connected', async () => {
       const waitForMediaConnectionConnectedResult = new Defer();
+      const correlationId = 'aaaa-bbbb-cccc-dddd';
 
-      sinon
+      let capturedInstance;
+      const stub = sinon
         .stub(MediaConnectionAwaiter.prototype, 'waitForMediaConnectionConnected')
-        .returns(waitForMediaConnectionConnectedResult.promise);
+        .callsFake(function () {
+          capturedInstance = this;
+          return waitForMediaConnectionConnectedResult.promise;
+        });
 
       waitForMediaConnectionConnectedResult.resolve();
 
-      await mediaProperties.waitForMediaConnectionConnected();
+      await mediaProperties.waitForMediaConnectionConnected(correlationId);
+
+      assert.calledOnce(stub);
+      assert.equal(capturedInstance.correlationId, correlationId);
+      assert.equal(capturedInstance.webrtcMediaConnection, mockMC);
     });
     it('rejects if media connection is not connected', async () => {
       const waitForMediaConnectionConnectedResult = new Defer();