@webex/plugin-meetings 3.0.0-test.1 → 3.1.0

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

@@ -1,11 +1,14 @@
 import {assert} from '@webex/test-helper-chai';
 import MockWebex from '@webex/test-helper-mock-webex';
 import sinon from 'sinon';
-import Reachability, {ReachabilityResults, ReachabilityResultsForBackend} from '@webex/plugin-meetings/src/reachability/';
+import Reachability, {
+  ReachabilityResults,
+  ReachabilityResultsForBackend,
+} from '@webex/plugin-meetings/src/reachability/';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 import * as ClusterReachabilityModule from '@webex/plugin-meetings/src/reachability/clusterReachability';
 
-import { IP_VERSION } from '@webex/plugin-meetings/src/constants';
+import {IP_VERSION} from '@webex/plugin-meetings/src/constants';
 
 describe('isAnyPublicClusterReachable', () => {
   let webex;
@@ -36,19 +39,31 @@ describe('isAnyPublicClusterReachable', () => {
   };
 
   it('returns true when udp is reachable', async () => {
-    await checkIsClusterReachable({x: {udp: {result: 'reachable'}, tcp: {result: 'unreachable'}}}, true);
+    await checkIsClusterReachable(
+      {x: {udp: {result: 'reachable'}, tcp: {result: 'unreachable'}}},
+      true
+    );
   });
 
   it('returns true when tcp is reachable', async () => {
-    await checkIsClusterReachable({x: {udp: {result: 'unreachable'}, tcp: {result: 'reachable'}}}, true);
+    await checkIsClusterReachable(
+      {x: {udp: {result: 'unreachable'}, tcp: {result: 'reachable'}}},
+      true
+    );
   });
 
   it('returns true when both tcp and udp are reachable', async () => {
-    await checkIsClusterReachable({x: {udp: {result: 'reachable'}, tcp: {result: 'reachable'}}}, true);
+    await checkIsClusterReachable(
+      {x: {udp: {result: 'reachable'}, tcp: {result: 'reachable'}}},
+      true
+    );
   });
 
   it('returns false when both tcp and udp are unreachable', async () => {
-    await checkIsClusterReachable({x: {udp: {result: 'unreachable'}, tcp: {result: 'unreachable'}}}, false);
+    await checkIsClusterReachable(
+      {x: {udp: {result: 'unreachable'}, tcp: {result: 'unreachable'}}},
+      false
+    );
   });
 
   it('returns false when reachability result is empty', async () => {
@@ -61,60 +76,69 @@ describe('isAnyPublicClusterReachable', () => {
 
   describe('ignores video mesh reachability', () => {
     it('returns false if there are no public cluster results, only video mesh', async () => {
-      await checkIsClusterReachable({
-        x: {
-          udp: {result: 'reachable'},
-          tcp: {result: 'reachable'},
-          isVideoMesh: true,
-        },
-        y: {
-          udp: {result: 'unreachable'},
-          tcp: {result: 'reachable'},
-          isVideoMesh: true,
-        }
-      }, false);
+      await checkIsClusterReachable(
+        {
+          x: {
+            udp: {result: 'reachable'},
+            tcp: {result: 'reachable'},
+            isVideoMesh: true,
+          },
+          y: {
+            udp: {result: 'unreachable'},
+            tcp: {result: 'reachable'},
+            isVideoMesh: true,
+          },
+        },
+        false
+      );
     });
 
     it('returns false if there public cluster reachability failed, only video mesh succeeded', async () => {
-      await checkIsClusterReachable({
-        x: {
-          udp: {result: 'unreachable'},
-          tcp: {result: 'reachable'},
-          isVideoMesh: true,
-        },
-        y: {
-          udp: {result: 'reachable'},
-          tcp: {result: 'unreachable'},
-          isVideoMesh: true,
-        },
-        publicOne: {
-          udp: {result: 'unreachable'},
-          tcp: {result: 'unreachable'},
-          isVideoMesh: false,
-        }
-      }, false);
+      await checkIsClusterReachable(
+        {
+          x: {
+            udp: {result: 'unreachable'},
+            tcp: {result: 'reachable'},
+            isVideoMesh: true,
+          },
+          y: {
+            udp: {result: 'reachable'},
+            tcp: {result: 'unreachable'},
+            isVideoMesh: true,
+          },
+          publicOne: {
+            udp: {result: 'unreachable'},
+            tcp: {result: 'unreachable'},
+            isVideoMesh: false,
+          },
+        },
+        false
+      );
     });
 
     it('returns true if there is at least 1 public cluster result, while video mesh is not reachable', async () => {
-      await checkIsClusterReachable({
-        x: {
-          udp: {result: 'reachable'},
-          tcp: {result: 'reachable'},
-          isVideoMesh: true,
-        },
-        y: {
-          udp: {result: 'unreachable'},
-          tcp: {result: 'reachable'},
-          isVideoMesh: true,
-        },
-        publicOne: {
-          udp: {result: 'unreachable'},
-          tcp: {result: 'reachable'},
-          isVideoMesh: false,
-        }
-      }, true);
+      await checkIsClusterReachable(
+        {
+          x: {
+            udp: {result: 'reachable'},
+            tcp: {result: 'reachable'},
+            isVideoMesh: true,
+          },
+          y: {
+            udp: {result: 'unreachable'},
+            tcp: {result: 'reachable'},
+            isVideoMesh: true,
+          },
+          publicOne: {
+            udp: {result: 'unreachable'},
+            tcp: {result: 'reachable'},
+            isVideoMesh: false,
+          },
+        },
+        true
+      );
     });
-  })
+  });
 });
 
 describe('gatherReachability', () => {
@@ -244,7 +268,10 @@ describe('gatherReachability', () => {
   });
 
   it('starts ClusterReachability on each media cluster', async () => {
-    webex.config.meetings.experimental = {enableTcpReachability: true};
+    webex.config.meetings.experimental = {
+      enableTcpReachability: true,
+      enableTlsReachability: true,
+    };
 
     const getClustersResult = {
       clusters: {
@@ -284,11 +311,11 @@ describe('gatherReachability', () => {
       xtls: ['xtls1.1', 'xtls1.2'],
       isVideoMesh: false,
     });
-    // cluster 2 is video mesh, so we should not do TCP reachability on it
+    // cluster 2 is video mesh, so we should not do TCP or TLS reachability on it
     assert.calledWith(clusterReachabilityCtorStub, 'cluster 2', {
       udp: ['udp2.1', 'udp2.2'],
       tcp: [],
-      xtls: ['xtls2.1', 'xtls2.2'],
+      xtls: [],
       isVideoMesh: true,
     });
 
@@ -296,7 +323,10 @@ describe('gatherReachability', () => {
   });
 
   it('does not do TCP reachability if it is disabled in config', async () => {
-    webex.config.meetings.experimental = {enableTcpReachability: false};
+    webex.config.meetings.experimental = {
+      enableTcpReachability: false,
+      enableTlsReachability: true,
+    };
 
     const getClustersResult = {
       clusters: {
@@ -329,6 +359,82 @@ describe('gatherReachability', () => {
       xtls: ['testXTLS1', 'testXTLS2'],
     });
   });
+
+  it('does not do TLS reachability if it is disabled in config', async () => {
+    webex.config.meetings.experimental = {
+      enableTcpReachability: true,
+      enableTlsReachability: false,
+    };
+
+    const getClustersResult = {
+      clusters: {
+        'cluster name': {
+          udp: ['testUDP1', 'testUDP2'],
+          tcp: ['testTCP1', 'testTCP2'],
+          xtls: ['testXTLS1', 'testXTLS2'],
+          isVideoMesh: false,
+        },
+      },
+      joinCookie: {id: 'id'},
+    };
+
+    const reachability = new Reachability(webex);
+
+    reachability.reachabilityRequest.getClusters = sinon.stub().returns(getClustersResult);
+
+    const clusterReachabilityCtorStub = sinon
+      .stub(ClusterReachabilityModule, 'ClusterReachability')
+      .callsFake(() => ({
+        start: sinon.stub().resolves({}),
+      }));
+
+    await reachability.gatherReachability();
+
+    assert.calledOnceWithExactly(clusterReachabilityCtorStub, 'cluster name', {
+      isVideoMesh: false,
+      udp: ['testUDP1', 'testUDP2'],
+      tcp: ['testTCP1', 'testTCP2'],
+      xtls: [], // empty list because TLS is disabled in config
+    });
+  });
+
+  it('does not do TCP or TLS reachability if it is disabled in config', async () => {
+    webex.config.meetings.experimental = {
+      enableTcpReachability: false,
+      enableTlsReachability: false,
+    };
+
+    const getClustersResult = {
+      clusters: {
+        'cluster name': {
+          udp: ['testUDP1', 'testUDP2'],
+          tcp: ['testTCP1', 'testTCP2'],
+          xtls: ['testXTLS1', 'testXTLS2'],
+          isVideoMesh: false,
+        },
+      },
+      joinCookie: {id: 'id'},
+    };
+
+    const reachability = new Reachability(webex);
+
+    reachability.reachabilityRequest.getClusters = sinon.stub().returns(getClustersResult);
+
+    const clusterReachabilityCtorStub = sinon
+      .stub(ClusterReachabilityModule, 'ClusterReachability')
+      .callsFake(() => ({
+        start: sinon.stub().resolves({}),
+      }));
+
+    await reachability.gatherReachability();
+
+    assert.calledOnceWithExactly(clusterReachabilityCtorStub, 'cluster name', {
+      isVideoMesh: false,
+      udp: ['testUDP1', 'testUDP2'],
+      tcp: [], // empty list because TCP is disabled in config
+      xtls: [], // empty list because TLS is disabled in config
+    });
+  });
 });
 
 describe('getReachabilityResults', () => {
@@ -460,10 +566,14 @@ describe('getReachabilityMetrics', () => {
       reachability_public_udp_failed: 0,
       reachability_public_tcp_success: 0,
       reachability_public_tcp_failed: 0,
+      reachability_public_xtls_success: 0,
+      reachability_public_xtls_failed: 0,
       reachability_vmn_udp_success: 0,
       reachability_vmn_udp_failed: 0,
       reachability_vmn_tcp_success: 0,
       reachability_vmn_tcp_failed: 0,
+      reachability_vmn_xtls_success: 0,
+      reachability_vmn_xtls_failed: 0,
     });
   });
 
@@ -523,10 +633,14 @@ describe('getReachabilityMetrics', () => {
         reachability_public_udp_failed: 2,
         reachability_public_tcp_success: 2,
         reachability_public_tcp_failed: 1,
+        reachability_public_xtls_success: 0,
+        reachability_public_xtls_failed: 0,
         reachability_vmn_udp_success: 1,
         reachability_vmn_udp_failed: 0,
         reachability_vmn_tcp_success: 1,
         reachability_vmn_tcp_failed: 1,
+        reachability_vmn_xtls_success: 0,
+        reachability_vmn_xtls_failed: 0,
       }
     );
   });
@@ -562,7 +676,16 @@ describe('getReachabilityMetrics', () => {
         public5: {
           udp: {result: 'reachable', latencyInMilliseconds: '400', clientMediaIPs: ['10.10.10.10']},
           tcp: {result: 'untested'},
-          xtls: {result: 'untested'},
+          xtls: {result: 'unreachable'},
+        },
+        public6: {
+          udp: {result: 'untested'},
+          tcp: {result: 'untested'},
+          xtls: {
+            result: 'reachable',
+            latencyInMilliseconds: '200',
+            clientMediaIPs: ['10.10.10.10'],
+          },
         },
       },
       // expected result:
@@ -571,10 +694,14 @@ describe('getReachabilityMetrics', () => {
         reachability_public_udp_failed: 1,
         reachability_public_tcp_success: 1,
         reachability_public_tcp_failed: 2,
+        reachability_public_xtls_success: 1,
+        reachability_public_xtls_failed: 1,
         reachability_vmn_udp_success: 0,
         reachability_vmn_udp_failed: 0,
         reachability_vmn_tcp_success: 0,
         reachability_vmn_tcp_failed: 0,
+        reachability_vmn_xtls_success: 0,
+        reachability_vmn_xtls_failed: 0,
       }
     );
   });
@@ -611,10 +738,16 @@ describe('getReachabilityMetrics', () => {
         vmn5: {
           udp: {result: 'reachable', latencyInMilliseconds: 200, clientMediaIPs: ['10.10.10.10']},
           tcp: {result: 'unreachable'},
-          xtls: {result: 'untested'},
+          xtls: {result: 'unreachable'},
           isVideoMesh: true,
           someOtherField: 'any value',
         },
+        vmn6: {
+          udp: {result: 'untested'},
+          tcp: {result: 'untested'},
+          xtls: {result: 'reachable', latencyInMilliseconds: 100, clientMediaIPs: ['10.10.10.10']},
+          isVideoMesh: true,
+        },
       },
       // expected result:
       {
@@ -622,11 +755,15 @@ describe('getReachabilityMetrics', () => {
         reachability_public_udp_failed: 0,
         reachability_public_tcp_success: 0,
         reachability_public_tcp_failed: 0,
+        reachability_public_xtls_success: 0,
+        reachability_public_xtls_failed: 0,
         reachability_vmn_udp_success: 3,
         reachability_vmn_udp_failed: 1,
         reachability_vmn_tcp_success: 1,
         reachability_vmn_tcp_failed: 3,
+        reachability_vmn_xtls_success: 1,
+        reachability_vmn_xtls_failed: 1,
       }
     );
   });
-});
+});

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

@@ -4,6 +4,7 @@ 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';
+import {NewMetrics} from '@webex/internal-plugin-metrics';
 
 
 describe('plugin-meetings/reachability', () => {
@@ -14,6 +15,7 @@ describe('plugin-meetings/reachability', () => {
     webex = new MockWebex({
       children: {
         meetings: Meetings,
+        newMetrics: NewMetrics
       },
     });
 
@@ -22,19 +24,25 @@ describe('plugin-meetings/reachability', () => {
       regionCode: 'WEST-COAST',
     };
 
-    webex.internal = {
-      services: {
-        get: sinon.mock().returns('locusUrl'),
-        waitForCatalog: sinon.mock().returns(Promise.resolve({})),
-      },
+    webex.internal.services = {
+      get: sinon.mock().returns('locusUrl'),
+      waitForCatalog: sinon.mock().returns(Promise.resolve({})),
     };
 
-
     reachabilityRequest = new ReachabilityRequest(webex);
 
   });
 
   describe('#getClusters', () => {
+
+    beforeEach(() => {
+      sinon.spy(webex.internal.newMetrics.callDiagnosticLatencies, 'measureLatency');
+    });
+
+    afterEach(() => {
+      sinon.restore();
+    });
+
     it('sends a GET request with the correct params', async () => {
       webex.request = sinon.mock().returns(Promise.resolve({
         body: {
@@ -49,7 +57,6 @@ describe('plugin-meetings/reachability', () => {
       }));
 
       const res = await reachabilityRequest.getClusters(IP_VERSION.only_ipv4);
-
       const requestParams = webex.request.getCall(0).args[0];
 
       assert.equal(requestParams.method, 'GET');
@@ -63,6 +70,7 @@ describe('plugin-meetings/reachability', () => {
       });
       assert.deepEqual(res.clusters.clusterId, {udp: "testUDP", isVideoMesh: true})
       assert.deepEqual(res.joinCookie, {anycastEntryPoint: "aws-eu-west-1"})
+      assert.calledOnceWithExactly(webex.internal.newMetrics.callDiagnosticLatencies.measureLatency, sinon.match.func, 'internal.get.cluster.time');
     });
   });
 });

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

@@ -144,6 +144,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);

package/test/unit/spec/recording-controller/index.js

@@ -3,7 +3,6 @@ import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
 import {HTTP_VERBS, SELF_POLICY} from '@webex/plugin-meetings/src/constants';
 
-
 describe('plugin-meetings', () => {
   describe('recording-controller tests', () => {
     describe('index', () => {

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', () => {