@webex/plugin-meetings 3.0.0-beta.4 → 3.0.0-beta.400

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

@@ -0,0 +1,68 @@
+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';
+import {IP_VERSION} from '@webex/plugin-meetings/src/constants';
+
+
+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(IP_VERSION.only_ipv4);
+
+      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,
+        ipver: 4,
+      });
+      assert.deepEqual(res.clusters.clusterId, {udp: "testUDP", isVideoMesh: true})
+      assert.deepEqual(res.joinCookie, {anycastEntryPoint: "aws-eu-west-1"})
+    });
+  });
+});

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

@@ -0,0 +1,40 @@
+import {assert} from '@webex/test-helper-chai';
+
+import {convertStunUrlToTurn} from '@webex/plugin-meetings/src/reachability/util';
+
+describe('plugin-meetings/src/reachability/util', () => {
+  describe('#convertStunUrlToTurn()', () => {
+    [
+      {
+        title: 'a stun url with port',
+        stunUrl: 'stun:external-media91.public.wjfkm-a-10.prod.infra.webex.com:5004',
+        expectedUrlPart: 'external-media91.public.wjfkm-a-10.prod.infra.webex.com:5004',
+      },
+      {
+        title: 'a stun url without port',
+        stunUrl: 'stun:something.somewhere.com',
+        expectedUrlPart: 'something.somewhere.com',
+      },
+    ].forEach(({title, stunUrl, expectedUrlPart}) => {
+      it(`should convert ${title} to a TCP turn url`, () => {
+        const turnUrl = convertStunUrlToTurn(stunUrl, 'tcp');
+
+        assert.equal(turnUrl, `turn:${expectedUrlPart}?transport=tcp`);
+      });
+
+      it(`should convert ${title} to a UDP turn url`, () => {
+        const turnUrl = convertStunUrlToTurn(stunUrl, 'udp');
+
+        assert.equal(turnUrl, `turn:${expectedUrlPart}`);
+      });
+    });
+
+    it('show fail if stunUrl is not a valid url', () => {
+      assert.throws(() => convertStunUrlToTurn('not a url', 'tcp'), 'Invalid URL: not a url');
+    });
+
+    it('show fail if stunUrl is not a STUN url', () => {
+      assert.throws(() => convertStunUrlToTurn('http://webex.com', 'tcp'), 'Not a STUN URL: http://webex.com');
+    });
+  });
+});

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

@@ -3,7 +3,9 @@ import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 import sinon from 'sinon';
 import ReconnectionManager from '@webex/plugin-meetings/src/reconnection-manager';
-import Metrics from '@webex/plugin-meetings/src/metrics';
+import { RECONNECTION } from '../../../../src/constants';
+import LoggerProxy from '../../../../src/common/logs/logger-proxy';
+import LoggerConfig from '../../../../src/common/logs/logger-config';
 
 const {assert} = chai;
 
