@webex/plugin-meetings 3.0.0-beta.0 → 3.0.0-beta.10

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

@@ -0,0 +1,207 @@
+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(false, 'some debug id', {
+      mediaProperties: {
+        mediaDirection: {
+          sendAudio: true,
+          sendVideo: true,
+          sendShare: false,
+          receiveAudio: true,
+          receiveVideo: true,
+          receiveShare: true,
+        },
+        audioTrack: fakeAudioTrack,
+        videoTrack: fakeVideoTrack,
+        shareTrack: null,
+      },
+      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',
+        },
+      },
+      'some debug id'
+    );
+  });
+
+  it('creates a MultistreamRoapMediaConnection when multistream is enabled', () => {
+    const multistreamRoapMediaConnectionConstructorStub = sinon
+      .stub(internalMediaModule, 'MultistreamRoapMediaConnection')
+      .returns(fakeRoapMediaConnection);
+
+    Media.createMediaConnection(true, 'some debug id', {
+      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',
+          },
+        ],
+      },
+      'some debug id'
+    );
+  });
+
+  it('passes empty ICE servers array to MultistreamRoapMediaConnection if turnServerInfo is undefined (multistream enabled)', () => {
+    const multistreamRoapMediaConnectionConstructorStub = sinon
+      .stub(internalMediaModule, 'MultistreamRoapMediaConnection')
+      .returns(fakeRoapMediaConnection);
+
+    Media.createMediaConnection(true, 'debug string', {});
+    assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
+    assert.calledWith(
+      multistreamRoapMediaConnectionConstructorStub,
+      {
+        iceServers: [],
+      },
+      'debug string'
+    );
+  });
+
+  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(false, 'some debug id', {
+      mediaProperties: {
+        mediaDirection: {
+          sendAudio: true,
+          sendVideo: true,
+          sendShare: true,
+          receiveAudio: true,
+          receiveVideo: true,
+          receiveShare: true,
+        },
+        audioTrack: fakeAudioTrack,
+        videoTrack: null,
+        shareTrack: fakeVideoTrack,
+      },
+      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',
+        },
+      },
+      'some debug id'
+    );
+  });
+});

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',

package/test/unit/spec/meeting/effectsState.js

@@ -3,7 +3,6 @@ import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
 import MockWebex from '@webex/test-helper-mock-webex';
 import {BNR_STATUS} from '@webex/plugin-meetings/src/constants';
-
 import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
 import Meeting from '@webex/plugin-meetings/src/meeting';
 import Meetings from '@webex/plugin-meetings';
@@ -161,7 +160,6 @@ describe('plugin-meetings', () => {
         meetings: Meetings
       }
     });
-    MediaUtil.createPeerConnection = sinon.stub().returns({});
     meeting = new Meeting(
       {
         userId: uuid1
@@ -174,7 +172,6 @@ describe('plugin-meetings', () => {
     effects = createEffectsState('BNR');
     meeting.canUpdateMedia = sinon.stub().returns(true);
     MeetingUtil.validateOptions = sinon.stub().returns(Promise.resolve());
-    MeetingUtil.updateTransceiver = sinon.stub();
 
     meeting.addMedia = sinon.stub().returns(Promise.resolve());
     meeting.getMediaStreams = sinon.stub().returns(Promise.resolve());
@@ -184,6 +181,7 @@ describe('plugin-meetings', () => {
       sinon.stub(meeting.mediaProperties, 'mediaDirection').value({
         receiveAudio: true
       });
+      sinon.stub(meeting.mediaProperties, 'webrtcMediaConnection').value({updateSendReceiveOptions: sinon.stub()});
     });
   });