@webex/plugin-meetings 3.0.0-beta.47 → 3.0.0-beta.49

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

@@ -3,6 +3,7 @@ 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';
 
 describe('createMediaConnection', () => {
   const fakeRoapMediaConnection = {
@@ -103,6 +104,16 @@ describe('createMediaConnection', () => {
       .returns(fakeRoapMediaConnection);
 
     Media.createMediaConnection(true, 'some debug id', {
+      mediaProperties: {
+        mediaDirection: {
+          sendAudio: true,
+          sendVideo: true,
+          sendShare: false,
+          receiveAudio: true,
+          receiveVideo: true,
+          receiveShare: true,
+        }
+      },
       turnServerInfo: {
         url: 'turn server url',
         username: 'turn username',
@@ -120,22 +131,73 @@ describe('createMediaConnection', () => {
             credential: 'turn password',
           },
         ],
+        enableMainAudio: true,
+        enableMainVideo: true,
       },
       'some debug id'
     );
   });
 
+  forEach([
+    {sendAudio: true, receiveAudio: true, sendVideo: true, receiveVideo: true, enableMainAudio: true, enableMainVideo: true,},
+    {sendAudio: true, receiveAudio: false, sendVideo: true, receiveVideo: false, enableMainAudio: true, enableMainVideo: true,},
+    {sendAudio: false, receiveAudio: true, sendVideo: false, receiveVideo: true, enableMainAudio: true, enableMainVideo: true,},
+    {sendAudio: false, receiveAudio: false, sendVideo: false, receiveVideo: false, enableMainAudio: false, enableMainVideo: false,},
+  ], ({sendAudio, sendVideo, receiveAudio, receiveVideo, enableMainAudio, enableMainVideo}) => {
+    it(`sets enableMainVideo to ${enableMainVideo} and enableMainAudio to ${enableMainAudio} when sendAudio: ${sendAudio} sendVideo: ${sendVideo} receiveAudio: ${receiveAudio} receiveVideo: ${receiveVideo}`, () => {
+      const multistreamRoapMediaConnectionConstructorStub = sinon
+        .stub(internalMediaModule, 'MultistreamRoapMediaConnection')
+        .returns(fakeRoapMediaConnection);
+
+      Media.createMediaConnection(true, 'some debug id', {
+        mediaProperties: {
+          mediaDirection: {
+            sendAudio,
+            sendVideo,
+            sendShare: false,
+            receiveAudio,
+            receiveVideo,
+            receiveShare: true,
+          },
+        },
+      });
+      assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
+      assert.calledWith(
+        multistreamRoapMediaConnectionConstructorStub,
+        {
+          iceServers: [],
+          enableMainAudio,
+          enableMainVideo,
+        },
+        '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', {});
+    Media.createMediaConnection(true, 'debug string', {
+      mediaProperties: {
+        mediaDirection: {
+          sendAudio: true,
+          sendVideo: true,
+          sendShare: false,
+          receiveAudio: true,
+          receiveVideo: true,
+          receiveShare: true,
+        },
+      },
+    });
     assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
     assert.calledWith(
       multistreamRoapMediaConnectionConstructorStub,
       {
         iceServers: [],
+        enableMainAudio: true,
+        enableMainVideo: true,
       },
       'debug string'
     );

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

@@ -2,7 +2,7 @@
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
 import 'jsdom-global/register';
-import {cloneDeep, isEqual} from 'lodash';
+import {cloneDeep, forEach, isEqual} from 'lodash';
 import sinon from 'sinon';
 import StateMachine from 'javascript-state-machine';
 import uuid from 'uuid';
@@ -2195,6 +2195,43 @@ describe('plugin-meetings', () => {
           sandbox = null;
         });
 
+        forEach(
+          [
+            {receiveAudio: true, sendAudio: true, enableMultistreamAudio: true},
+            {receiveAudio: true, sendAudio: false, enableMultistreamAudio: true},
+            {receiveAudio: false, sendAudio: true, enableMultistreamAudio: true},
+            {receiveAudio: false, sendAudio: false, enableMultistreamAudio: false},
+          ],
+          ({receiveAudio, sendAudio, enableMultistreamAudio}) => {
+            it(`should call enableMultistreamAudio with ${enableMultistreamAudio} if it is a multistream connection and receiveAudio: ${receiveAudio} sendAudio: ${sendAudio}`, async () => {
+              const mediaSettings = {
+                sendAudio,
+                receiveAudio,
+                sendVideo: true,
+                receiveVideo: true,
+                sendShare: true,
+                receiveShare: true,
+                isSharing: true,
+              };
+
+              meeting.mediaProperties.webrtcMediaConnection = {
+                enableMultistreamAudio: sinon.stub().resolves('some value'),
+              };
+              meeting.isMultistream = true;
+
+              const result = await meeting.updateMedia({
+                  mediaSettings,
+              });
+
+              assert.calledOnceWithExactly(
+                meeting.mediaProperties.webrtcMediaConnection.enableMultistreamAudio,
+                enableMultistreamAudio
+              );
+              assert.equal(result, 'some value');
+            });
+          }
+        );
+
         it('should use a queue if currently busy', async () => {
           const mediaSettings = {
             sendAudio: true,

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

@@ -1,7 +1,7 @@
 import {assert} from '@webex/test-helper-chai';
 import MockWebex from '@webex/test-helper-mock-webex';
 import sinon from 'sinon';
-import Reachability from '@webex/plugin-meetings/src/reachability/';
+import Reachability, {ICECandidateResult} from '@webex/plugin-meetings/src/reachability/';
 
 describe('isAnyClusterReachable', () => {
   let webex;
@@ -22,8 +22,8 @@ describe('isAnyClusterReachable', () => {
 
     const result = await reachability.isAnyClusterReachable();
 
-      assert.equal(result, expectedValue);
-    };
+    assert.equal(result, expectedValue);
+  };
 
   it('returns true when udp is reachable', async () => {
     await checkIsClusterReachable({x: {udp: {reachable: 'true'}, tcp: {reachable: 'false'}}}, true);
@@ -72,24 +72,130 @@ describe('gatherReachability', () => {
           udp: 'testUDP',
         },
       },
-    }
+    };
     const getClustersResult = {
       clusters: {clusterId: 'cluster'},
-      joinCookie: {id: 'id'}
+      joinCookie: {id: 'id'},
     };
 
     reachability.reachabilityRequest.getClusters = sinon.stub().returns(getClustersResult);
-    (reachability as any).performReachabilityCheck = sinon.stub().returns(reachabilityResults)
+    (reachability as any).performReachabilityCheck = sinon.stub().returns(reachabilityResults);
 
     const result = await reachability.gatherReachability();
 
     assert.equal(result, reachabilityResults);
 
-    const storedResultForReachabilityResult = await webex.boundedStorage.get('Reachability', 'reachability.result');
-    const storedResultForJoinCookie = await webex.boundedStorage.get('Reachability', 'reachability.joinCookie');
+    const storedResultForReachabilityResult = await webex.boundedStorage.get(
+      'Reachability',
+      'reachability.result'
+    );
+    const storedResultForJoinCookie = await webex.boundedStorage.get(
+      'Reachability',
+      'reachability.joinCookie'
+    );
 
     assert.equal(JSON.stringify(result), storedResultForReachabilityResult);
     assert.equal(JSON.stringify(getClustersResult.joinCookie), storedResultForJoinCookie);
   });
 
+  describe('clientMediaIPs', () => {
+    let testingClass: TestReachability;
+
+    class TestReachability extends Reachability {
+      public testParseIceResultsToReachabilityResults(iceResults: Array<ICECandidateResult>) {
+        return this.parseIceResultsToReachabilityResults(iceResults);
+      }
+      public testAddPublicIP(peerConnection: RTCPeerConnection, publicIP?: string | null) {
+        return this.addPublicIP(peerConnection, publicIP);
+      }
+    }
+    beforeEach(() => {
+      testingClass = new TestReachability({webex});
+    });
+
+    it('calls parseIceResultsToReachabilityResults correctly', () => {
+      const res = testingClass.testParseIceResultsToReachabilityResults([
+        {
+          clusterId: 'id1',
+          elapsed: '12312',
+          publicIPs: ['1.1.1.1'],
+        },
+        {
+          clusterId: 'id2',
+          elapsed: null,
+          publicIPs: ['1.1.1.1'],
+        },
+        {
+          clusterId: 'id2',
+          elapsed: '14123',
+          publicIPs: undefined,
+        },
+      ]);
+
+      assert.deepEqual(res, {
+        id1: {
+          tcp: {
+            clientMediaIPs: ['1.1.1.1'],
+            latencyInMilliseconds: '12312',
+            reachable: 'true',
+          },
+          udp: {
+            clientMediaIPs: ['1.1.1.1'],
+            latencyInMilliseconds: '12312',
+            reachable: 'true',
+          },
+        },
+        id2: {
+          tcp: {
+            latencyInMilliseconds: '14123',
+            reachable: 'true',
+          },
+          udp: {
+            latencyInMilliseconds: '14123',
+            reachable: 'true',
+          },
+        },
+      });
+    });
+
+    it('calls addPublicIP correctly with no existing public APIs', () => {
+      const peerConnection = {
+        connectionState: 'not_closed',
+      };
+
+      testingClass.testAddPublicIP(peerConnection as RTCPeerConnection, '1.1.1.1');
+
+      assert.deepEqual(peerConnection, {
+        connectionState: 'not_closed',
+        publicIPs: ['1.1.1.1'],
+      });
+    });
+
+    it('calls addPublicIP correctly with existing public APIs', () => {
+      const peerConnection = {
+        connectionState: 'not_closed',
+        publicIPs: ['2.2.2.2'],
+      };
+
+      testingClass.testAddPublicIP(peerConnection as any, '1.1.1.1');
+
+      assert.deepEqual(peerConnection, {
+        connectionState: 'not_closed',
+        publicIPs: ['2.2.2.2', '1.1.1.1'],
+      });
+    });
+
+    it('calls addPublicIP correctly null publicAPI', () => {
+      const peerConnection = {
+        connectionState: 'not_closed',
+      };
+
+      testingClass.testAddPublicIP(peerConnection as RTCPeerConnection, null);
+
+      assert.deepEqual(peerConnection, {
+        connectionState: 'not_closed',
+        publicIPs: null,
+      });
+    });
+  });
 });