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

package/test/unit/spec/members/utils.js

@@ -101,7 +101,7 @@ describe('plugin-meetings', () => {
       });
     });
     describe('#generateLowerAllHandsMemberOptions', () => {
-      it('returns the correct options', () => {
+      it('returns the correct options without roles', () => {
         const requestingParticipantId = 'test';
         const locusUrl = 'urlTest1';
 
@@ -113,6 +113,20 @@ describe('plugin-meetings', () => {
           }
         );
       });
+      it('returns the correct options with roles', () => {
+        const requestingParticipantId = 'test';
+        const locusUrl = 'urlTest1';
+        const roles = ['panelist'];
+
+        assert.deepEqual(
+          MembersUtil.generateLowerAllHandsMemberOptions(requestingParticipantId, locusUrl, roles),
+          {
+            requestingParticipantId,
+            locusUrl,
+            roles,
+          }
+        );
+      });
     });
     describe('#generateEditDisplayNameMemberOptions', () => {
       it('returns the correct options', () => {
@@ -248,5 +262,100 @@ describe('plugin-meetings', () => {
         testParams(false);
       });
     });
+
+    describe('#getAddMemberBody', () => {
+      it('returns the correct body with email address and roles', () => {
+        const options = {
+          invitee: {
+            emailAddress: 'test@example.com',
+            roles: ['role1', 'role2'],
+          },
+          alertIfActive: true,
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: 'test@example.com',
+              roles: ['role1', 'role2'],
+            },
+          ],
+          alertIfActive: true,
+        });
+      });
+
+      it('returns the correct body with phone number and no roles', () => {
+        const options = {
+          invitee: {
+            phoneNumber: '1234567890',
+          },
+          alertIfActive: false,
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: '1234567890',
+            },
+          ],
+          alertIfActive: false,
+        });
+      });
+
+      it('returns the correct body with fallback to email', () => {
+        const options = {
+          invitee: {
+            email: 'fallback@example.com',
+          },
+          alertIfActive: true,
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: 'fallback@example.com',
+            },
+          ],
+          alertIfActive: true,
+        });
+      });
+
+      it('handles missing `alertIfActive` gracefully', () => {
+        const options = {
+          invitee: {
+            emailAddress: 'test@example.com',
+            roles: ['role1'],
+          },
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: 'test@example.com',
+              roles: ['role1'],
+            },
+          ],
+          alertIfActive: undefined,
+        });
+      });
+
+      it('ignores roles if not provided', () => {
+        const options = {
+          invitee: {
+            emailAddress: 'test@example.com',
+          },
+          alertIfActive: false,
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: 'test@example.com',
+            },
+          ],
+          alertIfActive: false,
+        });
+      });
+    });
   });
 });

package/test/unit/spec/multistream/remoteMedia.ts

@@ -7,7 +7,7 @@ import {RemoteMedia, RemoteMediaEvents} from '@webex/plugin-meetings/src/multist
 import {ReceiveSlotEvents} from '@webex/plugin-meetings/src/multistream/receiveSlot';
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
-import { forEach } from 'lodash';
+import {forEach} from 'lodash';
 
 describe('RemoteMedia', () => {
   let remoteMedia;
@@ -227,12 +227,26 @@ describe('RemoteMedia', () => {
   });
 
   describe('setSizeHint()', () => {
-
     it('works if the receive slot is undefined', () => {
       remoteMedia.receiveSlot = undefined;
       remoteMedia.setSizeHint(100, 100);
     });
 
+    forEach(
+      [
+        {width: 0, height: 0},
+        {width: 135, height: 0},
+        {width: 0, height: 240},
+      ],
+      ({width, height}) => {
+        it(`skip updating the max fs when applied ${width}:${height}`, () => {
+          remoteMedia.setSizeHint(width, height);
+
+          assert.notCalled(fakeReceiveSlot.setMaxFs);
+        });
+      }
+    );
+
     forEach(
       [
         {height: 134, fs: 60},

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

@@ -15,6 +15,7 @@ describe('ClusterReachability', () => {
   let previousRTCPeerConnection;
   let clusterReachability;
   let fakePeerConnection;
+  let gatherIceCandidatesSpy;
 
   const emittedEvents: Record<Events, (ResultEventData | ClientMediaIpsUpdatedEventData)[]> = {
     [Events.resultReady]: [],
@@ -44,6 +45,8 @@ describe('ClusterReachability', () => {
       xtls: ['stun:xtls1.webex.com', 'stun:xtls2.webex.com:443'],
     });
 
+    gatherIceCandidatesSpy = sinon.spy(clusterReachability, 'gatherIceCandidates');
+
     resetEmittedEvents();
 
     clusterReachability.on(Events.resultReady, (data: ResultEventData) => {
@@ -151,6 +154,10 @@ describe('ClusterReachability', () => {
       assert.calledOnceWithExactly(fakePeerConnection.createOffer, {offerToReceiveAudio: true});
       assert.calledOnce(fakePeerConnection.setLocalDescription);
 
+      // Make sure that gatherIceCandidates is called before setLocalDescription
+      // as setLocalDescription triggers the ICE gathering process
+      assert.isTrue(gatherIceCandidatesSpy.calledBefore(fakePeerConnection.setLocalDescription));
+
       clusterReachability.abort();
       await promise;
 

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