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

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

@@ -20,11 +20,11 @@ describe('plugin-meetings', () => {
     const initialConfig = {
       videoPacketLossRatioThreshold: 9,
       rttThreshold: 500,
-      jitterThreshold: 500
+      jitterThreshold: 500,
     };
 
     const configObject = {
-      mediaType: 'video',
+      mediaType: 'video-send',
       remoteRtpResults: {
         id: 'RTCRemoteInboundRtpVideoStream_2411086660',
         timestamp: 1624472676193.79,
@@ -39,20 +39,20 @@ describe('plugin-meetings', () => {
         roundTripTime: 0.648,
         fractionLost: 0,
         totalRoundTripTime: 3.554,
-        roundTripTimeMeasurements: 14
+        roundTripTimeMeasurements: 14,
       },
       statsAnalyzerCurrentStats: {
-        audio: {
+        'audio-send': {
           send: {
-            currentPacketLossRatio: 8
-          }
+            currentPacketLossRatio: 8,
+          },
         },
-        video: {
+        'video-send': {
           send: {
-            currentPacketLossRatio: 10
-          }
-        }
-      }
+            currentPacketLossRatio: 10,
+          },
+        },
+      },
     };
 
     const sandbox = sinon.createSandbox();
@@ -75,13 +75,19 @@ describe('plugin-meetings', () => {
 
     it('should emit a network quality judgement event with the proper payload', async () => {
       await networkQualityMonitor.determineUplinkNetworkQuality(configObject);
-      assert(sandBoxEmitSpy.calledWith(sinon.match({
-        file: 'networkQualityMonitor',
-        function: 'emitNetworkQuality'
-      }), sinon.match(EVENT_TRIGGERS.NETWORK_QUALITY), sinon.match({
-        mediaType: 'video',
-        networkQualityScore: 0
-      })));
+      assert(
+        sandBoxEmitSpy.calledWith(
+          sinon.match({
+            file: 'networkQualityMonitor',
+            function: 'emitNetworkQuality',
+          }),
+          sinon.match(EVENT_TRIGGERS.NETWORK_QUALITY),
+          sinon.match({
+            mediaType: 'video-send',
+            networkQualityScore: 0,
+          })
+        )
+      );
     });
 
     it('should reset to default values after determineUplinkNetworkQuality call stack is complete', async () => {

package/test/unit/spec/personal-meeting-room/personal-meeting-room.js

@@ -5,9 +5,7 @@
 import 'jsdom-global/register';
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
-import {
-  _PERSONAL_ROOM_
-} from '@webex/plugin-meetings/src/constants';
+import {_PERSONAL_ROOM_} from '@webex/plugin-meetings/src/constants';
 import PersonalMeetingRoom from '@webex/plugin-meetings/src/personal-meeting-room';
 
 describe('personal-meeting-room', () => {
@@ -16,14 +14,11 @@ describe('personal-meeting-room', () => {
 
   beforeEach(() => {
     meetingInfo = {
-      fetchMeetingInfo: sinon.stub().returns(Promise.resolve(
-        {body: {isPmr: true}}
-      ))
+      fetchMeetingInfo: sinon.stub().returns(Promise.resolve({body: {isPmr: true}})),
     };
     pmr = new PersonalMeetingRoom({meetingInfo}, {parent: {}});
   });
 
-
   describe('#get()', () => {
     it('returns personal meeting room info', async () => {
       await pmr.get();

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

@@ -1,52 +1,201 @@
 import {assert} from '@webex/test-helper-chai';
-import Reachability from '@webex/plugin-meetings/src/reachability/';
+import MockWebex from '@webex/test-helper-mock-webex';
+import sinon from 'sinon';
+import Reachability, {ICECandidateResult} from '@webex/plugin-meetings/src/reachability/';
 
 describe('isAnyClusterReachable', () => {
-  before(function () {
-    this.jsdom = require('jsdom-global')('', {url: 'http://localhost'});
-  });
-  after(function () {
-    this.jsdom();
-  });
+  let webex;
 
-  afterEach(() => {
-    window.localStorage.clear()
+  beforeEach(() => {
+    webex = new MockWebex();
   });
 
-  const checkIsClusterReachable = (mockStorage: any, expectedValue: boolean) => {
-
+  const checkIsClusterReachable = async (mockStorage: any, expectedValue: boolean) => {
     if (mockStorage) {
-      window.localStorage.setItem('reachability.result', JSON.stringify(mockStorage))
+      await webex.boundedStorage.put(
+        'Reachability',
+        'reachability.result',
+        JSON.stringify(mockStorage)
+      );
     }
-    const reachability = new Reachability({});
+    const reachability = new Reachability(webex);
 
-    const result = reachability.isAnyClusterReachable();
+    const result = await reachability.isAnyClusterReachable();
 
     assert.equal(result, expectedValue);
+  };
+
+  it('returns true when udp is reachable', async () => {
+    await checkIsClusterReachable({x: {udp: {reachable: 'true'}, tcp: {reachable: 'false'}}}, true);
+  });
 
-  }
+  it('returns true when tcp is reachable', async () => {
+    await checkIsClusterReachable({x: {udp: {reachable: 'false'}, tcp: {reachable: 'true'}}}, true);
+  });
 
-  it('returns true when udp is reachable', () => {
-    checkIsClusterReachable({x: {udp: {reachable: 'true'}, tcp: {reachable: 'false'}}}, true)
+  it('returns true when both tcp and udp are reachable', async () => {
+    await checkIsClusterReachable({x: {udp: {reachable: 'true'}, tcp: {reachable: 'true'}}}, true);
   });
 
-  it('returns true when tcp is reachable', () => {
-    checkIsClusterReachable({x: {udp: {reachable: 'false'}, tcp: {reachable: 'true'}}}, true)
+  it('returns false when both tcp and udp are unreachable', async () => {
+    await checkIsClusterReachable({x: {udp: {reachable: 'false'}, tcp: {reachable: 'false'}}}, false);
   });
 
-  it('returns true when both tcp and udp are reachable', () => {
-    checkIsClusterReachable({x: {udp: {reachable: 'true'}, tcp: {reachable: 'true'}}}, true)
+  it('returns false when reachability result is empty', async () => {
+    await checkIsClusterReachable({x: {}}, false);
   });
 
-  it('returns false when both tcp and udp are unreachable', () => {
-    checkIsClusterReachable({x: {udp: {reachable: 'false'}, tcp: {reachable: 'false'}}}, false)
+  it('returns false when reachability.result item is not there', async () => {
+    await checkIsClusterReachable(undefined, false);
   });
+});
+
+describe('gatherReachability', () => {
+  let webex;
+
+  beforeEach(async () => {
+    webex = new MockWebex();
+
+    await webex.boundedStorage.put(
+      'Reachability',
+      'reachability.result',
+      JSON.stringify({old: 'results'})
+    );
+  });
+
+  it('stores the reachability', async () => {
+    const reachability = new Reachability(webex);
+
+    const reachabilityResults = {
+      clusters: {
+        clusterId: {
+          udp: 'testUDP',
+        },
+      },
+    };
+    const getClustersResult = {
+      clusters: {clusterId: 'cluster'},
+      joinCookie: {id: 'id'},
+    };
+
+    reachability.reachabilityRequest.getClusters = sinon.stub().returns(getClustersResult);
+    (reachability as any).performReachabilityCheck = sinon.stub().returns(reachabilityResults);
+
+    const result = await reachability.gatherReachability();
 
-  it('returns false when reachability result is empty', () => {
-    checkIsClusterReachable({x: {}}, false)
+    assert.equal(result, reachabilityResults);
+
+    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);
   });
 
-  it('returns false when reachability.result item is not there', () => {
-    checkIsClusterReachable(undefined, false)
+  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,
+      });
+    });
   });
 });

package/test/unit/spec/reachability/request.js

@@ -0,0 +1,66 @@
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+import MockWebex from '@webex/test-helper-mock-webex';
+import Meetings from '@webex/plugin-meetings';
+import ReachabilityRequest from '@webex/plugin-meetings/src/reachability/request';
+
+
+describe('plugin-meetings/reachability', () => {
+  let reachabilityRequest;
+  let webex;
+
+  beforeEach(() => {
+    webex = new MockWebex({
+      children: {
+        meetings: Meetings,
+      },
+    });
+
+    webex.meetings.clientRegion = {
+      countryCode: 'US',
+      regionCode: 'WEST-COAST',
+    };
+
+    webex.internal = {
+      services: {
+        get: sinon.mock().returns('locusUrl'),
+        waitForCatalog: sinon.mock().returns(Promise.resolve({})),
+      },
+    };
+
+
+    reachabilityRequest = new ReachabilityRequest(webex);
+
+  });
+
+  describe('#getClusters', () => {
+    it('sends a GET request with the correct params', async () => {
+      webex.request = sinon.mock().returns(Promise.resolve({
+        body: {
+          clusterClasses: {
+            hybridMedia: ["clusterId"]
+          },
+          clusters: {"clusterId": {
+            udp: "testUDP"
+          }},
+          joinCookie: {anycastEntryPoint: "aws-eu-west-1"}
+        }
+      }));
+
+      const res = await reachabilityRequest.getClusters();
+
+      const requestParams = webex.request.getCall(0).args[0];
+
+      assert.equal(requestParams.method, 'GET');
+      assert.equal(requestParams.resource, `clusters`);
+      assert.equal(requestParams.api, 'calliopeDiscovery');
+      assert.equal(requestParams.shouldRefreshAccessToken, false);
+
+      assert.deepEqual(requestParams.qs, {
+        JCSupport: 1,
+      });
+      assert.deepEqual(res.clusters.clusterId, {udp: "testUDP", isVideoMesh: true})
+      assert.deepEqual(res.joinCookie, {anycastEntryPoint: "aws-eu-west-1"})
+    });
+  });
+});

package/test/unit/spec/reconnection-manager/index.js

@@ -2,8 +2,7 @@ import 'jsdom-global/register';
 import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 import sinon from 'sinon';
-
-import ReconnectionManager from '../../../../src/reconnection-manager';
+import ReconnectionManager from '@webex/plugin-meetings/src/reconnection-manager';
 
 const {assert} = chai;
 
@@ -11,6 +10,154 @@ chai.use(chaiAsPromised);
 sinon.assert.expose(chai.assert, {prefix: ''});
 
 describe('plugin-meetings', () => {
+  describe('ReconnectionManager.reconnect', () => {
+    let fakeMediaConnection;
+    let fakeMeeting;
+
+    beforeEach(() => {
+      fakeMediaConnection = {
+        initiateOffer: sinon.stub().resolves({}),
+        reconnect: sinon.stub().resolves({}),
+      };
+      fakeMeeting = {
+        closePeerConnections: sinon.stub().resolves({}),
+        createMediaConnection: sinon.stub().returns(fakeMediaConnection),
+        config: {
+          reconnection: {
+            enabled: true,
+            detection: true,
+            iceReconnectionTimeout: 10000,
+            retry: {
+              times: 2,
+              backOff: {
+                start: 1000,
+                rate: 2,
+              },
+            },
+          },
+        },
+        mediaProperties: {
+          unsetPeerConnection: sinon.stub(),
+          webrtcMediaConnection: fakeMediaConnection,
+        },
+        mediaRequestManagers: {
+          audio: {commit: sinon.stub(), clearPreviousRequests: sinon.stub()},
+          video: {commit: sinon.stub(), clearPreviousRequests: sinon.stub()},
+        },
+        roap: {
+          doTurnDiscovery: sinon.stub().resolves({
+            turnServerInfo: {
+              url: 'fake_turn_url',
+              username: 'fake_turn_username',
+              password: 'fake_turn_password',
+            },
+            turnDiscoverySkippedReason: undefined,
+          }),
+        },
+        statsAnalyzer: {
+          updateMediaConnection: sinon.stub(),
+        },
+        webex: {
+          meetings: {
+            getMeetingByType: sinon.stub().returns(true),
+            syncMeetings: sinon.stub().resolves({}),
+          },
+          internal: {
+            newMetrics: {
+              submitClientEvent: sinon.stub()
+            }
+          }
+        },
+      };
+    });
+
+    it('uses correct TURN TLS information on the reconnection', async () => {
+      const rm = new ReconnectionManager(fakeMeeting);
+
+      await rm.reconnect();
+
+      assert.calledOnce(fakeMeeting.roap.doTurnDiscovery);
+      assert.calledOnce(fakeMediaConnection.reconnect);
+      assert.calledWith(fakeMediaConnection.reconnect, [
+        {
+          urls: 'fake_turn_url',
+          username: 'fake_turn_username',
+          credential: 'fake_turn_password',
+        },
+      ]);
+
+      assert.calledWith(fakeMeeting.webex.internal.newMetrics.submitClientEvent, {
+        name: 'client.media.reconnecting',
+        options: {
+          meetingId: rm.meeting.id,
+        },
+      });
+
+      assert.calledWith(fakeMeeting.webex.internal.newMetrics.submitClientEvent, {
+        name: 'client.media.recovered',
+        payload: {
+          recoveredBy: 'new',
+        },
+        options: {
+          meetingId: rm.meeting.id,
+        },
+      });
+    });
+
+    it('does not clear previous requests and re-request media for non-multistream meetings', async () => {
+      fakeMeeting.isMultistream = false;
+      const rm = new ReconnectionManager(fakeMeeting);
+
+      await rm.reconnect();
+
+      assert.notCalled(fakeMeeting.mediaRequestManagers.audio.clearPreviousRequests);
+      assert.notCalled(fakeMeeting.mediaRequestManagers.video.clearPreviousRequests);
+      assert.notCalled(fakeMeeting.mediaRequestManagers.audio.commit);
+      assert.notCalled(fakeMeeting.mediaRequestManagers.video.commit);
+    });
+
+    it('does clear previous requests and re-request media for multistream meetings', async () => {
+      fakeMeeting.isMultistream = true;
+      const rm = new ReconnectionManager(fakeMeeting);
+
+      await rm.reconnect();
+
+      assert.calledOnce(fakeMeeting.mediaRequestManagers.audio.clearPreviousRequests);
+      assert.calledOnce(fakeMeeting.mediaRequestManagers.video.clearPreviousRequests);
+      assert.calledOnce(fakeMeeting.mediaRequestManagers.audio.commit);
+      assert.calledOnce(fakeMeeting.mediaRequestManagers.video.commit);
+    });
+
+
+    it('sends the correct client event when reconnection fails', async () => {
+      sinon.stub(ReconnectionManager.prototype, 'executeReconnection').rejects();
+      fakeMeeting.isMultistream = true;
+      const rm = new ReconnectionManager(fakeMeeting);
+
+      try {
+        await rm.reconnect();
+      } catch (err) {
+        assert.calledWith(fakeMeeting.webex.internal.newMetrics.submitClientEvent, {
+          name: 'client.call.aborted',
+          payload: {
+            errors: [
+              {
+                category: 'expected',
+                errorCode: 2008,
+                fatal: true,
+                name: 'media-engine',
+                shownToUser: false,
+              },
+            ],
+          },
+          options: {
+            meetingId: rm.meeting.id,
+          },
+        });
+      }
+    });
+  });
+
   /**
    * Currently, testing dependent classes that aren't available at the top
    * level causes testing errors in CI based around related files. Skipping this here until a solution
@@ -30,11 +177,11 @@ describe('plugin-meetings', () => {
               times: 2,
               backOff: {
                 start: 1000,
-                rate: 2
-              }
-            }
-          }
-        }
+                rate: 2,
+              },
+            },
+          },
+        },
       });
     });
 
@@ -53,8 +200,7 @@ describe('plugin-meetings', () => {
         });
 
         it('should resolve the deferred promise', () => {
-          reconnectionManager.iceState.resolve =
-            sinon.spy();
+          reconnectionManager.iceState.resolve = sinon.spy();
           const {resolve} = reconnectionManager.iceState;
 
           reconnectionManager.iceReconnected();