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

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/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/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', {

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

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

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

@@ -29,32 +29,98 @@ describe('plugin-meetings', () => {
             });
         });
 
-        describe('#webcastUrlUpdate', () => {
-            it('sets the webcast url', () => {
-                webinar.webcastUrlUpdate('newUrl');
+        describe('#updateWebcastUrl', () => {
+            it('sets the webcast instance url', () => {
+                webinar.updateWebcastUrl({resources: {webcastInstance: {url:'newUrl'}}});
 
-                assert.equal(webinar.webcastUrl, 'newUrl');
+                assert.equal(webinar.webcastInstanceUrl, 'newUrl');
             });
         });
 
-        describe('#webinarAttendeesSearchingUrlUpdate', () => {
-            it('sets the webinarAttendeesSearching url', () => {
-                webinar.webinarAttendeesSearchingUrlUpdate('newUrl');
-
-                assert.equal(webinar.webinarAttendeesSearchingUrl, 'newUrl');
-            });
-        });
 
         describe('#updateCanManageWebcast', () => {
-          it('update canManageWebcast', () => {
-            webinar.updateCanManageWebcast(true);
+          it('sets the webcast instance url when valid', () => {
+            webinar.updateWebcastUrl({resources: {webcastInstance: {url:'newUrl'}}});
+            assert.equal(webinar.webcastInstanceUrl, 'newUrl', 'webcast instance URL should be updated');
+          });
 
-            assert.equal(webinar.canManageWebcast, true);
+          it('handles missing resources gracefully', () => {
+              webinar.updateWebcastUrl({});
+              assert.isUndefined(webinar.webcastInstanceUrl, 'webcast instance URL should be undefined');
+          });
 
-            webinar.updateCanManageWebcast(false);
+          it('handles missing webcastInstance gracefully', () => {
+              webinar.updateWebcastUrl({resources: {}});
+              assert.isUndefined(webinar.webcastInstanceUrl, 'webcast instance URL should be undefined');
+          });
 
-            assert.equal(webinar.canManageWebcast, false);
+          it('handles missing URL gracefully', () => {
+              webinar.updateWebcastUrl({resources: {webcastInstance: {}}});
+              assert.isUndefined(webinar.webcastInstanceUrl, 'webcast instance URL should be undefined');
           });
         });
+
+      describe('#updateRoleChanged', () => {
+        it('updates roles when promoted from attendee to panelist', () => {
+          const payload = {
+            oldRoles: ['ATTENDEE'],
+            newRoles: ['PANELIST']
+          };
+
+          const result = webinar.updateRoleChanged(payload);
+
+          assert.equal(webinar.selfIsPanelist, true, 'self should be a panelist');
+          assert.equal(webinar.selfIsAttendee, false, 'self should not be an attendee');
+          assert.equal(webinar.canManageWebcast, false, 'self should not have manage webcast capability');
+          assert.equal(result.isPromoted, true, 'should indicate promotion');
+          assert.equal(result.isDemoted, false, 'should not indicate demotion');
+        });
+
+        it('updates roles when demoted from panelist to attendee', () => {
+          const payload = {
+            oldRoles: ['PANELIST'],
+            newRoles: ['ATTENDEE']
+          };
+
+          const result = webinar.updateRoleChanged(payload);
+
+          assert.equal(webinar.selfIsPanelist, false, 'self should not be a panelist');
+          assert.equal(webinar.selfIsAttendee, true, 'self should be an attendee');
+          assert.equal(webinar.canManageWebcast, false, 'self should not have manage webcast capability');
+          assert.equal(result.isPromoted, false, 'should not indicate promotion');
+          assert.equal(result.isDemoted, true, 'should indicate demotion');
+        });
+
+        it('updates roles when promoted to moderator', () => {
+          const payload = {
+            oldRoles: ['PANELIST'],
+            newRoles: ['MODERATOR']
+          };
+
+          const result = webinar.updateRoleChanged(payload);
+
+          assert.equal(webinar.selfIsPanelist, false, 'self should not be a panelist');
+          assert.equal(webinar.selfIsAttendee, false, 'self should not be an attendee');
+          assert.equal(webinar.canManageWebcast, true, 'self should have manage webcast capability');
+          assert.equal(result.isPromoted, false, 'should not indicate promotion');
+          assert.equal(result.isDemoted, false, 'should not indicate demotion');
+        });
+
+        it('updates roles when unchanged (remains as panelist)', () => {
+          const payload = {
+            oldRoles: ['PANELIST'],
+            newRoles: ['PANELIST']
+          };
+
+          const result = webinar.updateRoleChanged(payload);
+
+          assert.equal(webinar.selfIsPanelist, true, 'self should remain a panelist');
+          assert.equal(webinar.selfIsAttendee, false, 'self should not be an attendee');
+          assert.equal(webinar.canManageWebcast, false, 'self should not have manage webcast capability');
+          assert.equal(result.isPromoted, false, 'should not indicate promotion');
+          assert.equal(result.isDemoted, false, 'should not indicate demotion');
+        });
+      });
+
     })
 })