@webex/plugin-meetings 3.0.0 → 3.1.0-next.10

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

@@ -1,6 +1,9 @@
 import {assert} from '@webex/test-helper-chai';
 
-import {convertStunUrlToTurn} from '@webex/plugin-meetings/src/reachability/util';
+import {
+  convertStunUrlToTurn,
+  convertStunUrlToTurnTls,
+} from '@webex/plugin-meetings/src/reachability/util';
 
 describe('plugin-meetings/src/reachability/util', () => {
   describe('#convertStunUrlToTurn()', () => {
@@ -34,7 +37,34 @@ describe('plugin-meetings/src/reachability/util', () => {
     });
 
     it('show fail if stunUrl is not a STUN url', () => {
-      assert.throws(() => convertStunUrlToTurn('http://webex.com', 'tcp'), 'Not a STUN URL: http://webex.com');
+      assert.throws(
+        () => convertStunUrlToTurn('http://webex.com', 'tcp'),
+        'Not a STUN URL: http://webex.com'
+      );
+    });
+  });
+
+  describe('#convertStunUrlToTurnTls()', () => {
+    it(`should convert to a turns url`, () => {
+      const turnsUrl = convertStunUrlToTurnTls(
+        'stun:external-media91.public.wjfkm-a-10.prod.infra.webex.com:443'
+      );
+
+      assert.equal(
+        turnsUrl,
+        'turns:external-media91.public.wjfkm-a-10.prod.infra.webex.com:443?transport=tcp'
+      );
+    });
+
+    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

@@ -2,11 +2,14 @@ import 'jsdom-global/register';
 import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 import sinon from 'sinon';
+import {Defer} from '@webex/common';
 import ReconnectionManager from '@webex/plugin-meetings/src/reconnection-manager';
+import ReconnectionNotStartedError from '@webex/plugin-meetings/src/common/errors/reconnection-not-started';
+import TriggerProxy from '@webex/plugin-meetings/src/common/events/trigger-proxy';
+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;
 
 chai.use(chaiAsPromised);
@@ -14,18 +17,15 @@ sinon.assert.expose(chai.assert, {prefix: ''});
 
 describe('plugin-meetings', () => {
   describe('ReconnectionManager.reconnect', () => {
-    const sandbox = sinon.createSandbox();
     let fakeMediaConnection;
     let fakeMeeting;
     let loggerSpy;
 
-    before(() => {
+    beforeEach(() => {
       LoggerConfig.set({ enable: false });
       LoggerProxy.set();
-      loggerSpy = sandbox.spy(LoggerProxy.logger, 'info');
-    });
+      loggerSpy = sinon.spy(LoggerProxy.logger, 'info');
 
-    beforeEach(() => {
       fakeMediaConnection = {
         initiateOffer: sinon.stub().resolves({}),
         reconnect: sinon.stub().resolves({}),
@@ -33,6 +33,7 @@ describe('plugin-meetings', () => {
       fakeMeeting = {
         closePeerConnections: sinon.stub().resolves({}),
         createMediaConnection: sinon.stub().returns(fakeMediaConnection),
+        correlationId: 'correlationId',
         config: {
           reconnection: {
             enabled: true,
@@ -47,6 +48,7 @@ describe('plugin-meetings', () => {
             },
           },
         },
+        locusUrl: 'test/id',
         mediaProperties: {
           unsetPeerConnection: sinon.stub(),
           webrtcMediaConnection: fakeMediaConnection,
@@ -83,11 +85,16 @@ describe('plugin-meetings', () => {
             }
           }
         },
+        trigger: sinon.stub(),
       };
+
+      sinon.stub(TriggerProxy, 'trigger').returns(true);
+      sinon.stub(Metrics, 'sendBehavioralMetric');
     });
 
     afterEach(() => {
-      sandbox.reset();
+      sinon.reset();
+      sinon.restore();
     });
 
     it('calls syncMeetings', async () => {
@@ -144,6 +151,34 @@ describe('plugin-meetings', () => {
       });
     });
 
+    // 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);
@@ -195,6 +230,99 @@ describe('plugin-meetings', () => {
         });
       }
     });
+
+    it('sends the right metrics and events when succeeds', async () => {
+      const rm = new ReconnectionManager(fakeMeeting);
+
+      await rm.reconnect();
+
+      assert.calledWith(
+        TriggerProxy.trigger,
+        fakeMeeting,
+        {file: 'reconnection-manager/index', function: 'reconnect'},
+        'meeting:reconnectionSuccess'
+      );
+      assert.calledWithMatch(fakeMeeting.webex.internal.newMetrics.submitClientEvent, {
+        name: 'client.media.recovered',
+        payload: {
+          recoveredBy: 'new',
+        },
+        options: {
+          meetingId: fakeMeeting.id,
+        },
+      });
+      assert.equal(rm.status, RECONNECTION.STATE.DEFAULT_STATUS);
+    });
+
+    it('sends the right metrics and events when fails', async () => {
+      const rm = new ReconnectionManager(fakeMeeting);
+
+      sinon.stub(rm, 'executeReconnection').rejects(new Error('fake error'));
+
+      await assert.isRejected(rm.reconnect());
+
+      assert.calledWith(
+        TriggerProxy.trigger,
+        fakeMeeting,
+        {file: 'reconnection-manager/index', function: 'reconnect'},
+        'meeting:reconnectionFailure'
+      );
+      assert.calledWithMatch(fakeMeeting.webex.internal.newMetrics.submitClientEvent, {
+        name: 'client.call.aborted',
+        payload: {
+          errors: [
+            {
+              category: 'expected',
+              errorCode: 2008,
+              fatal: true,
+              name: 'media-engine',
+              shownToUser: false,
+            },
+          ],
+        },
+        options: {
+          meetingId: fakeMeeting.id,
+        },
+      });
+      assert.calledWith(Metrics.sendBehavioralMetric, 'js_sdk_meeting_reconnect_failures', {
+        correlation_id: fakeMeeting.correlationId,
+        locus_id: 'id',
+        reason: 'fake error',
+        stack: sinon.match.any,
+      });
+      assert.equal(rm.status, RECONNECTION.STATE.DEFAULT_STATUS);
+    });
+
+    it('throws ReconnectionNotStartedError if reconnection is already in progress', async () => {
+      const rm = new ReconnectionManager(fakeMeeting);
+      const defer = new Defer();
+
+      sinon.stub(rm, 'executeReconnection').returns(defer.promise);
+
+      rm.reconnect();
+
+      try {
+        await rm.reconnect();
+
+        fail("rm.reconnect() should have thrown, but it hasn't");
+      } catch (e) {
+        assert.instanceOf(e, ReconnectionNotStartedError);
+      }
+    });
+
+    it('throws ReconnectionNotStartedError if reconnection is disabled in config', async () => {
+      fakeMeeting.config.reconnection.enabled = false;
+
+      const rm = new ReconnectionManager(fakeMeeting);
+
+      try {
+        await rm.reconnect();
+
+        fail("rm.reconnect() should have thrown, but it hasn't");
+      } catch (e) {
+        assert.instanceOf(e, ReconnectionNotStartedError);
+      }
+    });
   });
 
   /**
@@ -288,29 +416,41 @@ describe('plugin-meetings', () => {
 
     describe('waitForIceReconnect()', () => {
       describe('when ice is marked as not disconnected', () => {
+        let clock;
+
         beforeEach(() => {
+          clock = sinon.useFakeTimers();
           reconnectionManager.iceState.disconnected = false;
         });
 
+        afterEach(() => {
+          clock.restore();
+        });
+
         it('should set the disconnected state to true', () => {
-          reconnectionManager.waitForIceReconnect();
+          const promise = reconnectionManager.waitForIceReconnect();
 
           assert.isTrue(reconnectionManager.iceState.disconnected);
+
+          // we let the timer expire
+          clock.tick(reconnectionManager.iceState.timeoutDuration);
+          assert.isRejected(promise);
         });
 
-        it('should return a promise that rejects after a duration', (done) => {
-          reconnectionManager.iceState.timeoutDuration = 100;
+        it('should return a promise that rejects after a duration', async () => {
+          const promise = reconnectionManager.waitForIceReconnect();
 
-          assert.isRejected(reconnectionManager.waitForIceReconnect());
-          done();
+          // we let the timer expire
+          clock.tick(reconnectionManager.iceState.timeoutDuration);
+          assert.isRejected(promise);
         });
 
-        it('should resolve return a resolved promise when triggered', () => {
+        it('should resolve when ICE is reconnected', async () => {
           const promise = reconnectionManager.waitForIceReconnect();
 
-          reconnectionManager.iceState.resolve();
+          reconnectionManager.iceReconnected();
 
-          assert.isFulfilled(promise);
+          await promise;
         });
       });
 
@@ -331,30 +471,6 @@ 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');

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

@@ -13,15 +13,23 @@ import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
 import { IP_VERSION } from '../../../../src/constants';
 
 describe('Roap', () => {
+  let webex;
+
+  const RESULT = {something: 'some value'};
+  const meeting = {id: 'some meeting id'} as Meeting;
+
+  beforeEach(() => {
+    webex = new MockWebex({});
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
   describe('doTurnDiscovery', () => {
     [false, true].forEach(function (isReconnecting) {
       [false, true, undefined].forEach(function (isForced) {
         it(`calls this.turnDiscovery.doTurnDiscovery() and forwards all the arguments when isReconnecting = ${isReconnecting} and isForced = ${isForced}`, async () => {
-          const webex = new MockWebex({});
-
-          const RESULT = {something: 'some value'};
-          const meeting = {id: 'some meeting id'} as Meeting;
-
           const doTurnDiscoveryStub = sinon
             .stub(TurnDiscovery.prototype, 'doTurnDiscovery')
             .resolves(RESULT);
@@ -32,11 +40,58 @@ describe('Roap', () => {
 
           assert.calledOnceWithExactly(doTurnDiscoveryStub, meeting, isReconnecting, isForced);
           assert.deepEqual(result, RESULT);
+        });
+      });
+    });
+
+    describe('generateTurnDiscoveryRequestMessage', () => {
+      [false, true].forEach(function (isForced) {
+        it(`calls this.turnDiscovery.generateTurnDiscoveryRequestMessage with isForced=${isForced}`, async () => {
+          const generateTurnDiscoveryRequestMessageStub = sinon
+            .stub(TurnDiscovery.prototype, 'generateTurnDiscoveryRequestMessage')
+            .resolves(RESULT);
+
+          const roap = new Roap({}, {parent: webex});
 
-          sinon.restore();
+          const result = await roap.generateTurnDiscoveryRequestMessage(meeting, isForced);
+
+          assert.calledOnceWithExactly(generateTurnDiscoveryRequestMessageStub, meeting, isForced);
+          assert.deepEqual(result, RESULT);
         });
       });
     });
+
+    describe('handleTurnDiscoveryHttpResponse', () => {
+      it('calls this.turnDiscovery.handleTurnDiscoveryHttpResponse', async () => {
+        const handleTurnDiscoveryHttpResponseStub = sinon
+          .stub(TurnDiscovery.prototype, 'handleTurnDiscoveryHttpResponse')
+          .resolves(RESULT);
+
+        const httpReponse = {some: 'http response'};
+
+        const roap = new Roap({}, {parent: webex});
+
+        const result = await roap.handleTurnDiscoveryHttpResponse(meeting, httpReponse);
+
+        assert.calledOnceWithExactly(handleTurnDiscoveryHttpResponseStub, meeting, httpReponse);
+        assert.deepEqual(result, RESULT);
+      });
+    });
+
+    describe('abortTurnDiscovery', () => {
+      it('calls this.turnDiscovery.abort', async () => {
+        const abortStub = sinon
+          .stub(TurnDiscovery.prototype, 'abort')
+          .returns(RESULT);
+
+        const roap = new Roap({}, {parent: webex});
+
+        const result = await roap.abortTurnDiscovery();
+
+        assert.calledOnceWithExactly(abortStub);
+        assert.deepEqual(result, RESULT);
+      });
+    });
   });
 
   describe('sendRoapMediaRequest', () => {