@webex/plugin-meetings 3.6.0-next.9 → 3.7.0-next.1

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,
+      });
     });
   });
 });