@webex/plugin-meetings 3.3.1 → 3.4.0-next.10

package/test/unit/spec/locus-info/selfUtils.js

@@ -345,37 +345,39 @@ describe('plugin-meetings', () => {
   });
 
   describe('mutedByOthersChanged', () => {
-    it('throws an error if changedSelf is not provided', function() {
-      assert.throws(() => SelfUtils.mutedByOthersChanged({}, null), 'New self must be defined to determine if self was muted by others.');
-    });
-
-    it('return false when oldSelf is not defined', function() {
-      assert.equal(SelfUtils.mutedByOthersChanged(null, { remoteMuted: false }), false);
+    it('throws an error if changedSelf is not provided', function () {
+      assert.throws(
+        () => SelfUtils.mutedByOthersChanged({}, null),
+        'New self must be defined to determine if self was muted by others.'
+      );
     });
 
-    it('should return true when remoteMuted is true on entry', function() {
-      assert.equal(SelfUtils.mutedByOthersChanged(null, { remoteMuted: true }), true);
+    it('return false when oldSelf is not defined', function () {
+      assert.equal(SelfUtils.mutedByOthersChanged(null, {remoteMuted: false}), false);
     });
 
-    it('should return false when selfIdentity and modifiedBy are the same', function() {
-      assert.equal(SelfUtils.mutedByOthersChanged(
-        { remoteMuted: false },
-        { remoteMuted: true, selfIdentity: 'user1', modifiedBy: 'user1' }
-      ), false);
+    it('should return true when remoteMuted is true on entry', function () {
+      assert.equal(SelfUtils.mutedByOthersChanged(null, {remoteMuted: true}), true);
     });
 
-    it('should return true when remoteMuted values are different', function() {
-      assert.equal(SelfUtils.mutedByOthersChanged(
-        { remoteMuted: false },
-        { remoteMuted: true, selfIdentity: 'user1', modifiedBy: 'user2' }
-      ), true);
+    it('should return true when remoteMuted values are different', function () {
+      assert.equal(
+        SelfUtils.mutedByOthersChanged(
+          {remoteMuted: false},
+          {remoteMuted: true, selfIdentity: 'user1', modifiedBy: 'user2'}
+        ),
+        true
+      );
     });
 
-    it('should return true when remoteMuted is true and unmuteAllowed has changed', function() {
-      assert.equal(SelfUtils.mutedByOthersChanged(
-        { remoteMuted: true, unmuteAllowed: false },
-        { remoteMuted: true, unmuteAllowed: true, selfIdentity: 'user1', modifiedBy: 'user2' }
-      ), true);
+    it('should return true when remoteMuted is true and unmuteAllowed has changed', function () {
+      assert.equal(
+        SelfUtils.mutedByOthersChanged(
+          {remoteMuted: true, unmuteAllowed: false},
+          {remoteMuted: true, unmuteAllowed: true, selfIdentity: 'user1', modifiedBy: 'user2'}
+        ),
+        true
+      );
     });
   });
 

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

@@ -1,6 +1,6 @@
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
-import {ConnectionState, Event} from '@webex/internal-media-core';
+import {ConnectionState, MediaConnectionEventNames} from '@webex/internal-media-core';
 import testUtils from '../../../utils/testUtils';
 import {ICE_AND_DTLS_CONNECTION_TIMEOUT} from '@webex/plugin-meetings/src/constants';
 import MediaConnectionAwaiter from '../../../../src/media/MediaConnectionAwaiter';
@@ -19,6 +19,8 @@ describe('MediaConnectionAwaiter', () => {
       off: sinon.stub(),
       getConnectionState: sinon.stub().returns(ConnectionState.New),
       getIceGatheringState: sinon.stub().returns('new'),
+      getIceConnectionState: sinon.stub().returns('new'),
+      getPeerConnectionState: sinon.stub().returns('new'),
     };
 
     mediaConnectionAwaiter = new MediaConnectionAwaiter({
@@ -52,8 +54,11 @@ describe('MediaConnectionAwaiter', () => {
         .then(() => {
           promiseResolved = true;
         })
-        .catch(() => {
+        .catch((error) => {
           promiseRejected = true;
+
+          const {iceConnected} = error;
+          assert.equal(iceConnected, false);
         });
 
       await testUtils.flushPromises();
@@ -61,21 +66,109 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check the right listener was registered
-      assert.calledTwice(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_GATHERING_STATE_CHANGED);
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], MediaConnectionEventNames.ICE_GATHERING_STATE_CHANGED);
+      const iceGatheringListener = mockMC.on.getCall(2).args[1];
+
+      mockMC.getIceGatheringState.returns('complete');
+      iceGatheringListener();
+
+      await clock.tickAsync(ICE_AND_DTLS_CONNECTION_TIMEOUT);
+      await testUtils.flushPromises();
+
+      assert.equal(promiseResolved, false);
+      assert.equal(promiseRejected, true);
+
+      assert.calledThrice(mockMC.off);
+    });
+
+    it('rejects immediately if ice state is FAILED', async () => {
+      mockMC.getConnectionState.returns(ConnectionState.Connecting);
+      mockMC.getIceGatheringState.returns('gathering');
+
+      let promiseResolved = false;
+      let promiseRejected = false;
+
+      mediaConnectionAwaiter
+        .waitForMediaConnectionConnected()
+        .then(() => {
+          promiseResolved = true;
+        })
+        .catch((error) => {
+          promiseRejected = true;
+
+          const {iceConnected} = error;
+          assert.equal(iceConnected, false);
+        });
+
+      await testUtils.flushPromises();
+      assert.equal(promiseResolved, false);
+      assert.equal(promiseRejected, false);
+
+      // check the right listener was registered
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], MediaConnectionEventNames.ICE_GATHERING_STATE_CHANGED);
+      const iceConnectionListener = mockMC.on.getCall(1).args[1];
+
+      mockMC.getConnectionState.returns(ConnectionState.Failed);
+      iceConnectionListener();
+
+      await testUtils.flushPromises();
+
+      assert.equal(promiseResolved, false);
+      assert.equal(promiseRejected, true);
+
+      assert.calledThrice(mockMC.off);
+    });
+
+    it('rejects after timeout if dtls state is not connected', async () => {
+      mockMC.getConnectionState.returns(ConnectionState.Connecting);
+      mockMC.getIceGatheringState.returns('gathering');
+
+      let promiseResolved = false;
+      let promiseRejected = false;
+
+      mediaConnectionAwaiter
+        .waitForMediaConnectionConnected()
+        .then(() => {
+          promiseResolved = true;
+        })
+        .catch((error) => {
+          promiseRejected = true;
+
+          const {iceConnected} = error;
+          assert.equal(iceConnected, false);
+        });
+
+      await testUtils.flushPromises();
+      assert.equal(promiseResolved, false);
+      assert.equal(promiseRejected, false);
+
+      // check the right listener was registered
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], MediaConnectionEventNames.ICE_GATHERING_STATE_CHANGED);
       const listener = mockMC.on.getCall(1).args[1];
+      const iceConnectionListener = mockMC.on.getCall(1).args[1];
 
       mockMC.getIceGatheringState.returns('complete');
       listener();
 
+      mockMC.getIceConnectionState.returns('connected');
+      iceConnectionListener();
+
       await clock.tickAsync(ICE_AND_DTLS_CONNECTION_TIMEOUT);
       await testUtils.flushPromises();
 
       assert.equal(promiseResolved, false);
       assert.equal(promiseRejected, true);
 
-      assert.calledTwice(mockMC.off);
+      assert.calledThrice(mockMC.off);
     });
 
     it('resolves after timeout if connection state reach connected/completed', async () => {
@@ -99,9 +192,10 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check the right listener was registered
-      assert.calledTwice(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_GATHERING_STATE_CHANGED);
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], MediaConnectionEventNames.ICE_GATHERING_STATE_CHANGED);
 
       mockMC.getConnectionState.returns(ConnectionState.Connected);
 
@@ -111,7 +205,7 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseResolved, true);
       assert.equal(promiseRejected, false);
 
-      assert.calledTwice(mockMC.off);
+      assert.calledThrice(mockMC.off);
     });
 
     it(`resolves when media connection reaches "connected" state`, async () => {
@@ -137,9 +231,10 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check the right listener was registered
-      assert.calledTwice(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_GATHERING_STATE_CHANGED);
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], MediaConnectionEventNames.ICE_GATHERING_STATE_CHANGED);
       const listener = mockMC.on.getCall(0).args[1];
 
       // call the listener and pretend we are now connected
@@ -151,7 +246,7 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check that listener was removed
-      assert.calledTwice(mockMC.off);
+      assert.calledThrice(mockMC.off);
 
       assert.calledOnce(clearTimeoutSpy);
     });
@@ -179,9 +274,10 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check the right listener was registered
-      assert.calledTwice(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_GATHERING_STATE_CHANGED);
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], MediaConnectionEventNames.ICE_GATHERING_STATE_CHANGED);
       const listener = mockMC.on.getCall(1).args[1];
 
       // call the listener and pretend we are now connected
@@ -197,7 +293,7 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check that listener was removed
-      assert.calledTwice(mockMC.off);
+      assert.calledThrice(mockMC.off);
 
       assert.neverCalledWith(clearTimeoutSpy);
     });
