@webex/plugin-meetings 3.0.0-stream-classes.4 → 3.0.0-test.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,6 +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 { RECONNECTION } from '../../../../src/constants';
+import LoggerProxy from '../../../../src/common/logs/logger-proxy';
+import LoggerConfig from '../../../../src/common/logs/logger-config';
 
 const {assert} = chai;
 
@@ -11,8 +14,16 @@ sinon.assert.expose(chai.assert, {prefix: ''});
 
 describe('plugin-meetings', () => {
   describe('ReconnectionManager.reconnect', () => {
+    const sandbox = sinon.createSandbox();
     let fakeMediaConnection;
     let fakeMeeting;
+    let loggerSpy;
+
+    before(() => {
+      LoggerConfig.set({ enable: false });
+      LoggerProxy.set();
+      loggerSpy = sandbox.spy(LoggerProxy.logger, 'info');
+    });
 
     beforeEach(() => {
       fakeMediaConnection = {
@@ -64,6 +75,7 @@ describe('plugin-meetings', () => {
           meetings: {
             getMeetingByType: sinon.stub().returns(true),
             syncMeetings: sinon.stub().resolves({}),
+            startReachability: sinon.stub().resolves({}),
           },
           internal: {
             newMetrics: {
@@ -74,22 +86,38 @@ describe('plugin-meetings', () => {
       };
     });
 
-    it('syncs meetings if it is not an unverified guest', async () => {
+    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('does not sync meetings if it is an unverified guest', async () => {
+    it('calls startReachability on reconnect', async () => {
       const rm = new ReconnectionManager(fakeMeeting);
 
-      rm.webex.credentials.isUnverifiedGuest = true;
+      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.notCalled(rm.webex.meetings.syncMeetings);
+      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 () => {
@@ -98,6 +126,7 @@ describe('plugin-meetings', () => {
       await rm.reconnect();
 
       assert.calledOnce(fakeMeeting.roap.doTurnDiscovery);
+      assert.calledWith(fakeMeeting.roap.doTurnDiscovery, fakeMeeting, true, true);
       assert.calledOnce(fakeMediaConnection.reconnect);
       assert.calledWith(fakeMediaConnection.reconnect, [
         {
@@ -113,16 +142,6 @@ describe('plugin-meetings', () => {
           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 () => {
@@ -149,7 +168,6 @@ describe('plugin-meetings', () => {
       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;
@@ -186,9 +204,10 @@ describe('plugin-meetings', () => {
    */
   describe('ReconnectionManager', () => {
     let reconnectionManager;
+    let fakeMeeting;
 
     beforeEach(() => {
-      reconnectionManager = new ReconnectionManager({
+      fakeMeeting = {
         config: {
           reconnection: {
             enabled: true,
@@ -203,7 +222,9 @@ describe('plugin-meetings', () => {
             },
           },
         },
-      });
+      };
+
+      reconnectionManager = new ReconnectionManager(fakeMeeting);
     });
 
     describe('iceReconnected()', () => {
@@ -309,5 +330,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);
+      });
+    });
   });
 });

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

@@ -7,38 +7,35 @@ import RoapRequest from '@webex/plugin-meetings/src/roap/request';
 import Roap from '@webex/plugin-meetings/src/roap/';
 import Meeting from '@webex/plugin-meetings/src/meeting';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
+import Metrics from '@webex/plugin-meetings/src/metrics';
+import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
 
 import { IP_VERSION } from '../../../../src/constants';
 
 describe('Roap', () => {
   describe('doTurnDiscovery', () => {
-    it('calls this.turnDiscovery.doTurnDiscovery() and forwards all the arguments', async () => {
-      const webex = new MockWebex({});
+    [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 RESULT = {something: 'some value'};
+          const meeting = {id: 'some meeting id'} as Meeting;
 
-      const doTurnDiscoveryStub = sinon
-        .stub(TurnDiscovery.prototype, 'doTurnDiscovery')
-        .resolves(RESULT);
+          const doTurnDiscoveryStub = sinon
+            .stub(TurnDiscovery.prototype, 'doTurnDiscovery')
+            .resolves(RESULT);
 
-      const roap = new Roap({}, {parent: webex});
+          const roap = new Roap({}, {parent: webex});
 
-      // call with isReconnecting: true
-      const result = await roap.doTurnDiscovery(meeting, true);
+          const result = await roap.doTurnDiscovery(meeting, isReconnecting, isForced);
 
-      assert.calledOnceWithExactly(doTurnDiscoveryStub, meeting, true);
-      assert.deepEqual(result, RESULT);
+          assert.calledOnceWithExactly(doTurnDiscoveryStub, meeting, isReconnecting, isForced);
+          assert.deepEqual(result, RESULT);
 
-      doTurnDiscoveryStub.resetHistory();
-
-      // and with isReconnecting: false
-      const result2 = await roap.doTurnDiscovery(meeting, false);
-
-      assert.calledOnceWithExactly(doTurnDiscoveryStub, meeting, false);
-      assert.deepEqual(result2, RESULT);
-
-      sinon.restore();
+          sinon.restore();
+        });
+      });
     });
   });
 
@@ -47,6 +44,9 @@ describe('Roap', () => {
     let meeting;
 
     let webex;
+    let roap;
+
+    const fakeLocus = {id: 'fake locus'};
 
     beforeEach(() => {
       webex = new MockWebex({});
@@ -55,68 +55,188 @@ describe('Roap', () => {
         correlationId: 'correlation id',
         selfUrl: 'self url',
         mediaId: 'media id',
-        audio:{
+        audio: {
           isLocallyMuted: () => true,
         },
-        video:{
+        video: {
           isLocallyMuted: () => false,
         },
+        isMultistream: true,
         setRoapSeq: sinon.stub(),
-        config: {experimental: {enableTurnDiscovery: false}},
         locusMediaRequest: {fake: true},
-        webex: { meetings: { reachability: { isAnyClusterReachable: () => true}}},
+        webex: {meetings: {reachability: {isAnyPublicClusterReachable: () => true}}},
+        updateMediaConnections: sinon.stub(),
       };
 
       sinon.stub(MeetingUtil, 'getIpVersion').returns(IP_VERSION.unknown);
+      sinon.stub(Metrics, 'sendBehavioralMetric');
 
       sendRoapStub = sinon.stub(RoapRequest.prototype, 'sendRoap').resolves({});
       meeting.setRoapSeq.resetHistory();
+
+      roap = new Roap({}, {parent: webex});
+      sinon.stub(roap.turnDiscovery, 'isSkipped').resolves(false);
     });
 
     afterEach(() => {
       sinon.restore();
     });
 
-    [
-      {reconnect: true, turnDiscoverySkipped: false, expectEmptyMediaId: false},
-      {reconnect: true, turnDiscoverySkipped: true, expectEmptyMediaId: true},
-      {reconnect: false, turnDiscoverySkipped: false, expectEmptyMediaId: false},
-      {reconnect: false, turnDiscoverySkipped: true, expectEmptyMediaId: false},
-    ].forEach(({reconnect, turnDiscoverySkipped, expectEmptyMediaId}) =>
-      it(`sends roap OFFER with ${expectEmptyMediaId ? 'empty ' : ''}mediaId when ${
-        reconnect ? '' : 'not '
-      }reconnecting and TURN discovery is ${
-        turnDiscoverySkipped ? 'skipped' : 'not skipped'
-      }`, async () => {
-        const roap = new Roap({}, {parent: webex});
-
-        sinon.stub(roap.turnDiscovery, 'isSkipped').resolves(turnDiscoverySkipped);
-
-        await roap.sendRoapMediaRequest({
-          meeting,
-          sdp: 'sdp',
-          reconnect,
-          seq: 2,
-          tieBreaker: 4294967294,
-        });
-
-        const expectedRoapMessage = {
-          messageType: 'OFFER',
-          sdps: ['sdp'],
-          version: '2',
-          seq: 2,
-          tieBreaker: 4294967294,
-        };
+    it(`sends roap OFFER`, async () => {
+      await roap.sendRoapMediaRequest({
+        meeting,
+        sdp: 'sdp',
+        seq: 2,
+        tieBreaker: 4294967294,
+      });
+
+      const expectedRoapMessage = {
+        messageType: 'OFFER',
+        sdps: ['sdp'],
+        version: '2',
+        seq: 2,
+        tieBreaker: 4294967294,
+        headers: ['includeAnswerInHttpResponse', 'noOkInTransaction'],
+      };
 
-        assert.calledOnce(sendRoapStub);
-        assert.calledWith(sendRoapStub, sinon.match({
+      assert.calledOnce(sendRoapStub);
+      assert.calledWith(
+        sendRoapStub,
+        sinon.match({
           roapMessage: expectedRoapMessage,
           locusSelfUrl: meeting.selfUrl,
-          mediaId: expectEmptyMediaId ? '' : meeting.mediaId,
+          mediaId: meeting.mediaId,
           meetingId: meeting.id,
           locusMediaRequest: meeting.locusMediaRequest,
-        }));
-      })
-    );
+        })
+      );
+    });
+
+    it('reads SDP answer from the http response', async () => {
+      const roapAnswer = {
+        seq: 5,
+        messageType: 'ANSWER',
+        sdps: ['sdp answer'],
+        errorType: 'error type', // normally ANSWER would not have errorType or errorCause (only error messages have these)
+        errorCause: 'error cause', // but we're just testing here that all the fields are forwarded to the caller of sendRoapMediaRequest()
+        headers: ['header1', 'header2'],
+      };
+      const fakeMediaConnections = [
+        {
+          remoteSdp: JSON.stringify({
+            roapMessage: roapAnswer,
+          }),
+        },
+      ];
+
+      sendRoapStub.resolves({
+        mediaConnections: fakeMediaConnections,
+        locus: fakeLocus,
+      });
+
+      const result = await roap.sendRoapMediaRequest({
+        meeting,
+        sdp: 'sdp',
+        reconnect: false,
+        seq: 1,
+        tieBreaker: 4294967294,
+      });
+
+      assert.calledOnce(sendRoapStub);
+      assert.calledOnceWithExactly(meeting.updateMediaConnections, fakeMediaConnections);
+      assert.deepEqual(result, {
+        locus: fakeLocus,
+        roapAnswer: {
+          seq: 5,
+          messageType: 'ANSWER',
+          sdp: 'sdp answer',
+          errorType: 'error type',
+          errorCause: 'error cause',
+          headers: ['header1', 'header2'],
+        },
+      });
+    });
+
+    it('handles the case when there is no answer in the http response', async () => {
+      const fakeMediaConnections = [
+        {
+          // this is the actual value Locus returns to us when they don't send Roap ANSWER in the http response
+          remoteSdp:
+            '{"audioMuted":false,"videoMuted":false,"csis":[],"dtmfReceiveSupported":true,"type":"SDP"}',
+        },
+      ];
+
+      sendRoapStub.resolves({
+        mediaConnections: fakeMediaConnections,
+        locus: fakeLocus,
+      });
+
+      const result = await roap.sendRoapMediaRequest({
+        meeting,
+        sdp: 'sdp',
+        reconnect: false,
+        seq: 1,
+        tieBreaker: 4294967294,
+      });
+
+      assert.calledOnce(sendRoapStub);
+      assert.calledOnceWithExactly(meeting.updateMediaConnections, fakeMediaConnections);
+      assert.deepEqual(result, {
+        locus: fakeLocus,
+        roapAnswer: undefined,
+      });
+      assert.calledOnceWithExactly(
+        Metrics.sendBehavioralMetric,
+        BEHAVIORAL_METRICS.ROAP_HTTP_RESPONSE_MISSING,
+        {
+          correlationId: meeting.correlationId,
+          messageType: 'ANSWER',
+          isMultistream: meeting.isMultistream,
+        }
+      );
+    });
+
+    describe('does not crash when http response is missing things', () => {
+      [
+        {mediaConnections: undefined, title: 'mediaConnections are undefined'},
+        {mediaConnections: [], title: 'mediaConnections are empty array'},
+        {mediaConnections: [{}], title: 'mediaConnections[0] has no remoteSdp'},
+        {
+          mediaConnections: [{remoteSdp: '{}'}],
+          title: 'mediaConnections[0].remoteSdp is an empty json',
+        },
+      ].forEach(({mediaConnections, title}) =>
+        it(title, async () => {
+          sendRoapStub.resolves({
+            mediaConnections,
+            locus: fakeLocus,
+          });
+
+          const result = await roap.sendRoapMediaRequest({
+            meeting,
+            sdp: 'sdp',
+            reconnect: false,
+            seq: 1,
+            tieBreaker: 4294967294,
+          });
+
+          assert.calledOnce(sendRoapStub);
+          assert.deepEqual(result, {
+            locus: fakeLocus,
+            roapAnswer: undefined,
+          });
+
+          assert.calledOnceWithExactly(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.ROAP_HTTP_RESPONSE_MISSING,
+            {
+              correlationId: meeting.correlationId,
+              messageType: 'ANSWER',
+              isMultistream: meeting.isMultistream,
+            }
+          );
+        })
+      );
+    });
   });
 });

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

@@ -65,7 +65,9 @@ describe('plugin-meetings/roap', () => {
       REACHABILITY.localStorageResult,
       JSON.stringify({
         clusterId: {
-          udp: 'test',
+          udp: { result: 'reachable', latencyInMilliseconds: 10 },
+          tcp: { result: 'unreachable' },
+          isVideoMesh: false,
         },
       })
     );
@@ -78,7 +80,16 @@ describe('plugin-meetings/roap', () => {
       assert.deepEqual(res.localSdp, {
         reachability: {
           clusterId: {
-            udp: 'test',
+            udp: {
+              reachable: 'true',
+              latencyInMilliseconds: '10',
+            },
+            tcp: {
+              reachable: 'false',
+            },
+            xtls: {
+              untested: 'true',
+            }
           },
         },
       });
@@ -148,7 +159,20 @@ describe('plugin-meetings/roap', () => {
         roapMessage: {
           seq: 'seq',
         },
-        reachability: {clusterId: {udp: 'test'}},
+        reachability: {
+          clusterId: {
+            tcp: {
+              reachable: 'false',
+            },
+            udp: {
+              latencyInMilliseconds: '10',
+              reachable: 'true',
+            },
+            xtls: {
+              untested: 'true',
+            },
+          },
+        },
       });
     });