@webex/plugin-meetings 3.6.0 → 3.7.0-next.2

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

@@ -1234,7 +1234,7 @@ describe('gatherReachability', () => {
     assert.equal(receivedEvents['done'], 1);
 
     // and that ip network detection was started
-    assert.calledOnceWithExactly(webex.internal.device.ipNetworkDetector.detect);
+    assert.calledOnceWithExactly(webex.internal.device.ipNetworkDetector.detect, true);
 
     // finally, check the metrics - they should contain values from ipNetworkDetector
     assert.calledWith(Metrics.sendBehavioralMetric, 'js_sdk_reachability_completed', {
@@ -1664,6 +1664,270 @@ describe('gatherReachability', () => {
 
     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('getReachabilityResults', () => {

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: {
@@ -57,21 +52,67 @@ describe('plugin-meetings/reachability', () => {
         }
       }));
 
-      const res = await reachabilityRequest.getClusters(IP_VERSION.only_ipv4);
-      const requestParams = webex.request.getCall(0).args[0];
+      webex.config.meetings.reachabilityGetClusterTimeout = 3000;
 
-      assert.equal(requestParams.method, 'GET');
-      assert.equal(requestParams.resource, `clusters`);
-      assert.equal(requestParams.api, 'calliopeDiscovery');
-      assert.equal(requestParams.shouldRefreshAccessToken, false);
+      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.qs, {
-        JCSupport: 1,
-        ipver: 4,
+      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: '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/roap/index.ts

@@ -161,7 +161,7 @@ describe('Roap', () => {
           roapMessage: expectedRoapMessage,
           locusSelfUrl: meeting.selfUrl,
           mediaId: meeting.mediaId,
-          meetingId: meeting.id,
+          isMultistream: meeting.isMultistream,
           locusMediaRequest: meeting.locusMediaRequest,
         })
       );

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

@@ -4,6 +4,7 @@ import {assert} from '@webex/test-helper-chai';
 import MockWebex from '@webex/test-helper-mock-webex';
 import Meetings from '@webex/plugin-meetings';
 import RoapRequest from '@webex/plugin-meetings/src/roap/request';
+import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 import {IP_VERSION, REACHABILITY} from '@webex/plugin-meetings/src/constants';
 
 describe('plugin-meetings/roap', () => {
@@ -23,6 +24,11 @@ describe('plugin-meetings/roap', () => {
       regionCode: 'WEST-COAST',
     };
 
+    webex.meetings.reachability = {
+      getReachabilityReportToAttachToRoap: sinon.stub().resolves({}),
+      getClientMediaPreferences: sinon.stub().resolves({}),
+    };
+
     webex.internal = {
       services: {
         get: sinon.mock().returns(locusUrl),
@@ -36,6 +42,8 @@ describe('plugin-meetings/roap', () => {
       },
     };
 
+    sinon.stub(MeetingUtil, 'getIpVersion').returns(IP_VERSION.ipv4_and_ipv6);
+
     // @ts-ignore
     roapRequest = new RoapRequest({webex});
 
@@ -74,146 +82,80 @@ describe('plugin-meetings/roap', () => {
     );
   });
 
-  describe('#attachReachabilityData', () => {
-    it('returns the correct reachability data', async () => {
-      const res = await roapRequest.attachReachabilityData({});
-
-      assert.deepEqual(res.localSdp, {
-        reachability: {
-          clusterId: {
-            udp: {
-              reachable: 'true',
-              latencyInMilliseconds: '10',
-            },
-            tcp: {
-              reachable: 'false',
-            },
-            xtls: {
-              untested: 'true',
-            }
-          },
-        },
-      });
-      assert.deepEqual(res.joinCookie, {
-        anycastEntryPoint: 'aws-eu-west-1',
-      });
-    });
+  afterEach(() => {
+    sinon.restore();
+  })
 
-    it('handles the case when reachability data does not exist', async () => {
-      await webex.boundedStorage.del(REACHABILITY.namespace, REACHABILITY.localStorageJoinCookie);
+  describe('sendRoap', () => {
+    it('includes clientMediaPreferences and reachability in the request correctly', async () => {
+      const locusMediaRequest = {send: sinon.stub().resolves({body: {locus: {}}})};
 
-      await webex.boundedStorage.del(REACHABILITY.namespace, REACHABILITY.localStorageResult);
-      const sdp = {
-        some: 'attribute',
+      const FAKE_REACHABILITY_REPORT = {
+        id: 'fake reachability report',
+      };
+      const FAKE_CLIENT_MEDIA_PREFERENCES = {
+        id: 'fake client media preferences',
       };
 
-      const result = await roapRequest.attachReachabilityData(sdp);
-
-      assert.deepEqual(result, {
-        joinCookie: undefined,
-        localSdp: {
-          some: 'attribute',
-        },
-      });
-    });
-  });
-
-  describe('sendRoap', () => {
-    it('includes joinCookie in the request correctly', async () => {
-      const locusMediaRequest = {send: sinon.stub().resolves({body: {locus: {}}})};
-      const ipVersion = IP_VERSION.unknown;
+      webex.meetings.reachability.getReachabilityReportToAttachToRoap.resolves(FAKE_REACHABILITY_REPORT);
+      webex.meetings.reachability.getClientMediaPreferences.resolves(FAKE_CLIENT_MEDIA_PREFERENCES);
 
       await roapRequest.sendRoap({
         locusSelfUrl: locusUrl,
-        ipVersion,
         mediaId: 'mediaId',
         roapMessage: {
           seq: 'seq',
         },
         meetingId: 'meeting-id',
+        isMultistream: true,
         locusMediaRequest,
       });
 
+      assert.calledOnceWithExactly(webex.meetings.reachability.getReachabilityReportToAttachToRoap);
+      assert.calledOnceWithExactly(webex.meetings.reachability.getClientMediaPreferences, true, IP_VERSION.ipv4_and_ipv6);
+
       const requestParams = locusMediaRequest.send.getCall(0).args[0];
       assert.deepEqual(requestParams, {
         type: 'RoapMessage',
         selfUrl: locusUrl,
-        ipVersion,
-        joinCookie: {
-          anycastEntryPoint: 'aws-eu-west-1',
-        },
+        clientMediaPreferences: FAKE_CLIENT_MEDIA_PREFERENCES,
         mediaId: 'mediaId',
         roapMessage: {
           seq: 'seq',
         },
-        reachability: {
-          clusterId: {
-            tcp: {
-              reachable: 'false',
-            },
-            udp: {
-              latencyInMilliseconds: '10',
-              reachable: 'true',
-            },
-            xtls: {
-              untested: 'true',
-            },
-          },
-        },
+        reachability: FAKE_REACHABILITY_REPORT,
       });
     });
-  });
 
-  it('calls attachReachabilityData when sendRoap', async () => {
-    const locusMediaRequest = { send: sinon.stub().resolves({body: {locus: {}}})};
+    it('includes default clientMediaPreferences if calls to reachability fail', async () => {
+      const locusMediaRequest = {send: sinon.stub().resolves({body: {locus: {}}})};
 
-    const newSdp = {
-      new: 'sdp',
-      reachability: { someResult: 'whatever' }
-    };
-    const ipVersion = IP_VERSION.only_ipv6;
+      webex.meetings.reachability.getClientMediaPreferences.rejects(new Error('fake error'));
 
-    roapRequest.attachReachabilityData = sinon.stub().returns(
-      Promise.resolve({
-        localSdp: newSdp,
-        joinCookie: {
-          anycastEntryPoint: 'aws-eu-west-1',
+      await roapRequest.sendRoap({
+        locusSelfUrl: locusUrl,
+        mediaId: 'mediaId',
+        roapMessage: {
+          seq: 'seq',
         },
-      })
-    );
-
-    await roapRequest.sendRoap({
-      roapMessage: {
-        seq: 1,
-      },
-      locusSelfUrl: 'locusSelfUrl',
-      ipVersion,
-      mediaId: 'mediaId',
-      meetingId: 'meetingId',
-      preferTranscoding: true,
-      locusMediaRequest
-    });
-
-    const requestParams = locusMediaRequest.send.getCall(0).args[0];
+        meetingId: 'meeting-id',
+        isMultistream: true,
+        locusMediaRequest,
+      });
 
-    assert.deepEqual(requestParams, {
-      type: 'RoapMessage',
-      selfUrl: 'locusSelfUrl',
-      ipVersion,
-      joinCookie: {
-        anycastEntryPoint: 'aws-eu-west-1',
-      },
-      mediaId: 'mediaId',
-      roapMessage: {
-        seq: 1,
-      },
-      reachability: { someResult: 'whatever' },
-    });
+      assert.calledOnce(webex.meetings.reachability.getClientMediaPreferences);
 
-    assert.calledOnceWithExactly(roapRequest.attachReachabilityData, {
-      roapMessage: {
-        seq: 1,
-      },
+      const requestParams = locusMediaRequest.send.getCall(0).args[0];
+      assert.deepEqual(requestParams, {
+        type: 'RoapMessage',
+        selfUrl: locusUrl,
+        clientMediaPreferences: {ipver: 0, joinCookie: undefined, preferTranscoding: false},
+        mediaId: 'mediaId',
+        roapMessage: {
+          seq: 'seq',
+        },
+        reachability: undefined,
+      });
     });
   });
 });