@webex/plugin-meetings 3.0.0-beta.1 → 3.0.0-beta.2

package/src/statsAnalyzer/index.js

@@ -1,7 +1,8 @@
 import {cloneDeep} from 'lodash';
+import {MediaConnection as MC} from '@webex/internal-media-core';
 
 import EventsScope from '../common/events/events-scope';
-import {DEFAULT_GET_STATS_FILTER, CONNECTION_STATE, STATS, MQA_INTEVAL, NETWORK_TYPE, MEDIA_DEVICES, _UNKNOWN_} from '../constants';
+import {DEFAULT_GET_STATS_FILTER, STATS, MQA_INTEVAL, NETWORK_TYPE, MEDIA_DEVICES, _UNKNOWN_} from '../constants';
 import mqaData from '../mediaQualityMetrics/config';
 import LoggerProxy from '../common/logs/logger-proxy';
 
@@ -175,7 +176,7 @@ export class StatsAnalyzer extends EventsScope {
   }
 
   /**
-   * captures MQA data from peerconnection
+   * captures MQA data from media connection
    *
    * @public
    * @memberof StatsAnalyzer
@@ -232,8 +233,8 @@ export class StatsAnalyzer extends EventsScope {
     // Adding peripheral information
     mqaData.intervals[0].intervalMetadata.peripherals = [];
     mqaData.intervals[0].intervalMetadata.peripherals.push({information: _UNKNOWN_, name: MEDIA_DEVICES.SPEAKER});
-    mqaData.intervals[0].intervalMetadata.peripherals.push({information: this.peerConnection?.audioTransceiver?.sender?.track?.label || _UNKNOWN_, name: MEDIA_DEVICES.MICROPHONE});
-    mqaData.intervals[0].intervalMetadata.peripherals.push({information: this.peerConnection?.videoTransceiver?.sender?.track?.label || _UNKNOWN_, name: MEDIA_DEVICES.CAMERA});
+    mqaData.intervals[0].intervalMetadata.peripherals.push({information: this.statsResults[STATS.AUDIO_CORRELATE][STATS.SEND_DIRECTION].trackLabel || _UNKNOWN_, name: MEDIA_DEVICES.MICROPHONE});
+    mqaData.intervals[0].intervalMetadata.peripherals.push({information: this.statsResults[STATS.VIDEO_CORRELATE][STATS.SEND_DIRECTION].trackLabel || _UNKNOWN_, name: MEDIA_DEVICES.CAMERA});
 
 
     mqaData.networkType = this.statsResults.connectionType.local.networkType;
@@ -263,15 +264,15 @@ export class StatsAnalyzer extends EventsScope {
   }
 
   /**
-   * updated the peerconnection when changed
+   * updated the media connection when changed
    *
    * @private
-   * @memberof updatePeerconnection
-   * @param {PeerConnection} peerConnection
+   * @memberof StatsAnalyzer
+   * @param {MC.RoapMediaConnection} mediaConnection
    * @returns {void}
    */