@@ -228,10 +324,11 @@ describe('MediaConnectionAwaiter', () => {
       assert.calledOnce(setTimeoutSpy);
 
       // check the right listener was registered
-      assert.calledTwice(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_GATHERING_STATE_CHANGED);
-      const listener = mockMC.on.getCall(1).args[1];
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], MediaConnectionEventNames.ICE_GATHERING_STATE_CHANGED);
+      const listener = mockMC.on.getCall(2).args[1];
 
       // call the listener and pretend we are now connected
       mockMC.getIceGatheringState.returns('complete');
@@ -249,7 +346,7 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check that listener was removed
-      assert.calledTwice(mockMC.off);
+      assert.calledThrice(mockMC.off);
     });
 
     it(`reject with restart timer once if gathering state is not complete`, async () => {
@@ -276,9 +373,10 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check the right listener was registered
-      assert.calledTwice(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_GATHERING_STATE_CHANGED);
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], MediaConnectionEventNames.ICE_GATHERING_STATE_CHANGED);
 
       await clock.tickAsync(ICE_AND_DTLS_CONNECTION_TIMEOUT * 2);
       await testUtils.flushPromises();
@@ -287,7 +385,7 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, true);
 
       // check that listener was removed
-      assert.calledTwice(mockMC.off);
+      assert.calledThrice(mockMC.off);
 
       assert.calledOnce(clearTimeoutSpy);
       assert.calledTwice(setTimeoutSpy);