@@ -12,13 +14,23 @@ sinon.assert.expose(chai.assert, {prefix: ''});
 
 describe('plugin-meetings', () => {
   describe('ReconnectionManager.reconnect', () => {
-    it('uses correct TURN TLS information on the new connection', async () => {
-      Metrics.postEvent = sinon.stub();
+    const sandbox = sinon.createSandbox();
+    let fakeMediaConnection;
+    let fakeMeeting;
+    let loggerSpy;
+
+    before(() => {
+      LoggerConfig.set({ enable: false });
+      LoggerProxy.set();
+      loggerSpy = sandbox.spy(LoggerProxy.logger, 'info');
+    });
 
-      const fakeMediaConnection = {
-        initiateOffer: sinon.stub().resolves({})
+    beforeEach(() => {
+      fakeMediaConnection = {
+        initiateOffer: sinon.stub().resolves({}),
+        reconnect: sinon.stub().resolves({}),
       };
-      const fakeMeeting = {
+      fakeMeeting = {
         closePeerConnections: sinon.stub().resolves({}),
         createMediaConnection: sinon.stub().returns(fakeMediaConnection),
         config: {
@@ -30,13 +42,18 @@ describe('plugin-meetings', () => {
               times: 2,
               backOff: {
                 start: 1000,
-                rate: 2
-              }
-            }
-          }
+                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({
@@ -45,34 +62,166 @@ describe('plugin-meetings', () => {
               username: 'fake_turn_username',
               password: 'fake_turn_password',
             },
-            turnDiscoverySkippedReason: undefined
-          })
+            turnDiscoverySkippedReason: undefined,
+          }),
         },
         statsAnalyzer: {
           updateMediaConnection: sinon.stub(),
         },
         webex: {
+          credentials: {
+            isUnverifiedGuest: false,
+          },
           meetings: {
             getMeetingByType: sinon.stub().returns(true),
-            syncMeetings: sinon.stub().resolves({})
+            syncMeetings: sinon.stub().resolves({}),
+            startReachability: sinon.stub().resolves({}),
+          },
+          internal: {
+            newMetrics: {
+              submitClientEvent: sinon.stub()
+            }
           }
-        }
+        },
       };
+    });
+
+    afterEach(() => {
+      sandbox.reset();
+    });
+
+    it('calls syncMeetings', async () => {
+      const rm = new ReconnectionManager(fakeMeeting);
+
+      await rm.reconnect();
+
+      assert.calledOnce(rm.webex.meetings.syncMeetings);
+      assert.calledWith(rm.webex.meetings.syncMeetings, {keepOnlyLocusMeetings: false});
+    });
+
+    it('calls startReachability on reconnect', async () => {
+      const rm = new ReconnectionManager(fakeMeeting);
+
+      await rm.reconnect();
+
+      assert.calledOnce(rm.webex.meetings.startReachability);
+    });
+
+    it('continues with reconnection attempt if startReachability throws an error', async () => {
+      const reachabilityError = new Error();
+      fakeMeeting.webex.meetings.startReachability = sinon.stub().throws(reachabilityError);
 
       const rm = new ReconnectionManager(fakeMeeting);
 
       await rm.reconnect();
 
-      assert.calledOnce(fakeMeeting.closePeerConnections);
-      assert.calledOnce(fakeMeeting.mediaProperties.unsetPeerConnection);
+      assert.calledOnce(rm.webex.meetings.startReachability);
+      assert.calledWith(loggerSpy, 'ReconnectionManager:index#reconnect --> Reachability failed, continuing with reconnection attempt, err: ', reachabilityError);
+      assert.calledWith(loggerSpy, 'ReconnectionManager:index#executeReconnection --> Attempting to reconnect to meeting.');
+    });
+
+    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(fakeMeeting.createMediaConnection);
-      assert.calledWith(fakeMeeting.createMediaConnection, {
-        url: 'fake_turn_url',
-        username: 'fake_turn_username',
-        password: 'fake_turn_password',
+      assert.calledWith(fakeMeeting.roap.doTurnDiscovery, fakeMeeting, true, true);
+      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.calledOnce(fakeMediaConnection.initiateOffer);
+    });
+
+    // this can happen when we land on a video mesh node
+    it('does not use TURN server if TURN url is an empty string', async () => {
+      const rm = new ReconnectionManager(fakeMeeting);
+
+      fakeMeeting.roap.doTurnDiscovery.resolves({
+        turnServerInfo: {
+          url: '',
+          username: 'whatever',
+          password: 'whatever',
+        },
+        turnDiscoverySkippedReason: undefined,
+      });
+
+      await rm.reconnect();
+
+      assert.calledOnce(fakeMeeting.roap.doTurnDiscovery);
+      assert.calledWith(fakeMeeting.roap.doTurnDiscovery, fakeMeeting, true, true);
+      assert.calledOnce(fakeMediaConnection.reconnect);
+      assert.calledWith(fakeMediaConnection.reconnect, []);
+
+      assert.calledWith(fakeMeeting.webex.internal.newMetrics.submitClientEvent, {
+        name: 'client.media.reconnecting',
+        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,
+          },
+        });
+      }
     });
   });
 
@@ -81,11 +230,12 @@ describe('plugin-meetings', () => {
    * level causes testing errors in CI based around related files. Skipping this here until a solution
    * to this problem is generated.
    */
-  describe.skip('ReconnectionManager', () => {
+  describe('ReconnectionManager', () => {
     let reconnectionManager;
+    let fakeMeeting;
 
     beforeEach(() => {
-      reconnectionManager = new ReconnectionManager({
+      fakeMeeting = {
         config: {
           reconnection: {
             enabled: true,
@@ -95,12 +245,14 @@ describe('plugin-meetings', () => {
               times: 2,
               backOff: {
                 start: 1000,
-                rate: 2
-              }
-            }
-          }
-        }
-      });
+                rate: 2,
+              },
+            },
+          },
+        },
+      };
+
+      reconnectionManager = new ReconnectionManager(fakeMeeting);
     });
 
     describe('iceReconnected()', () => {
@@ -118,8 +270,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();
@@ -175,10 +326,11 @@ describe('plugin-meetings', () => {
           assert.isTrue(reconnectionManager.iceState.disconnected);
         });
 
-        it('should return a promise that rejects after a duration', () => {
+        it('should return a promise that rejects after a duration', (done) => {
           reconnectionManager.iceState.timeoutDuration = 100;
 
-          return assert.isRejected(reconnectionManager.waitForIceReconnect());
+          assert.isRejected(reconnectionManager.waitForIceReconnect());
+          done();
         });
 
         it('should resolve return a resolved promise when triggered', () => {
@@ -206,5 +358,41 @@ describe('plugin-meetings', () => {
         });
       });
     });
+
+    describe('setStatus()', () => {
+      beforeEach(() => {
+        reconnectionManager.status = RECONNECTION.STATE.DEFAULT_STATUS;
+      });
+
+      it('should correctly change status to in progress', () => {
+        reconnectionManager.setStatus(RECONNECTION.STATE.IN_PROGRESS);
+
+        assert.equal(reconnectionManager.status, RECONNECTION.STATE.IN_PROGRESS);
+      });
+
+      it('should correctly change status to complete', () => {
+        reconnectionManager.setStatus(RECONNECTION.STATE.COMPLETE);
+
+        assert.equal(reconnectionManager.status, RECONNECTION.STATE.COMPLETE);
+      });
+
+      it('should correctly change status to failure', () => {
+        reconnectionManager.setStatus(RECONNECTION.STATE.FAILURE);
+
+        assert.equal(reconnectionManager.status, RECONNECTION.STATE.FAILURE);
+      });
+    });
+
+    describe('cleanUp()', () => {
+      it('should call reset and keep reference to meeting object', () => {
+        const resetSpy = sinon.spy(reconnectionManager, 'reset');
+        assert.equal(reconnectionManager.meeting, fakeMeeting);
+
+        reconnectionManager.cleanUp();
+
+        assert.equal(reconnectionManager.meeting, fakeMeeting);
+        assert.calledOnce(reconnectionManager.reset);
+      });
+    });
   });
 });