-  updatePeerconnection(peerConnection) {
-    this.peerConnection = peerConnection;
+  updateMediaConnection(mediaConnection) {
+    this.mediaConnection = mediaConnection;
   }
 
   /**
@@ -279,13 +280,13 @@ export class StatsAnalyzer extends EventsScope {
    *
    * @public
    * @memberof StatsAnalyzer
-   * @param {PeerConnection} peerConnection
+   * @param {MC.RoapMediaConnection} mediaConnection
    * @returns {Promise}
    */
-  startAnalyzer(peerConnection) {
+  startAnalyzer(mediaConnection) {
     if (!this.statsStarted) {
       this.statsStarted = true;
-      this.peerConnection = peerConnection;
+      this.mediaConnection = mediaConnection;
 
       return this.getStatsAndParse()
         .then(() => {
@@ -326,10 +327,10 @@ export class StatsAnalyzer extends EventsScope {
     if (sendOneLastMqa) {
       return this.getStatsAndParse().then(() => {
         this.sendMqaData();
-        this.peerConnection = null;
+        this.mediaConnection = null;
       });
     }
-    this.peerConnection = null;
+    this.mediaConnection = null;
 
     return Promise.resolve();
   }
@@ -634,53 +635,38 @@ export class StatsAnalyzer extends EventsScope {
    * @returns {Promise}
    */
   getStatsAndParse() {
-    if (!this.peerConnection) {
+    if (!this.mediaConnection) {
       return Promise.resolve();
     }
 
-    if (this.peerConnection && this.peerConnection.connectionState === CONNECTION_STATE.FAILED) {
-      LoggerProxy.logger.trace('StatsAnalyzer:index#getStatsAndParse --> PeerConnection is in failed state');
+    if (this.mediaConnection && this.mediaConnection.getConnectionState() === MC.ConnectionState.Failed) {
+      LoggerProxy.logger.trace('StatsAnalyzer:index#getStatsAndParse --> media connection is in failed state');
 
       return Promise.resolve();
     }
 
     LoggerProxy.logger.trace('StatsAnalyzer:index#getStatsAndParse --> Collecting Stats');
 
-    return Promise.all([
-      this.peerConnection.videoTransceiver.sender.getStats().then((res) => {
-        this.filterAndParseGetStatsResults(res, STATS.VIDEO_CORRELATE, true);
-      }),
-
-      this.peerConnection.videoTransceiver.receiver.getStats().then((res) => {
-        this.filterAndParseGetStatsResults(res, STATS.VIDEO_CORRELATE, false);
-      }),
-
-      this.peerConnection.audioTransceiver.sender.getStats().then((res) => {
-        this.filterAndParseGetStatsResults(res, STATS.AUDIO_CORRELATE, true);
-      }),
-
-      this.peerConnection.audioTransceiver.receiver.getStats().then((res) => {
-        this.filterAndParseGetStatsResults(res, STATS.AUDIO_CORRELATE, false);
-      }),
-
-      // TODO: add checks for screen share
-      this.peerConnection.shareTransceiver.sender.getStats().then((res) => {
-        this.filterAndParseGetStatsResults(res, STATS.SHARE_CORRELATE, true);
-      }),
+    return this.mediaConnection.getTransceiverStats().then((transceiverStats) => {
+      this.filterAndParseGetStatsResults(transceiverStats.video.sender, STATS.VIDEO_CORRELATE, true);
+      this.filterAndParseGetStatsResults(transceiverStats.video.receiver, STATS.VIDEO_CORRELATE, false);
+      this.filterAndParseGetStatsResults(transceiverStats.audio.sender, STATS.AUDIO_CORRELATE, true);
+      this.filterAndParseGetStatsResults(transceiverStats.audio.receiver, STATS.AUDIO_CORRELATE, false);
+      this.filterAndParseGetStatsResults(transceiverStats.screenShareVideo.sender, STATS.SHARE_CORRELATE, true);
+      this.filterAndParseGetStatsResults(transceiverStats.screenShareVideo.receiver, STATS.SHARE_CORRELATE, false);
 
-      this.peerConnection.shareTransceiver.receiver.getStats().then((res) => {
-        this.filterAndParseGetStatsResults(res, STATS.SHARE_CORRELATE, false);
-      }),
+      // updates the current direction of media
+      this.statsResults[STATS.AUDIO_CORRELATE].direction = transceiverStats.audio.currentDirection;
+      this.statsResults[STATS.VIDEO_CORRELATE].direction = transceiverStats.video.currentDirection;
+      this.statsResults[STATS.SHARE_CORRELATE].direction = transceiverStats.screenShareVideo.currentDirection;
 
-    ]).then(() => {
-      this.statsResults[STATS.AUDIO_CORRELATE].direction = this.peerConnection.audioTransceiver.currentDirection;
-      this.statsResults[STATS.VIDEO_CORRELATE].direction = this.peerConnection.videoTransceiver.currentDirection;
-      this.statsResults[STATS.SHARE_CORRELATE].direction = this.peerConnection.shareTransceiver.currentDirection;
+      this.statsResults[STATS.AUDIO_CORRELATE][STATS.SEND_DIRECTION].trackLabel = transceiverStats.audio.localTrackLabel;
+      this.statsResults[STATS.VIDEO_CORRELATE][STATS.SEND_DIRECTION].trackLabel = transceiverStats.video.localTrackLabel;
 
-      // Process Stats results every 5 seconds
       this.compareLastStatsResult();
 
       // Save the last results to compare with the current
+      // DO Deep copy, for some reason it takes the reference all the time rather then old value set
       this.lastStatsResults = JSON.parse(JSON.stringify(this.statsResults));
 
       LoggerProxy.logger.trace('StatsAnalyzer:index#getStatsAndParse --> Finished Collecting Stats');

package/test/integration/spec/journey.js

@@ -364,7 +364,7 @@ skipInNode(describe)('plugin-meetings', () => {
               stream: response[0]
             })
               .then(() => {
-                console.log('AUDIO ', alice.meeting.mediaProperties.peerConnection.audioTransceiver.sender.track);
+                console.log('AUDIO ', alice.meeting.mediaProperties.audioTrack);
                 assert.equal(alice.meeting.mediaProperties.audioTrack.id, response[0].getAudioTracks()[0].id);
                 assert.equal(alice.meeting.mediaProperties.videoTrack.id, oldVideoTrackId);
               })),

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

@@ -0,0 +1,223 @@
+import * as internalMediaModule from '@webex/plugin-meetings/src/media/internal-media-core-wrapper';
+import Media from '@webex/plugin-meetings/src/media/index';
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+import StaticConfig from '@webex/plugin-meetings/src/common/config';
+
+describe('createMediaConnection', () => {
+  const fakeRoapMediaConnection = {
+    id: 'roap media connection',
+  };
+  const fakeAudioTrack = {
+    id: 'audio track',
+  };
+  const fakeVideoTrack = {
+    id: 'video track',
+  };
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  it('creates a RoapMediaConnection when multistream is disabled', () => {
+    const roapMediaConnectionConstructorStub = sinon
+      .stub(internalMediaModule, 'RoapMediaConnection')
+      .returns(fakeRoapMediaConnection);
+
+    StaticConfig.set({bandwidth: {audio: 123, video: 456, startBitrate: 999}});
+
+    const ENABLE_EXTMAP = false;
+    const ENABLE_RTX = true;
+
+    Media.createMediaConnection(
+      {
+        mediaDirection: {
+          sendAudio: true,
+          sendVideo: true,
+          sendShare: false,
+          receiveAudio: true,
+          receiveVideo: true,
+          receiveShare: true,
+        },
+        audioTrack: fakeAudioTrack,
+        videoTrack: fakeVideoTrack,
+        shareTrack: null,
+      },
+      {
+        isMultistream: false,
+        remoteQualityLevel: 'HIGH',
+        enableRtx: ENABLE_RTX,
+        enableExtmap: ENABLE_EXTMAP,
+        turnServerInfo: {
+          url: 'turn server url',
+          username: 'turn username',
+          password: 'turn password',
+        },
+      }
+    );
+    assert.calledOnce(roapMediaConnectionConstructorStub);
+    assert.calledWith(
+      roapMediaConnectionConstructorStub,
+      {
+        iceServers: [
+          {
+            urls: 'turn server url',
+            username: 'turn username',
+            credential: 'turn password',
+          },
+        ],
+        skipInactiveTransceivers: false,
+        requireH264: true,
+        sdpMunging: {
+          convertPort9to0: false,
+          addContentSlides: true,
+          bandwidthLimits: {
+            audio: 123,
+            video: 456,
+          },
+          startBitrate: 999,
+          periodicKeyframes: 20,
+          disableExtmap: !ENABLE_EXTMAP,
+          disableRtx: !ENABLE_RTX,
+        },
+      },
+      {
+        send: {
+          audio: fakeAudioTrack,
+          video: fakeVideoTrack,
+          screenShareVideo: null,
+        },
+        receive: {
+          audio: true,
+          video: true,
+          screenShareVideo: true,
+          remoteQualityLevel: 'HIGH',
+        },
+      },
+      'mc'
+    );
+  });
+
+  it('creates a MultistreamRoapMediaConnection when multistream is enabled', () => {
+    const multistreamRoapMediaConnectionConstructorStub = sinon
+      .stub(internalMediaModule, 'MultistreamRoapMediaConnection')
+      .returns(fakeRoapMediaConnection);
+
+    Media.createMediaConnection(
+      {},
+      {
+        isMultistream: true,
+        turnServerInfo: {
+          url: 'turn server url',
+          username: 'turn username',
+          password: 'turn password',
+        },
+      }
+    );
+    assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
+    assert.calledWith(
+      multistreamRoapMediaConnectionConstructorStub,
+      {
+        iceServers: [
+          {
+            urls: 'turn server url',
+            username: 'turn username',
+            credential: 'turn password',
+          },
+        ],
+      },
+      'mc'
+    );
+  });
+
+  it('passes empty ICE servers array to MultistreamRoapMediaConnection if turnServerInfo is undefined (multistream enabled)', () => {
+    const multistreamRoapMediaConnectionConstructorStub = sinon
+      .stub(internalMediaModule, 'MultistreamRoapMediaConnection')
+      .returns(fakeRoapMediaConnection);
+
+    Media.createMediaConnection(
+      {},
+      {
+        isMultistream: true,
+        turnServerInfo: undefined,
+      }
+    );
+    assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
+    assert.calledWith(
+      multistreamRoapMediaConnectionConstructorStub,
+      {
+        iceServers: [],
+      },
+      'mc'
+    );
+  });
+
+  it('passes empty ICE servers array to RoapMediaConnection if turnServerInfo is undefined (multistream disabled)', () => {
+    const roapMediaConnectionConstructorStub = sinon
+      .stub(internalMediaModule, 'RoapMediaConnection')
+      .returns(fakeRoapMediaConnection);
+
+    StaticConfig.set({bandwidth: {audio: 123, video: 456, startBitrate: 999}});
+
+    const ENABLE_EXTMAP = false;
+    const ENABLE_RTX = true;
+
+    Media.createMediaConnection(
+      {
+        mediaDirection: {
+          sendAudio: true,
+          sendVideo: true,
+          sendShare: true,
+          receiveAudio: true,
+          receiveVideo: true,
+          receiveShare: true,
+        },
+        audioTrack: fakeAudioTrack,
+        videoTrack: null,
+        shareTrack: fakeVideoTrack,
+      },
+      {
+        isMultistream: false,
+        remoteQualityLevel: 'HIGH',
+        enableRtx: ENABLE_RTX,
+        enableExtmap: ENABLE_EXTMAP,
+        turnServerInfo: undefined,
+      }
+    );
+    assert.calledOnce(roapMediaConnectionConstructorStub);
+    assert.calledWith(
+      roapMediaConnectionConstructorStub,
+      {
+        iceServers: [],
+        skipInactiveTransceivers: false,
+        requireH264: true,
+        sdpMunging: {
+          convertPort9to0: false,
+          addContentSlides: true,
+          bandwidthLimits: {
+            audio: 123,
+            video: 456,
+          },
+          startBitrate: 999,
+          periodicKeyframes: 20,
+          disableExtmap: !ENABLE_EXTMAP,
+          disableRtx: !ENABLE_RTX,
+        },
+      },
+      {
+        send: {
+          audio: fakeAudioTrack,
+          video: null,
+          screenShareVideo: fakeVideoTrack,
+        },
+        receive: {
+          audio: true,
+          video: true,
+          screenShareVideo: true,
+          remoteQualityLevel: 'HIGH',
+        },
+      },
+      'mc'
+    );
+  });
+});

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

@@ -1,5 +1,6 @@
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
+import {MediaConnection as MC} from '@webex/internal-media-core';
 import MediaProperties from '@webex/plugin-meetings/src/media/properties';
 import MediaUtil from '@webex/plugin-meetings/src/media/util';
 import testUtils from '../../../utils/testUtils';
@@ -8,47 +9,39 @@ import {Defer} from '@webex/common';
 
 describe('MediaProperties', () => {
   let mediaProperties;
-  let mockPc;
+  let mockMC;
   let clock;
 
   beforeEach(() => {
     clock = sinon.useFakeTimers();
 
-    mockPc = {
+    mockMC = {
       getStats: sinon.stub().resolves([]),
-      addEventListener: sinon.stub(),
-      removeEventListener: sinon.stub(),
-      iceConnectionState: 'connected',
+      on: sinon.stub(),
+      off: sinon.stub(),
+      getConnectionState: sinon.stub().returns(MC.ConnectionState.Connected),
     };
 
-    sinon.stub(MediaUtil, 'createPeerConnection').returns(mockPc);
-
     mediaProperties = new MediaProperties();
+    mediaProperties.setMediaPeerConnection(mockMC);
   });
 
   afterEach(() => {
     clock.restore();
     sinon.restore();
   });
-  describe('waitForIceConnectedState', () => {
+  describe('waitForMediaConnectionConnected', () => {
     it('resolves immediately if ice state is connected', async () => {
-      mockPc.iceConnectionState = 'connected';
-
-      await mediaProperties.waitForIceConnectedState();
-    });
-    it('resolves immediately if ice state is completed', async () => {
-      mockPc.iceConnectionState = 'completed';
-
-      await mediaProperties.waitForIceConnectedState();
+      await mediaProperties.waitForMediaConnectionConnected();
     });
     it('rejects after timeout if ice state does not reach connected/completed', async () => {
-      mockPc.iceConnectionState = 'connecting';
+      mockMC.getConnectionState.returns(MC.ConnectionState.Connecting);
 
       let promiseResolved = false;
       let promiseRejected = false;
 
       mediaProperties
-        .waitForIceConnectedState()
+        .waitForMediaConnectionConnected()
         .then(() => {
           promiseResolved = true;
         })
@@ -66,128 +59,126 @@ describe('MediaProperties', () => {
       assert.equal(promiseRejected, true);
 
       // check that listener was registered and removed
-      assert.calledOnce(mockPc.addEventListener);
-      assert.equal(mockPc.addEventListener.getCall(0).args[0], 'iceconnectionstatechange');
-      const listener = mockPc.addEventListener.getCall(0).args[1];
+      assert.calledOnce(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], MC.Event.CONNECTION_STATE_CHANGED);
+      const listener = mockMC.on.getCall(0).args[1];
 
-      assert.calledOnce(mockPc.removeEventListener);
-      assert.calledWith(mockPc.removeEventListener, 'iceconnectionstatechange', listener);
+      assert.calledOnce(mockMC.off);
+      assert.calledWith(mockMC.off, MC.Event.CONNECTION_STATE_CHANGED, listener);
     });
 
-    ['connected', 'completed'].forEach((successIceState) =>
-      it(`resolves when ice state reaches ${successIceState}`, async () => {
-        mockPc.iceConnectionState = 'connecting';
+    it(`resolves when media connection reaches "connected" state`, async () => {
+      mockMC.getConnectionState.returns(MC.ConnectionState.Connecting);
 
-        const clearTimeoutSpy = sinon.spy(clock, 'clearTimeout');
+      const clearTimeoutSpy = sinon.spy(clock, 'clearTimeout');
 
-        let promiseResolved = false;
-        let promiseRejected = false;
+      let promiseResolved = false;
+      let promiseRejected = false;
 
-        mediaProperties
-          .waitForIceConnectedState()
-          .then(() => {
-            promiseResolved = true;
-          })
-          .catch(() => {
-            promiseRejected = true;
-          });
+      mediaProperties
+        .waitForMediaConnectionConnected()
+        .then(() => {
+          promiseResolved = true;
+        })
+        .catch(() => {
+          promiseRejected = true;
+        });
 
-        assert.equal(promiseResolved, false);
-        assert.equal(promiseRejected, false);
+      assert.equal(promiseResolved, false);
+      assert.equal(promiseRejected, false);
 
-        // check the right listener was registered
-        assert.calledOnce(mockPc.addEventListener);
-        assert.equal(mockPc.addEventListener.getCall(0).args[0], 'iceconnectionstatechange');
-        const listener = mockPc.addEventListener.getCall(0).args[1];
+      // check the right listener was registered
+      assert.calledOnce(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], MC.Event.CONNECTION_STATE_CHANGED);
+      const listener = mockMC.on.getCall(0).args[1];
 
-        // call the listener and pretend we are now connected
-        mockPc.iceConnectionState = successIceState;
-        listener();
-        await testUtils.flushPromises();
+      // call the listener and pretend we are now connected
+      mockMC.getConnectionState.returns(MC.ConnectionState.Connected);
+      listener();
+      await testUtils.flushPromises();
 
-        assert.equal(promiseResolved, true);
-        assert.equal(promiseRejected, false);
+      assert.equal(promiseResolved, true);
+      assert.equal(promiseRejected, false);
 
-        // check that listener was removed
-        assert.calledOnce(mockPc.removeEventListener);
-        assert.calledWith(mockPc.removeEventListener, 'iceconnectionstatechange', listener);
+      // check that listener was removed
+      assert.calledOnce(mockMC.off);
+      assert.calledWith(mockMC.off, MC.Event.CONNECTION_STATE_CHANGED, listener);
 
-        assert.calledOnce(clearTimeoutSpy);
-      })
-    );
+      assert.calledOnce(clearTimeoutSpy);
+    });
   });
 
   describe('getCurrentConnectionType', () => {
-    it('calls waitForIceConnectedState', async () => {
-      const spy = sinon.stub(mediaProperties, 'waitForIceConnectedState');
+    it('calls waitForMediaConnectionConnected', async () => {
+      const spy = sinon.stub(mediaProperties, 'waitForMediaConnectionConnected');
 
       await mediaProperties.getCurrentConnectionType();
 
       assert.calledOnce(spy);
     });
-    it('calls getStats() only after waitForIceConnectedState resolves', async () => {
-      const waitForIceConnectedStateResult = new Defer();
+    it('calls getStats() only after waitForMediaConnectionConnected resolves', async () => {
+      const waitForMediaConnectionConnectedResult = new Defer();
 
-      const waitForIceConnectedStateStub = sinon
-        .stub(mediaProperties, 'waitForIceConnectedState')
-        .returns(waitForIceConnectedStateResult.promise);
+      const waitForMediaConnectionConnectedStub = sinon
+        .stub(mediaProperties, 'waitForMediaConnectionConnected')
+        .returns(waitForMediaConnectionConnectedResult.promise);
 
       const result = mediaProperties.getCurrentConnectionType();
 
       await testUtils.flushPromises();
 
-      assert.called(waitForIceConnectedStateStub);
-      assert.notCalled(mockPc.getStats);
+      assert.called(waitForMediaConnectionConnectedStub);
+      assert.notCalled(mockMC.getStats);
 
-      waitForIceConnectedStateResult.resolve();
+      waitForMediaConnectionConnectedResult.resolve();
       await testUtils.flushPromises();
 
-      assert.called(mockPc.getStats);
+      assert.called(mockMC.getStats);
       await result;
     });
-    it('rejects if waitForIceConnectedState rejects', async () => {
-      const waitForIceConnectedStateResult = new Defer();
+    it('rejects if waitForMediaConnectionConnected rejects', async () => {
+      const waitForMediaConnectionConnectedResult = new Defer();
 
-      const waitForIceConnectedStateStub = sinon
-        .stub(mediaProperties, 'waitForIceConnectedState')
-        .returns(waitForIceConnectedStateResult.promise);
+      const waitForMediaConnectionConnectedStub = sinon
+        .stub(mediaProperties, 'waitForMediaConnectionConnected')
+        .returns(waitForMediaConnectionConnectedResult.promise);
 
       const result = mediaProperties.getCurrentConnectionType();
 
       await testUtils.flushPromises();
 
-      assert.called(waitForIceConnectedStateStub);
+      assert.called(waitForMediaConnectionConnectedStub);
 
-      waitForIceConnectedStateResult.reject(new Error('fake error'));
+      waitForMediaConnectionConnectedResult.reject(new Error('fake error'));
       await testUtils.flushPromises();
 
-      assert.notCalled(mockPc.getStats);
+      assert.notCalled(mockMC.getStats);
 
       await assert.isRejected(result);
     });
     it('returns "unknown" if getStats() fails', async () => {
-      mockPc.getStats.rejects(new Error());
+      mockMC.getStats.rejects(new Error());
 
       const connectionType = await mediaProperties.getCurrentConnectionType();
       assert.equal(connectionType, 'unknown');
     });
 
     it('returns "unknown" if getStats() returns no candidate pairs', async () => {
-      mockPc.getStats.resolves([{type: 'something', id: '1234'}]);
+      mockMC.getStats.resolves([{type: 'something', id: '1234'}]);
 
       const connectionType = await mediaProperties.getCurrentConnectionType();
       assert.equal(connectionType, 'unknown');
     });
 
     it('returns "unknown" if getStats() returns no successful candidate pair', async () => {
-      mockPc.getStats.resolves([{type: 'candidate-pair', id: '1234', state: 'inprogress'}]);
+      mockMC.getStats.resolves([{type: 'candidate-pair', id: '1234', state: 'inprogress'}]);
 
       const connectionType = await mediaProperties.getCurrentConnectionType();
       assert.equal(connectionType, 'unknown');
     });
 
     it('returns "unknown" if getStats() returns a successful candidate pair but local candidate is missing', async () => {
-      mockPc.getStats.resolves([
+      mockMC.getStats.resolves([
         {type: 'candidate-pair', id: '1234', state: 'succeeded', localCandidateId: 'wrong id'},
       ]);
 
@@ -196,7 +187,7 @@ describe('MediaProperties', () => {
     });
 
     it('returns "UDP" if getStats() returns a successful candidate pair with udp local candidate', async () => {
-      mockPc.getStats.resolves([
+      mockMC.getStats.resolves([
         {
           type: 'candidate-pair',
           id: 'some candidate pair id',
@@ -212,7 +203,7 @@ describe('MediaProperties', () => {
     });
 
     it('returns "TCP" if getStats() returns a successful candidate pair with tcp local candidate', async () => {
-      mockPc.getStats.resolves([
+      mockMC.getStats.resolves([
         {
           type: 'candidate-pair',
           id: 'some candidate pair id',
@@ -233,7 +224,7 @@ describe('MediaProperties', () => {
       {relayProtocol: 'udp', expectedConnectionType: 'TURN-UDP'},
     ].forEach(({relayProtocol, expectedConnectionType}) =>
       it(`returns "${expectedConnectionType}" if getStats() returns a successful candidate pair with a local candidate with relayProtocol=${relayProtocol}`, async () => {
-        mockPc.getStats.resolves([
+        mockMC.getStats.resolves([
           {
             type: 'candidate-pair',
             id: 'some candidate pair id',
@@ -265,7 +256,7 @@ describe('MediaProperties', () => {
       // in real life this will never happen and all active candidate pairs will have same transport,
       // but here we're simulating a situation where they have different transports and just checking
       // that the code still works and just returns the first one
-      mockPc.getStats.resolves([
+      mockMC.getStats.resolves([
         {
           type: 'inbound-rtp',
           id: 'whatever',