@@ -317,11 +415,12 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check the right listener was registered
-      assert.calledTwice(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_GATHERING_STATE_CHANGED);
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], MediaConnectionEventNames.ICE_GATHERING_STATE_CHANGED);
       const connectionStateListener = mockMC.on.getCall(0).args[1];
-      const iceGatheringListener = mockMC.on.getCall(1).args[1];
+      const iceGatheringListener = mockMC.on.getCall(2).args[1];
 
       mockMC.getIceGatheringState.returns('complete');
       iceGatheringListener();
@@ -335,7 +434,7 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check that listener was removed
-      assert.calledTwice(mockMC.off);
+      assert.calledThrice(mockMC.off);
 
       assert.calledTwice(clearTimeoutSpy);
       assert.calledTwice(setTimeoutSpy);

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

@@ -1,60 +1,57 @@
-import * as internalMediaModule from '@webex/internal-media-core';
+import * as InternalMediaCoreModule from '@webex/internal-media-core';
 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';
-import {forEach} from 'lodash';
-import MockWebex from '@webex/test-helper-mock-webex';
 
 describe('createMediaConnection', () => {
   let clock;
   beforeEach(() => {
     clock = sinon.useFakeTimers();
   });
-  const webex = MockWebex();
 
   const fakeRoapMediaConnection = {
     id: 'roap media connection',
   };
   const fakeTrack = {
-    id: 'any fake track'
-  }
+    id: 'any fake track',
+  };
   const fakeAudioStream = {
     outputStream: {
       getTracks: () => {
         return [fakeTrack];
-      }
-    }
+      },
+    },
   };
   const fakeVideoStream = {
     outputStream: {
       getTracks: () => {
         return [fakeTrack];
-      }
-    }
+      },
+    },
   };
   const fakeShareVideoStream = {
     outputStream: {
       getTracks: () => {
         return [fakeTrack];
-      }
-    }
+      },
+    },
   };
   const fakeShareAudioStream = {
     outputStream: {
       getTracks: () => {
         return [fakeTrack];
-      }
-    }
+      },
+    },
   };
   afterEach(() => {
     sinon.restore();
-    clock.uninstall()
+    clock.uninstall();
   });
 
   it('creates a RoapMediaConnection when multistream is disabled', () => {
     const roapMediaConnectionConstructorStub = sinon
-      .stub(internalMediaModule, 'RoapMediaConnection')
+      .stub(InternalMediaCoreModule, 'RoapMediaConnection')
       .returns(fakeRoapMediaConnection);
 
     StaticConfig.set({bandwidth: {audio: 123, video: 456, startBitrate: 999}});
@@ -62,7 +59,7 @@ describe('createMediaConnection', () => {
     const ENABLE_EXTMAP = false;
     const ENABLE_RTX = true;
 
-    Media.createMediaConnection(false, 'some debug id', webex, 'meetingId', 'correlationId', {
+    Media.createMediaConnection(false, 'some debug id', 'meetingId', {
       mediaProperties: {
         mediaDirection: {
           sendAudio: false,
@@ -81,7 +78,7 @@ describe('createMediaConnection', () => {
       enableRtx: ENABLE_RTX,
       enableExtmap: ENABLE_EXTMAP,
       turnServerInfo: {
-        url: 'turn server url',
+        url: 'turns:turn-server-url:443?transport=tcp',
         username: 'turn username',
         password: 'turn password',
       },
@@ -92,7 +89,12 @@ describe('createMediaConnection', () => {
       {
         iceServers: [
           {
-            urls: 'turn server url',
+            urls: 'turn:turn-server-url:5004?transport=tcp',
+            username: 'turn username',
+            credential: 'turn password',
+          },
+          {
+            urls: 'turns:turn-server-url:443?transport=tcp',
             username: 'turn username',
             credential: 'turn password',
           },
@@ -132,10 +134,16 @@ describe('createMediaConnection', () => {
 
   it('creates a MultistreamRoapMediaConnection when multistream is enabled', () => {
     const multistreamRoapMediaConnectionConstructorStub = sinon
-      .stub(internalMediaModule, 'MultistreamRoapMediaConnection')
+      .stub(InternalMediaCoreModule, 'MultistreamRoapMediaConnection')
       .returns(fakeRoapMediaConnection);
 
-    Media.createMediaConnection(true, 'some debug id', webex, 'meeting id', 'correlationId', {
+    const rtcMetrics = {
+      addMetrics: sinon.stub(),
+      closeMetrics: sinon.stub(),
+      sendMetricsInQueue: sinon.stub(),
+    };
+
+    Media.createMediaConnection(true, 'some debug id', 'meeting id', {
       mediaProperties: {
         mediaDirection: {
           sendAudio: true,
@@ -146,8 +154,9 @@ describe('createMediaConnection', () => {
           receiveShare: true,
         },
       },
+      rtcMetrics,
       turnServerInfo: {
-        url: 'turn server url',
+        url: 'turns:turn-server-url:443?transport=tcp',
         username: 'turn username',
         password: 'turn password',
       },
@@ -159,7 +168,12 @@ describe('createMediaConnection', () => {
       {
         iceServers: [
           {
-            urls: 'turn server url',
+            urls: 'turn:turn-server-url:5004?transport=tcp',
+            username: 'turn username',
+            credential: 'turn password',
+          },
+          {
+            urls: 'turns:turn-server-url:443?transport=tcp',
             username: 'turn username',
             credential: 'turn password',
           },
@@ -168,18 +182,42 @@ describe('createMediaConnection', () => {
       },
       'meeting id'
     );
+
+    // check if rtcMetrics callbacks are configured correctly
+    const addMetricsCallback = multistreamRoapMediaConnectionConstructorStub.getCalls()[0].args[2];
+    const closeMetricsCallback = multistreamRoapMediaConnectionConstructorStub.getCalls()[0].args[3];
+    const sendMetricsInQueueCallback = multistreamRoapMediaConnectionConstructorStub.getCalls()[0].args[4];
+
+    assert.isFunction(addMetricsCallback);
+    assert.isFunction(closeMetricsCallback);
+    assert.isFunction(sendMetricsInQueueCallback);
+
+    const fakeMetricsData = {id: 'metrics data'};
+
+    addMetricsCallback(fakeMetricsData);
+    assert.calledOnceWithExactly(rtcMetrics.addMetrics, fakeMetricsData);
+
+    closeMetricsCallback();
+    assert.calledOnce(rtcMetrics.closeMetrics);
+
+    sendMetricsInQueueCallback();
+    assert.calledOnce(rtcMetrics.sendMetricsInQueue);
+
   });
 
   [
     {testCase: 'turnServerInfo is undefined', turnServerInfo: undefined},
-    {testCase: 'turnServerInfo.url is empty string', turnServerInfo: {url: '', username: 'turn username', password: 'turn password'}},
+    {
+      testCase: 'turnServerInfo.url is empty string',
+      turnServerInfo: {url: '', username: 'turn username', password: 'turn password'},
+    },
   ].forEach(({testCase, turnServerInfo}) => {
     it(`passes empty ICE servers array to MultistreamRoapMediaConnection if ${testCase} (multistream enabled)`, () => {
       const multistreamRoapMediaConnectionConstructorStub = sinon
-        .stub(internalMediaModule, 'MultistreamRoapMediaConnection')
+        .stub(InternalMediaCoreModule, 'MultistreamRoapMediaConnection')
         .returns(fakeRoapMediaConnection);
-  
-      Media.createMediaConnection(true, 'debug string', webex, 'meeting id', 'correlationId', {
+
+      Media.createMediaConnection(true, 'debug string', 'meeting id', {
         mediaProperties: {
           mediaDirection: {
             sendAudio: true,
@@ -199,16 +237,16 @@ describe('createMediaConnection', () => {
           iceServers: [],
         },
         'meeting id'
-        );
+      );
     });
   });
-      
+
   it('does not pass bundlePolicy to MultistreamRoapMediaConnection if bundlePolicy is undefined', () => {
     const multistreamRoapMediaConnectionConstructorStub = sinon
-      .stub(internalMediaModule, 'MultistreamRoapMediaConnection')
+      .stub(InternalMediaCoreModule, 'MultistreamRoapMediaConnection')
       .returns(fakeRoapMediaConnection);
 
-    Media.createMediaConnection(true, 'debug string', webex, 'meeting id', 'correlationId', {
+    Media.createMediaConnection(true, 'debug string', 'meeting id', {
       mediaProperties: {
         mediaDirection: {
           sendAudio: true,
@@ -233,11 +271,14 @@ describe('createMediaConnection', () => {
 
   [
     {testCase: 'turnServerInfo is undefined', turnServerInfo: undefined},
-    {testCase: 'turnServerInfo.url is empty string', turnServerInfo: {url: '', username: 'turn username', password: 'turn password'}},
+    {
+      testCase: 'turnServerInfo.url is empty string',
+      turnServerInfo: {url: '', username: 'turn username', password: 'turn password'},
+    },
   ].forEach(({testCase, turnServerInfo}) => {
     it(`passes empty ICE servers array to RoapMediaConnection if ${testCase} (multistream disabled)`, () => {
       const roapMediaConnectionConstructorStub = sinon
-        .stub(internalMediaModule, 'RoapMediaConnection')
+        .stub(InternalMediaCoreModule, 'RoapMediaConnection')
         .returns(fakeRoapMediaConnection);
 
       StaticConfig.set({bandwidth: {audio: 123, video: 456, startBitrate: 999}});
@@ -245,7 +286,7 @@ describe('createMediaConnection', () => {
       const ENABLE_EXTMAP = false;
       const ENABLE_RTX = true;
 
-      Media.createMediaConnection(false, 'some debug id', webex, 'meeting id', 'correlationId', {
+      Media.createMediaConnection(false, 'some debug id', 'meeting id', {
         mediaProperties: {
           mediaDirection: {
             sendAudio: true,