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

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

@@ -196,6 +196,7 @@ describe('plugin-meetings', () => {
         const permissionToken = 'permission-token';
         const installationId = 'installationId';
         const reachability = 'reachability';
+        const clientMediaPreferences = 'clientMediaPreferences';
 
         await meetingsRequest.joinMeeting({
           locusUrl,
@@ -204,6 +205,7 @@ describe('plugin-meetings', () => {
           roapMessage,
           reachability,
           permissionToken,
+          clientMediaPreferences
         });
         const requestParams = meetingsRequest.request.getCall(0).args[0];
 
@@ -214,6 +216,7 @@ describe('plugin-meetings', () => {
         assert.equal(requestParams.body.device.countryCode, 'US');
         assert.equal(requestParams.body.permissionToken, 'permission-token');
         assert.equal(requestParams.body.device.regionCode, 'WEST-COAST');
+        assert.equal(requestParams.body.clientMediaPreferences, 'clientMediaPreferences');
         assert.include(requestParams.body.device.localIp, '127.0.0');
         assert.deepEqual(requestParams.body.localMedias, [
           {localSdp: '{"roapMessage":"roap-message","reachability":"reachability"}'},
@@ -386,32 +389,6 @@ describe('plugin-meetings', () => {
 
         assert.deepEqual(requestParams.body.alias, undefined);
       });
-
-      it('includes joinCookie and ipver correctly', async () => {
-        const locusUrl = 'locusURL';
-        const deviceUrl = 'deviceUrl';
-        const correlationId = 'random-uuid';
-        const roapMessage = 'roap-message';
-        const permissionToken = 'permission-token';
-
-        await meetingsRequest.joinMeeting({
-          locusUrl,
-          deviceUrl,
-          correlationId,
-          roapMessage,
-          permissionToken,
-          ipVersion: IP_VERSION.ipv4_and_ipv6,
-        });
-        const requestParams = meetingsRequest.request.getCall(0).args[0];
-
-        assert.equal(requestParams.method, 'POST');
-        assert.equal(requestParams.uri, `${locusUrl}/participant?alternateRedirect=true`);
-        assert.deepEqual(requestParams.body.clientMediaPreferences, {
-          joinCookie: {anycastEntryPoint: 'aws-eu-west-1'},
-          preferTranscoding: true,
-          ipver: 1,
-        });
-      });
     });
 
     describe('#pstn', () => {

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

@@ -22,6 +22,12 @@ describe('plugin-meetings', () => {
           meetings: Meetings,
         },
       });
+
+      webex.meetings.reachability = {
+        getReachabilityReportToAttachToRoap: sinon.stub().resolves({}),
+        getClientMediaPreferences: sinon.stub().resolves({}),
+      };  
+
       const logger = {
         info: sandbox.stub(),
         log: sandbox.stub(),
@@ -408,17 +414,39 @@ describe('plugin-meetings', () => {
       });
 
       it('#Should call `meetingRequest.joinMeeting', async () => {
+        meeting.isMultistream = true;
+
+        const FAKE_REACHABILITY_REPORT = {
+          id: 'fake reachability report',
+        };
+        const FAKE_CLIENT_MEDIA_PREFERENCES = {
+          id: 'fake client media preferences',
+        };
+  
+        webex.meetings.reachability.getReachabilityReportToAttachToRoap.resolves(FAKE_REACHABILITY_REPORT);
+        webex.meetings.reachability.getClientMediaPreferences.resolves(FAKE_CLIENT_MEDIA_PREFERENCES);
+        
+        sinon
+          .stub(webex.internal.device.ipNetworkDetector, 'supportsIpV4')
+          .get(() => true);
+        sinon
+          .stub(webex.internal.device.ipNetworkDetector, 'supportsIpV6')
+          .get(() => true);
+          
         await MeetingUtil.joinMeeting(meeting, {
           reachability: 'reachability',
           roapMessage: 'roapMessage',
         });
 
+        assert.calledOnceWithExactly(webex.meetings.reachability.getReachabilityReportToAttachToRoap);
+        assert.calledOnceWithExactly(webex.meetings.reachability.getClientMediaPreferences, meeting.isMultistream, IP_VERSION.ipv4_and_ipv6);
+
         assert.calledOnce(meeting.meetingRequest.joinMeeting);
         const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
 
         assert.equal(parameter.inviteeAddress, 'meetingJoinUrl');
-        assert.equal(parameter.preferTranscoding, true);
-        assert.equal(parameter.reachability, 'reachability');
+        assert.equal(parameter.reachability, FAKE_REACHABILITY_REPORT);
+        assert.equal(parameter.clientMediaPreferences, FAKE_CLIENT_MEDIA_PREFERENCES);
         assert.equal(parameter.roapMessage, 'roapMessage');
 
         assert.calledOnce(meeting.setLocus)
@@ -445,6 +473,29 @@ describe('plugin-meetings', () => {
         });
       });
 
+      it('should handle failed reachability report retrieval', async () => {
+        webex.meetings.reachability.getReachabilityReportToAttachToRoap.rejects(
+          new Error('fake error')
+        );
+        await MeetingUtil.joinMeeting(meeting, {});
+        // Verify meeting join still proceeds
+        assert.calledOnce(meeting.meetingRequest.joinMeeting);
+      });
+
+      it('should handle failed clientMediaPreferences retrieval', async () => {
+        webex.meetings.reachability.getClientMediaPreferences.rejects(new Error('fake error'));
+        meeting.isMultistream = true;
+        await MeetingUtil.joinMeeting(meeting, {});
+        // Verify meeting join still proceeds
+        assert.calledOnce(meeting.meetingRequest.joinMeeting);
+        const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
+        assert.deepEqual(parameter.clientMediaPreferences, {
+          preferTranscoding: false,
+          ipver: 0,
+          joinCookie: undefined,
+        });
+      });
+
       it('#Should call meetingRequest.joinMeeting with breakoutsSupported=true when passed in as true', async () => {
         await MeetingUtil.joinMeeting(meeting, {
           breakoutsSupported: true,
@@ -480,17 +531,6 @@ describe('plugin-meetings', () => {
         assert.deepEqual(parameter.deviceCapabilities, ['TEST']);
       });
 
-      it('#Should call meetingRequest.joinMeeting with preferTranscoding=false when multistream is enabled', async () => {
-        meeting.isMultistream = true;
-        await MeetingUtil.joinMeeting(meeting, {});
-
-        assert.calledOnce(meeting.meetingRequest.joinMeeting);
-        const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
-
-        assert.equal(parameter.inviteeAddress, 'meetingJoinUrl');
-        assert.equal(parameter.preferTranscoding, false);
-      });
-
       it('#Should fallback sipUrl if meetingJoinUrl does not exists', async () => {
         meeting.meetingJoinUrl = undefined;
         meeting.sipUri = 'sipUri';

package/test/unit/spec/meetings/index.js

@@ -2077,6 +2077,21 @@ describe('plugin-meetings', () => {
           ]);
         });
 
+        it('should handle failure to get user information if scopes are insufficient', async () => {
+          loggerProxySpy = sinon.spy(LoggerProxy.logger, 'error');
+          Object.assign(webex.people, {
+            _getMe: sinon.stub().returns(Promise.reject()),
+          });
+
+          await webex.meetings.fetchUserPreferredWebexSite();
+
+          assert.equal(webex.meetings.preferredWebexSite, '');
+          assert.calledOnceWithExactly(
+            loggerProxySpy,
+            'Failed to retrieve user information. No preferredWebexSite will be set'
+          );
+        });
+
         const setup = ({me = { type: 'validuser'}, user} = {}) => {
           loggerProxySpy = sinon.spy(LoggerProxy.logger, 'error');
           assert.deepEqual(webex.internal.services._getCatalog().getAllowedDomains(), []);
@@ -2093,7 +2108,7 @@ describe('plugin-meetings', () => {
 
           Object.assign(webex.people, {
             _getMe: sinon.stub().returns(Promise.resolve(me)),
-        });
+          });
         };
 
         it('should not call request.getMeetingPreferences if user is a guest', async () => {

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

@@ -660,17 +660,20 @@ describe('plugin-meetings', () => {
         resultPromise,
         spies,
         expectedRequestingMemberId,
-        expectedLocusUrl
+        expectedLocusUrl,
+        expectedRoles,
       ) => {
         await assert.isFulfilled(resultPromise);
         assert.calledOnceWithExactly(
           spies.generateLowerAllHandsMemberOptions,
           expectedRequestingMemberId,
-          expectedLocusUrl
+          expectedLocusUrl,
+          expectedRoles,
         );
         assert.calledOnceWithExactly(spies.lowerAllHandsMember, {
           requestingParticipantId: expectedRequestingMemberId,
           locusUrl: expectedLocusUrl,
+          ...(expectedRoles !== undefined && { roles: expectedRoles })
         });
         assert.strictEqual(resultPromise, spies.lowerAllHandsMember.getCall(0).returnValue);
       };
@@ -707,6 +710,26 @@ describe('plugin-meetings', () => {
 
         await checkValid(resultPromise, spies, requestingMemberId, url1);
       });
+
+      it('should make the correct request when called with valid requestingMemberId and roles', async () => {
+        const requestingMemberId = 'test-member-id';
+        const roles = ['panelist', 'attendee'];
+        const { members, spies } = setup('test-locus-url');
+
+        const resultPromise = members.lowerAllHands(requestingMemberId, roles);
+
+        await checkValid(resultPromise, spies, requestingMemberId, 'test-locus-url', roles);
+      });
+
+      it('should handle an empty roles array correctly', async () => {
+        const requestingMemberId = 'test-member-id';
+        const roles = [];
+        const { members, spies } = setup('test-locus-url');
+
+        const resultPromise = members.lowerAllHands(requestingMemberId, roles);
+
+        await checkValid(resultPromise, spies, requestingMemberId, 'test-locus-url', roles);
+      });
     });
 
     describe('#editDisplayName', () => {

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

@@ -225,7 +225,7 @@ describe('plugin-meetings', () => {
     });
 
     describe('#assignRolesMember', () => {
-      it('sends a PATCH to the locus endpoint', async () => {
+      it('sends a assignRolesMember PATCH to the locus endpoint', async () => {
         const locusUrl = url1;
         const memberId = 'test1';
         const roles = [
@@ -255,7 +255,7 @@ describe('plugin-meetings', () => {
     });
 
     describe('#raiseHand', () => {
-      it('sends a PATCH to the locus endpoint', async () => {
+      it('sends a raiseOrLowerHandMember PATCH to the locus endpoint', async () => {
         const locusUrl = url1;
         const memberId = 'test1';
 
@@ -319,7 +319,7 @@ describe('plugin-meetings', () => {
         assert.strictEqual(result, requestResponse);
       });
 
-      it('sends a PATCH to the locus endpoint', async () => {
+      it('sends a lowerAllHandsMember PATCH to the locus endpoint', async () => {
         const locusUrl = url1;
         const memberId = 'test1';
 
@@ -348,6 +348,40 @@ describe('plugin-meetings', () => {
           },
         });
       });
+
+      it('sends a lowerAllHandsMember PATCH to the locus endpoint with roles', async () => {
+        const locusUrl = url1;
+        const memberId = 'test1';
+        const roles = ['attendee'];
+
+        const options = {
+          requestingParticipantId: memberId,
+          locusUrl,
+          roles,
+        };
+
+        const getRequestParamsSpy = sandbox.spy(membersUtil, 'getLowerAllHandsMemberRequestParams');
+
+        await membersRequest.lowerAllHandsMember(options);
+
+        assert.calledOnceWithExactly(getRequestParamsSpy, {
+          requestingParticipantId: memberId,
+          locusUrl: url1,
+          roles: ['attendee'],
+        });
+
+        checkRequest({
+          method: 'PATCH',
+          uri: `${locusUrl}/controls`,
+          body: {
+            hand: {
+              raised: false,
+              roles: ['attendee'],
+            },
+            requestingParticipantId: memberId,
+          },
+        });
+      });
     });
 
     describe('#editDisplayName', () => {

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

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