@webex/plugin-meetings 3.7.0 → 3.8.0

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

@@ -1050,6 +1050,7 @@ describe('gatherReachability', () => {
 
         // the metrics related to ipver and trigger are not tested in these tests and are all the same, so setting them up here
         const expectedMetricsFull = {
+          aborted: false,
           ...expectedMetrics,
           ipver_firstIpV4: -1,
           ipver_firstIpV6: -1,
@@ -1238,6 +1239,7 @@ describe('gatherReachability', () => {
 
     // finally, check the metrics - they should contain values from ipNetworkDetector
     assert.calledWith(Metrics.sendBehavioralMetric, 'js_sdk_reachability_completed', {
+      aborted: false,
       vmn_udp_min: -1,
       vmn_udp_max: -1,
       vmn_udp_average: -1,
@@ -1622,14 +1624,14 @@ describe('gatherReachability', () => {
     const reachability = new Reachability(webex);
 
     let getClustersCallCount = 0;
-    
+
     reachability.reachabilityRequest.getClusters = sinon.stub().callsFake(() => {
       getClustersCallCount++;
 
       if (getClustersCallCount == 1) {
         throw new Error('fake error');
       }
-      
+
       return getClustersResult;
     });
 
@@ -1637,7 +1639,7 @@ describe('gatherReachability', () => {
 
     await simulateTimeout();
     await promise;
-    
+
     assert.equal(getClustersCallCount, 2);
 
     assert.calledOnce(clusterReachabilityCtorStub);
@@ -1647,7 +1649,7 @@ describe('gatherReachability', () => {
     const reachability = new Reachability(webex);
 
     let getClustersCallCount = 0;
-    
+
     reachability.reachabilityRequest.getClusters = sinon.stub().callsFake(() => {
       getClustersCallCount++;
 
@@ -1657,13 +1659,356 @@ describe('gatherReachability', () => {
     const promise = reachability.gatherReachability('test');
 
     await simulateTimeout();
-    
+
     await promise;
-    
+
     assert.equal(getClustersCallCount, 2);
 
     assert.neverCalledWith(clusterReachabilityCtorStub);
   });
+
+  describe('fallback mechanism and multiple calls to getClusters', () => {
+    let receivedEvents;
+
+    const mockGetClustersEmptyResult = {
+      discoveryOptions: {
+        ['early-call-min-clusters']: 0,
+        ['report-version']: 1,
+      },
+      clusters: {}, // empty cluster list
+      joinCookie: {id: 'cookie'},
+    };
+
+    beforeEach(() => {
+      webex.config.meetings.experimental = {
+        enableTcpReachability: true,
+        enableTlsReachability: true,
+      };
+
+      receivedEvents = {
+        done: 0,
+      };
+    });
+
+    it('keeps retrying if minimum required clusters are not reached', async () => {
+      const reachability = new Reachability(webex);
+
+      reachability.on('reachability:done', () => {
+        receivedEvents.done += 1;
+      });
+
+      const mockGetClustersResult1 = {
+        discoveryOptions: {
+          ['early-call-min-clusters']: 2,
+          ['report-version']: 1,
+        },
+        clusters: {
+          clusterA0: {
+            udp: ['udp-urlA'],
+            tcp: ['tcp-urlA'],
+            xtls: ['xtls-urlA'],
+            isVideoMesh: false,
+          },
+          clusterB0: {
+            udp: ['udp-urlB'],
+            tcp: ['tcp-urlB'],
+            xtls: ['xtls-urlB'],
+            isVideoMesh: false,
+          },
+        },
+        joinCookie: {id: 'cookie1'},
+      };
+      const mockGetClustersResult2 = {
+        discoveryOptions: {
+          ['early-call-min-clusters']: 2,
+          ['report-version']: 1,
+        },
+        clusters: {
+          clusterA1: {
+            udp: ['udp-urlA'],
+            tcp: ['tcp-urlA'],
+            xtls: ['xtls-urlA'],
+            isVideoMesh: false,
+          },
+          clusterB1: {
+            udp: ['udp-urlB'],
+            tcp: ['tcp-urlB'],
+            xtls: ['xtls-urlB'],
+            isVideoMesh: false,
+          },
+        },
+        joinCookie: {id: 'cookie2'},
+      };
+      const mockGetClustersResult3 = {
+        discoveryOptions: {
+          ['early-call-min-clusters']: 1,
+          ['report-version']: 1,
+        },
+        clusters: {
+          clusterA2: {
+            udp: ['udp-urlA'],
+            tcp: ['tcp-urlA'],
+            xtls: ['xtls-urlA'],
+            isVideoMesh: false,
+          },
+          clusterB2: {
+            udp: ['udp-urlB'],
+            tcp: ['tcp-urlB'],
+            xtls: ['xtls-urlB'],
+            isVideoMesh: false,
+          },
+        },
+        joinCookie: {id: 'cookie3'},
+      };
+
+      reachability.reachabilityRequest.getClusters = sinon.stub();
+      reachability.reachabilityRequest.getClusters.onCall(0).returns(mockGetClustersResult1);
+      reachability.reachabilityRequest.getClusters.onCall(1).returns(mockGetClustersResult2);
+
+      reachability.reachabilityRequest.getClusters.onCall(2).returns(mockGetClustersResult3);
+
+      const resultPromise = reachability.gatherReachability('test');
+
+      await testUtils.flushPromises();
+
+      // trigger some mock result events from ClusterReachability instances,
+      // but only from 1 cluster, so not enough to reach the minimum required
+      mockClusterReachabilityInstances['clusterA0'].emitFakeResult('udp', {
+        result: 'reachable',
+        clientMediaIPs: ['1.2.3.4'],
+        latencyInMilliseconds: 11,
+      });
+
+      clock.tick(3000);
+      await resultPromise;
+      await testUtils.flushPromises();
+
+      // because the minimum was not reached, another call to getClusters should be made
+      assert.calledTwice(reachability.reachabilityRequest.getClusters);
+
+      // simulate no results this time
+
+      // check that while the 2nd attempt is in progress, the join cookie is already available from the 2nd call to getClusters
+      const clientMediaPreferences = await reachability.getClientMediaPreferences(
+        true,
+        IP_VERSION.unknown
+      );
+
+      assert.deepEqual(clientMediaPreferences.joinCookie, mockGetClustersResult2.joinCookie);
+
+      clock.tick(3000);
+      await testUtils.flushPromises();
+
+      assert.calledThrice(reachability.reachabilityRequest.getClusters);
+
+      await testUtils.flushPromises();
+
+      // this time 1 result will be enough to reach the minimum
+      mockClusterReachabilityInstances['clusterA2'].emitFakeResult('udp', {
+        result: 'reachable',
+        clientMediaIPs: ['1.2.3.4'],
+        latencyInMilliseconds: 11,
+      });
+      clock.tick(3000);
+
+      // the reachability results should include only results from the last attempt
+      await checkResults(
+        {
+          clusterA2: {
+            udp: {result: 'reachable', clientMediaIPs: ['1.2.3.4'], latencyInMilliseconds: 11},
+            tcp: {result: 'unreachable'},
+            xtls: {result: 'unreachable'},
+            isVideoMesh: false,
+          },
+          clusterB2: {
+            udp: {result: 'unreachable'},
+            tcp: {result: 'unreachable'},
+            xtls: {result: 'unreachable'},
+            isVideoMesh: false,
+          },
+        },
+        mockGetClustersResult3.joinCookie
+      );
+
+      // wait some more time to make sure that there are no timers that fire from one of the previous checks
+      clock.tick(20000);
+
+      // as the first 2 attempts failed and didn't reach the overall timeout, there should be only 1 done event emitted
+      assert.equal(receivedEvents.done, 1);
+    });
+
+    it('handles getClusters() returning empty list on 1st call', async () => {
+      const reachability = new Reachability(webex);
+
+      reachability.on('reachability:done', () => {
+        receivedEvents.done += 1;
+      });
+
+      reachability.reachabilityRequest.getClusters = sinon
+        .stub()
+        .resolves(mockGetClustersEmptyResult);
+
+      const resultPromise = reachability.gatherReachability('test');
+
+      await testUtils.flushPromises();
+
+      clock.tick(3000);
+      await resultPromise;
+      await testUtils.flushPromises();
+
+      assert.calledOnce(reachability.reachabilityRequest.getClusters);
+      reachability.reachabilityRequest.getClusters.resetHistory();
+
+      assert.equal(receivedEvents.done, 1);
+      await checkResults({}, mockGetClustersEmptyResult.joinCookie);
+
+      // because we didn't actually test anything (we got empty cluster list from getClusters()), we should
+      // not say that webex backend is unreachable
+      assert.equal(await reachability.isWebexMediaBackendUnreachable(), false);
+
+      // wait to check that there are no other things happening
+      clock.tick(20000);
+      await testUtils.flushPromises();
+
+      assert.notCalled(reachability.reachabilityRequest.getClusters);
+      assert.equal(receivedEvents.done, 1);
+    });
+
+    it('handles getClusters() returning empty list on 2nd call', async () => {
+      const reachability = new Reachability(webex);
+
+      reachability.on('reachability:done', () => {
+        receivedEvents.done += 1;
+      });
+
+      const mockGetClustersResult1 = {
+        discoveryOptions: {
+          ['early-call-min-clusters']: 2,
+          ['report-version']: 1,
+        },
+        clusters: {
+          clusterA0: {
+            udp: ['udp-urlA'],
+            tcp: ['tcp-urlA'],
+            xtls: ['xtls-urlA'],
+            isVideoMesh: false,
+          },
+          clusterB0: {
+            udp: ['udp-urlB'],
+            tcp: ['tcp-urlB'],
+            xtls: ['xtls-urlB'],
+            isVideoMesh: false,
+          },
+        },
+        joinCookie: {id: 'cookie1'},
+      };
+
+      reachability.reachabilityRequest.getClusters = sinon.stub();
+      reachability.reachabilityRequest.getClusters.onCall(0).returns(mockGetClustersResult1);
+      reachability.reachabilityRequest.getClusters.onCall(1).returns(mockGetClustersEmptyResult);
+
+      const resultPromise = reachability.gatherReachability('test');
+
+      await testUtils.flushPromises();
+
+      clock.tick(3000);
+      await resultPromise;
+      await testUtils.flushPromises();
+
+      // because the minimum was not reached, another call to getClusters should be made
+      assert.calledTwice(reachability.reachabilityRequest.getClusters);
+
+      // the reachability results should include only results from the last attempt
+      await checkResults({}, mockGetClustersEmptyResult.joinCookie);
+
+      // as the first 2 attempts failed and didn't reach the overall timeout, there should be only 1 done event emitted
+      assert.equal(receivedEvents.done, 1);
+      // because we didn't actually test anything (we got empty cluster list from getClusters()), we should
+      // not say that webex backend is unreachable
+      assert.equal(await reachability.isWebexMediaBackendUnreachable(), false);
+    });
+  });
+
+  describe('stopReachability', () => {
+    let reachability;
+    let receivedEvents;
+    let sendMetricSpy;
+
+    beforeEach(() => {
+      reachability = new Reachability(webex);
+
+      receivedEvents = {};
+
+      sendMetricSpy = sinon.stub(reachability, 'sendMetric').resolves();
+    });
+
+    const setListener = (event) => {
+      reachability.on(event, () => {
+        receivedEvents[event] = receivedEvents[event] + 1 || 1;
+      });
+    };
+    it('works as expected', async () => {
+      setListener('reachability:stopped');
+      setListener('reachability:done');
+      setListener('reachability:firstResultAvailable');
+
+      const mockGetClustersResult = {
+        clusters: {
+          clusterA: {
+            udp: ['udp-urlA'],
+            tcp: ['tcp-urlA'],
+            xtls: ['xtls-urlA'],
+            isVideoMesh: false,
+          },
+          clusterB: {
+            udp: ['udp-urlB'],
+            tcp: ['tcp-urlB'],
+            xtls: ['xtls-urlB'],
+            isVideoMesh: false,
+          },
+        },
+        joinCookie: {id: 'id'},
+      };
+
+      reachability.reachabilityRequest.getClusters = sinon.stub().returns(mockGetClustersResult);
+
+      const gatherReachabilityFallbackSpy = sinon.spy(reachability, 'gatherReachabilityFallback');
+
+      const resultPromise = reachability.gatherReachability('test');
+
+      await testUtils.flushPromises();
+
+      reachability.stopReachability();
+
+      await resultPromise;
+
+      // simulate a lot of time passing to check that all timers were stopped and nothing else happens
+      clock.tick(99000);
+
+      assert.calledOnceWithExactly(mockClusterReachabilityInstances['clusterA'].abort);
+      assert.calledOnceWithExactly(mockClusterReachabilityInstances['clusterB'].abort);
+
+      assert.calledOnceWithExactly(sendMetricSpy, true);
+
+      assert.equal(receivedEvents['reachability:stopped'], 1);
+      assert.equal(receivedEvents['reachability:done'], undefined);
+      assert.equal(receivedEvents['reachability:firstResultAvailable'], undefined);
+
+      assert.notCalled(gatherReachabilityFallbackSpy);
+    });
+
+    it('does nothing if called without reachability being started', async () => {
+      const reachability = new Reachability(webex);
+
+      reachability.stopReachability();
+
+      assert.notCalled(sendMetricSpy);
+
+      assert.equal(receivedEvents['reachability:stopped'], undefined);
+      assert.equal(receivedEvents['reachability:done'], undefined);
+      assert.equal(receivedEvents['reachability:firstResultAvailable'], undefined);
+    });
+  });
 });
 
 describe('getReachabilityResults', () => {
@@ -2225,19 +2570,18 @@ describe('getStatistics', () => {
 describe('sendMetric', () => {
   let webex;
   let reachability;
+  let getStatisticsStub;
 
   beforeEach(() => {
     webex = new MockWebex();
     reachability = new TestReachability(webex);
 
     sinon.stub(Metrics, 'sendBehavioralMetric');
-  });
 
-  it('works as expected', async () => {
     // setup stub for getStatistics to return values that show what parameters it was called with,
     // this way we can verify that the correct results of calls to getStatistics are placed
     // in correct data fields when sendBehavioralMetric() is called
-    const getStatisticsStub = sinon
+    getStatisticsStub = sinon
       .stub(reachability, 'getStatistics')
       .callsFake((results, protocol, isVideoMesh) => {
         return {result: 'fake', protocol, isVideoMesh};
@@ -2258,7 +2602,13 @@ describe('sendMetric', () => {
         isVideoMesh: false,
       },
     });
+  });
 
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  it('works as expected', async () => {
     await reachability.sendMetric();
 
     // each call to getStatistics should be made with all the results from all fake clusterReachability:
@@ -2282,6 +2632,30 @@ describe('sendMetric', () => {
     assert.alwaysCalledWith(getStatisticsStub, expectedResults, sinon.match.any, sinon.match.any);
 
     assert.calledWith(Metrics.sendBehavioralMetric, 'js_sdk_reachability_completed', {
+      aborted: false,
+      vmn_udp_result: 'fake',
+      vmn_udp_protocol: 'udp',
+      vmn_udp_isVideoMesh: true,
+
+      public_udp_result: 'fake',
+      public_udp_protocol: 'udp',
+      public_udp_isVideoMesh: false,
+
+      public_tcp_result: 'fake',
+      public_tcp_protocol: 'tcp',
+      public_tcp_isVideoMesh: false,
+
+      public_xtls_result: 'fake',
+      public_xtls_protocol: 'xtls',
+      public_xtls_isVideoMesh: false,
+    });
+  });
+
+  it('sends metric with "aborted:true" if called with aborted=true arg', async () => {
+    await reachability.sendMetric(true);
+
+    assert.calledWith(Metrics.sendBehavioralMetric, 'js_sdk_reachability_completed', {
+      aborted: true,
       vmn_udp_result: 'fake',
       vmn_udp_protocol: 'udp',
       vmn_udp_isVideoMesh: true,

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

@@ -35,16 +35,11 @@ describe('plugin-meetings/reachability', () => {
   });
 
   describe('#getClusters', () => {
+    let previousReport;
 
     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: {
           clusterClasses: {
@@ -59,24 +54,65 @@ describe('plugin-meetings/reachability', () => {
 
       webex.config.meetings.reachabilityGetClusterTimeout = 3000;
 
-      const res = await reachabilityRequest.getClusters(IP_VERSION.only_ipv4);
+      previousReport = {
+        id: 'fake previous report',
+      }
+    });
+
+    afterEach(() => {
+      sinon.restore();
+    });
+
+    it('sends a POST request with the correct params when trigger is "startup"', async () => {
+      const res = await reachabilityRequest.getClusters('startup', IP_VERSION.only_ipv4, previousReport);
       const requestParams = webex.request.getCall(0).args[0];
 
       assert.deepEqual(requestParams, {
-        method: 'GET',
+        method: 'POST',
         resource: `clusters`,
         api: 'calliopeDiscovery',
         shouldRefreshAccessToken: false,
-        qs: {
-          JCSupport: 1,
-          ipver: 4,
-        },
         timeout: 3000,
+        body: {
+          ipver: IP_VERSION.only_ipv4,
+          'supported-options': {
+            'report-version': 1,
+            'early-call-min-clusters': true,
+          },
+          'previous-report': previousReport,
+          trigger: 'startup',
+        },
       });
 
       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');
     });
+
+    it('sends a POST request with the correct params when trigger is other than "startup"', async () => {
+      const res = await reachabilityRequest.getClusters('early-call/no-min-reached', IP_VERSION.only_ipv4, previousReport);
+      const requestParams = webex.request.getCall(0).args[0];
+
+      assert.deepEqual(requestParams, {
+        method: 'POST',
+        resource: `clusters`,
+        api: 'calliopeDiscovery',
+        shouldRefreshAccessToken: false,
+        timeout: 3000,
+        body: {
+          ipver: IP_VERSION.only_ipv4,
+          'supported-options': {
+            'report-version': 1,
+            'early-call-min-clusters': true,
+          },
+          'previous-report': previousReport,
+          trigger: 'early-call/no-min-reached',
+        },
+      });
+
+      assert.deepEqual(res.clusters.clusterId, {udp: "testUDP", isVideoMesh: true})
+      assert.deepEqual(res.joinCookie, {anycastEntryPoint: "aws-eu-west-1"})
+      assert.notCalled(webex.internal.newMetrics.callDiagnosticLatencies.measureLatency);
+    });
   });
 });

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

@@ -221,7 +221,21 @@ describe('plugin-meetings', () => {
 
             assert.calledWith(request.request, {
               uri: `test/loci/id/recording`,
-              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'start'}},
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'start'}, recordingType: 'cloud'},
+              method: HTTP_VERBS.PUT,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+
+          it('can start premise recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['PREMISE_RECORDING_CONTROL_START']);
+
+            const result = controller.startRecording();
+
+            assert.calledWith(request.request, {
+              uri: `test/loci/id/recording`,
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'start'}, recordingType: 'premise'},
               method: HTTP_VERBS.PUT,
             });
 
@@ -238,14 +252,28 @@ describe('plugin-meetings', () => {
             assert.isRejected(result);
           });
 
-          it('can start recording when the correct display hint is present', () => {
+          it('can stop recording when the correct display hint is present', () => {
             controller.setDisplayHints(['RECORDING_CONTROL_STOP']);
 
             const result = controller.stopRecording();
 
             assert.calledWith(request.request, {
               uri: `test/loci/id/recording`,
-              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'stop'}},
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'stop'}, recordingType: 'cloud'},
+              method: HTTP_VERBS.PUT,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+
+          it('can stop premise recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['PREMISE_RECORDING_CONTROL_STOP']);
+
+            const result = controller.stopRecording();
+
+            assert.calledWith(request.request, {
+              uri: `test/loci/id/recording`,
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'stop'}, recordingType: 'premise'},
               method: HTTP_VERBS.PUT,
             });
 
@@ -269,7 +297,21 @@ describe('plugin-meetings', () => {
 
             assert.calledWith(request.request, {
               uri: `test/loci/id/recording`,
-              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'pause'}},
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'pause'}, recordingType: 'cloud'},
+              method: HTTP_VERBS.PUT,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+
+          it('can pause premise recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['PREMISE_RECORDING_CONTROL_PAUSE']);
+
+            const result = controller.pauseRecording();
+
+            assert.calledWith(request.request, {
+              uri: `test/loci/id/recording`,
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'pause'}, recordingType: 'premise'},
               method: HTTP_VERBS.PUT,
             });
 
@@ -293,7 +335,21 @@ describe('plugin-meetings', () => {
 
             assert.calledWith(request.request, {
               uri: `test/loci/id/recording`,
-              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'resume'}},
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'resume'}, recordingType: 'cloud'},
+              method: HTTP_VERBS.PUT,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+
+          it('can resume premise recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['PREMISE_RECORDING_CONTROL_RESUME']);
+
+            const result = controller.resumeRecording();
+
+            assert.calledWith(request.request, {
+              uri: `test/loci/id/recording`,
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'resume'}, recordingType: 'premise'},
               method: HTTP_VERBS.PUT,
             });