@webex/plugin-meetings 3.0.0-beta.43 → 3.0.0-beta.45

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

@@ -24,6 +24,9 @@ describe('plugin-meetings', () => {
       },
       remoteMuted: false,
       unmuteAllowed: true,
+      remoteVideoMuted: false,
+      unmuteVideoAllowed: true,
+
       locusInfo: {
         onFullLocus: sinon.stub(),
       },
@@ -75,15 +78,16 @@ describe('plugin-meetings', () => {
     });
 
     it('initialises correctly for video', async () => {
-      // setup fields related to audio remote state
-      meeting.remoteMuted = true;
-      meeting.unmuteAllowed = false;
-      // create a new video MuteState intance
+      // setup fields related to video remote state
+      meeting.remoteVideoMuted = false;
+      meeting.unmuteVideoAllowed = false;
+
+      // create a new video MuteState instance
       video = createMuteState(VIDEO, meeting, {sendVideo: true});
 
       assert.isFalse(video.isMuted());
       assert.isFalse(video.state.server.remoteMute);
-      assert.isTrue(video.state.server.unmuteAllowed);
+      assert.isFalse(video.state.server.unmuteAllowed);
     });
 
     it('takes remote mute into account when reporting current state', async () => {
@@ -167,6 +171,30 @@ describe('plugin-meetings', () => {
       assert.isFalse(audio.isSelf());
     });
 
+    it('does local video unmute if localVideoUnmuteRequired is received', async () => {
+      // first we need to mute
+      await video.handleClientRequest(meeting, true);
+
+      assert.isTrue(video.isMuted());
+      assert.isTrue(video.isSelf());
+
+      MeetingUtil.remoteUpdateAudioVideo.resetHistory();
+
+      // now simulate server requiring us to locally unmute
+      video.handleServerLocalUnmuteRequired(meeting);
+      await testUtils.flushPromises();
+
+      // check that local track was unmuted
+      assert.calledWith(meeting.mediaProperties.videoTrack.setMuted, false);
+
+      // and local unmute was sent to server
+      assert.calledOnce(MeetingUtil.remoteUpdateAudioVideo);
+      assert.calledWith(MeetingUtil.remoteUpdateAudioVideo, undefined, false, meeting);
+
+      assert.isFalse(video.isMuted());
+      assert.isFalse(video.isSelf());
+    });
+
     describe('#isLocallyMuted()', () => {
       it('does not consider remote mute status for audio', async () => {
         // simulate being already remote muted
@@ -176,6 +204,15 @@ describe('plugin-meetings', () => {
 
         assert.isFalse(audio.isLocallyMuted());
       });
+
+      it('does not consider remote mute status for video', async () => {
+        // simulate being already remote muted
+        meeting.remoteVideoMuted = true;
+        // create a new MuteState intance
+        video = createMuteState(VIDEO, meeting, {sendVideo: true});
+
+        assert.isFalse(video.isLocallyMuted());
+      });
     });
 
     describe('#handleClientRequest', () => {
@@ -238,12 +275,41 @@ describe('plugin-meetings', () => {
 
         // check that remote unmute was sent to server
         assert.calledOnce(meeting.members.muteMember);
-        assert.calledWith(meeting.members.muteMember, meeting.members.selfId, false);
+        assert.calledWith(meeting.members.muteMember, meeting.members.selfId, false, true);
 
         assert.isFalse(audio.isMuted());
         assert.isFalse(audio.isSelf());
       });
 
+      it('does video remote unmute when unmuting and remote mute is on', async () => {
+        // simulate remote mute
+        video.handleServerRemoteMuteUpdate(true, true);
+
+        // unmute
+        await video.handleClientRequest(meeting, false);
+
+        // check that remote unmute was sent to server
+        assert.calledOnce(meeting.members.muteMember);
+        assert.calledWith(meeting.members.muteMember, meeting.members.selfId, false, false);
+
+        assert.isFalse(video.isMuted());
+        assert.isFalse(video.isSelf());
+      });
+
+      it('does not video remote unmute when unmuting and remote mute is off', async () => {
+        // simulate remote mute
+        video.handleServerRemoteMuteUpdate(false, true);
+
+        // unmute
+        await video.handleClientRequest(meeting, false);
+
+        // check that remote unmute was sent to server
+        assert.notCalled(meeting.members.muteMember);
+
+        assert.isFalse(video.isMuted());
+        assert.isFalse(video.isSelf());
+      });
+
       it('resolves client request promise once the server is updated', async () => {
         let clientPromiseResolved = false;
 

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

@@ -419,5 +419,40 @@ describe('plugin-meetings', () => {
         });
       });
     });
+
+    describe('canManageBreakout', () => {
+      it('works as expected', () => {
+        assert.deepEqual(MeetingUtil.canManageBreakout(['BREAKOUT_MANAGEMENT']), true);
+        assert.deepEqual(MeetingUtil.canManageBreakout([]), false);
+      });
+    });
+
+    describe('isSuppressBreakoutSupport', () => {
+      it('works as expected', () => {
+        assert.deepEqual(MeetingUtil.isSuppressBreakoutSupport(['UCF_SUPPRESS_BREAKOUTS_SUPPORT']), true);
+        assert.deepEqual(MeetingUtil.isSuppressBreakoutSupport([]), false);
+      });
+    });
+
+    describe('canAdmitLobbyToBreakout', () => {
+      it('works as expected', () => {
+        assert.deepEqual(MeetingUtil.canAdmitLobbyToBreakout(['DISABLE_LOBBY_TO_BREAKOUT']), false);
+        assert.deepEqual(MeetingUtil.canAdmitLobbyToBreakout([]), true);
+      });
+    });
+
+    describe('canUserAskForHelp', () => {
+      it('works as expected', () => {
+        assert.deepEqual(MeetingUtil.canUserAskForHelp(['DISABLE_ASK_FOR_HELP']), false);
+        assert.deepEqual(MeetingUtil.canUserAskForHelp([]), true);
+      });
+    });
+
+    describe('isBreakoutPreassignmentsEnabled', () => {
+      it('works as expected', () => {
+        assert.deepEqual(MeetingUtil.isBreakoutPreassignmentsEnabled(['DISABLE_BREAKOUT_PREASSIGNMENTS']), false);
+        assert.deepEqual(MeetingUtil.isBreakoutPreassignmentsEnabled([]), true);
+      });
+    });
   })
 });

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

@@ -130,6 +130,81 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#admitMembers', () => {
+      let members;
+      beforeEach(() => {
+        members = createMembers({url: url1});
+        members.membersRequest.admitMember = sinon.stub().returns(Promise.resolve(true));
+      });
+      it('should return error if param memberIds is not provided', async () => {
+        let error;
+        await members.admitMembers().catch((e) => {
+          error = e;
+        });
+        assert.deepEqual(error, new ParameterError('No member ids provided to admit.'));
+      });
+
+      it('should call membersRequest.admitMember as expected', async () => {
+        await members.admitMembers(['uuid']);
+        const arg1 = members.membersRequest.admitMember.getCall(0).args[0];
+        assert.equal(arg1.sessionLocusUrls, undefined);
+        assert.equal(arg1.locusUrl.includes('https://example.com/'), true);
+        assert.deepEqual(arg1.memberIds, ['uuid']);
+
+        const sessionLocusUrls = {
+          authorizingLocusUrl: 'authorizingLocusUrl',
+          mainLocusUrl: 'mainLocusUrl',
+        };
+        await members.admitMembers(['uuid'], sessionLocusUrls);
+        const arg2 = members.membersRequest.admitMember.getCall(1).args[0];
+        assert.equal(arg2.sessionLocusUrls, sessionLocusUrls);
+        assert.equal(arg1.locusUrl.includes('https://example.com/'), true);
+        assert.deepEqual(arg1.memberIds, ['uuid']);
+      });
+    });
+
+    describe('#muteMember', () => {
+      const testMuteMember = async (mute, isAudio) => {
+        sandbox.spy(MembersUtil, 'generateMuteMemberOptions');
+
+        const locusUrl = 'locus-url';
+        const members = createMembers({url: locusUrl});
+        const {membersRequest} = members;
+        sandbox.spy(membersRequest, 'muteMember');
+
+        const memberId = 'bob';
+
+        await members.muteMember(memberId, mute, isAudio);
+        assert.calledOnce(MembersUtil.generateMuteMemberOptions);
+        assert.calledWith(
+          MembersUtil.generateMuteMemberOptions,
+          memberId,
+          mute,
+          members.locusUrl,
+          isAudio
+        );
+
+        assert.calledOnce(membersRequest.muteMember);
+        assert.calledWith(membersRequest.muteMember, {memberId, muted: mute, locusUrl, isAudio});
+      };
+
+      it('invokes expected functions when muteMember is called for mute=true, isAudio=true', async () => {
+        testMuteMember(true, true);
+      });
+
+      it('invokes expected functions when muteMember is called for mute=true, isAudio=false', async () => {
+        testMuteMember(true, false);
+      });
+
+      it('invokes expected functions when muteMember is called for mute=false, isAudio=true', async () => {
+        testMuteMember(false, true);
+      });
+
+      it('invokes expected functions when muteMember is called for mute=false, isAudio=false', async () => {
+        testMuteMember(false, false);
+      });
+    });
+
     describe('#sendDialPadKey', () => {
       it('should throw a rejection when calling sendDialPadKey with no tones', async () => {
         const members = createMembers({url: url1});

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

@@ -3,6 +3,7 @@ import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 
 import MembersUtil from '@webex/plugin-meetings/src/members/util';
+import {HTTP_VERBS, CONTROLS, PARTICIPANT} from '@webex/plugin-meetings/src/constants';
 
 const {assert} = chai;
 
@@ -38,5 +39,116 @@ describe('plugin-meetings', () => {
         );
       });
     });
+    describe('#getAdmitMemberRequestBody', () => {
+      it('returns the correct request body', () => {
+        const option1 = {memberIds: ['uuid']};
+
+        assert.deepEqual(MembersUtil.getAdmitMemberRequestBody(option1), {
+          admit: {participantIds: ['uuid']},
+        });
+
+        const option2 = {
+          memberIds: ['uuid'],
+          sessionLocusUrls: {authorizingLocusUrl: 'authorizingLocusUrl'},
+        };
+
+        assert.deepEqual(MembersUtil.getAdmitMemberRequestBody(option2), {
+          admit: {participantIds: ['uuid']},
+          authorizingLocusUrl: 'authorizingLocusUrl',
+        });
+      });
+    });
+    describe('#getAdmitMemberRequestParams', () => {
+      it('returns the correct request params', () => {
+        const format1 = {memberIds: ['uuid'], locusUrl: 'locusUrl'};
+
+        assert.deepEqual(MembersUtil.getAdmitMemberRequestParams(format1), {
+          method: 'PUT',
+          uri: 'locusUrl/controls',
+          body: {admit: {participantIds: ['uuid']}},
+        });
+
+        const format2 = {
+          memberIds: ['uuid'],
+          sessionLocusUrls: {
+            authorizingLocusUrl: 'authorizingLocusUrl',
+            mainLocusUrl: 'mainLocusUrl',
+          },
+          locusUrl: 'locusUrl',
+        };
+
+        assert.deepEqual(MembersUtil.getAdmitMemberRequestParams(format2), {
+          method: 'PUT',
+          uri: 'mainLocusUrl/controls',
+          body: {
+            admit: {participantIds: ['uuid']},
+            authorizingLocusUrl: 'authorizingLocusUrl',
+          },
+        });
+      });
+    });
+
+    describe('#generateMuteMemberOptions', () => {
+      const testOptions = (isAudio) => {
+        const memberId = 'bob';
+        const muteStatus = true;
+        const locusUrl = 'urlTest1';
+
+        assert.deepEqual(
+          MembersUtil.generateMuteMemberOptions(memberId, muteStatus, locusUrl, isAudio),
+          {
+            memberId,
+            muted: muteStatus,
+            locusUrl,
+            isAudio,
+          }
+        );
+      };
+
+      it('returns the correct options for audio', () => {
+        testOptions(true);
+      });
+
+      it('returns the correct options for video', () => {
+        testOptions(false);
+      });
+    });
+
+    describe('#getMuteMemberRequestParams', () => {
+      const testParams = (isAudio) => {
+        const memberId = 'bob';
+        const muteStatus = true;
+        const locusUrl = 'urlTest1';
+
+        const options = {
+          memberId,
+          muted: muteStatus,
+          locusUrl,
+          isAudio,
+        };
+
+        const uri = `${options.locusUrl}/${PARTICIPANT}/${options.memberId}/${CONTROLS}`;
+        const property = isAudio ? 'audio' : 'video';
+        const body = {
+          [property]: {
+            muted: options.muted,
+          },
+        };
+
+        assert.deepEqual(MembersUtil.getMuteMemberRequestParams(options), {
+          method: HTTP_VERBS.PATCH,
+          uri,
+          body,
+        });
+      };
+
+      it('returns the correct params for audio', () => {
+        testParams(true);
+      });
+
+      it('returns the correct params for video', () => {
+        testParams(false);
+      });
+    });
   });
 });

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

@@ -699,6 +699,133 @@ describe('RemoteMediaManager', () => {
       });
     });
 
+    it('releases slots and reallocates slots when switching to layouts in correct order', async () => {
+
+      const config = cloneDeep(DefaultTestConfiguration);
+      let count = 0;
+
+      fakeReceiveSlotManager.allocateSlot = sinon.stub().callsFake((mediaType) => {
+        switch (mediaType) {
+          case MediaType.AudioMain:
+            return Promise.resolve(fakeAudioSlot);
+          case MediaType.VideoMain:
+            return Promise.resolve(new FakeSlot(MediaType.VideoMain, `fake video ${count++}`));
+          case MediaType.AudioSlides:
+            return Promise.resolve(fakeScreenShareAudioSlot);
+          case MediaType.VideoSlides:
+            return Promise.resolve(fakeScreenShareVideoSlot);
+        }
+        throw new Error(`invalid mediaType: ${mediaType}`);
+      })
+
+      remoteMediaManager = new RemoteMediaManager(
+        fakeReceiveSlotManager,
+        fakeMediaRequestManagers,
+        config
+      );
+
+      await remoteMediaManager.start();
+
+      resetHistory();
+
+      assert.deepEqual(remoteMediaManager.slots.video.activeSpeaker.map((slot: any) => slot.id), [
+        "fake video 0",
+        "fake video 1",
+        "fake video 2",
+        "fake video 3",
+        "fake video 4",
+        "fake video 5",
+        "fake video 6",
+        "fake video 7",
+        "fake video 8",
+      ]);
+
+      assert.deepEqual(remoteMediaManager.receiveSlotAllocations.activeSpeaker["main"].slots.map((slot: any) => slot.id), [
+        "fake video 0",
+        "fake video 1",
+        "fake video 2",
+        "fake video 3",
+        "fake video 4",
+        "fake video 5",
+        "fake video 6",
+        "fake video 7",
+        "fake video 8",
+      ])
+
+      // switch to "OnePlusFive" layout that requires 3 less video slots (6)
+      await remoteMediaManager.setLayout('OnePlusFive');
+
+      assert.deepEqual(remoteMediaManager.slots.video.unused, []);
+
+      assert.deepEqual(remoteMediaManager.slots.video.activeSpeaker.map((slot: any) => slot.id), [
+        "fake video 0",
+        "fake video 1",
+        "fake video 2",
+        "fake video 3",
+        "fake video 4",
+        "fake video 5"
+      ]);
+
+      // we're checking that the slots are in the same order as in the previous layout
+      // first one goes into main
+      assert.deepEqual(remoteMediaManager.receiveSlotAllocations.activeSpeaker["mainBigOne"].slots.map((slot: any) => slot.id), [
+        "fake video 0",
+      ])
+      // and rest go in the pips
+      assert.deepEqual(remoteMediaManager.receiveSlotAllocations.activeSpeaker["secondarySetOfSmallPanes"].slots.map((slot: any) => slot.id), [
+        "fake video 1",
+        "fake video 2",
+        "fake video 3",
+        "fake video 4",
+        "fake video 5"
+      ])
+
+      // verify that 3 main video slots were released
+      assert.callCount(fakeReceiveSlotManager.releaseSlot, 3);
+      fakeReceiveSlotManager.releaseSlot.getCalls().forEach((call) => {
+        const slot = call.args[0];
+
+        assert.strictEqual(slot.mediaType, MediaType.VideoMain);
+      });
+
+      await remoteMediaManager.setLayout('AllEqual');
+
+      assert.deepEqual(remoteMediaManager.slots.video.unused, []);
+
+      // checking that slots are in the same order as in previous layout + 3 new ones
+      assert.deepEqual(remoteMediaManager.slots.video.activeSpeaker.map((slot: any) => slot.id), [
+        "fake video 0",
+        "fake video 1",
+        "fake video 2",
+        "fake video 3",
+        "fake video 4",
+        "fake video 5",
+        "fake video 10",
+        "fake video 11",
+        "fake video 12",
+      ]);
+
+      assert.deepEqual(remoteMediaManager.receiveSlotAllocations.activeSpeaker["main"].slots.map((slot: any) => slot.id), [
+        "fake video 0",
+        "fake video 1",
+        "fake video 2",
+        "fake video 3",
+        "fake video 4",
+        "fake video 5",
+        "fake video 10",
+        "fake video 11",
+        "fake video 12"
+      ])
+
+       // verify that 3 main video slots were allocated
+       assert.callCount(fakeReceiveSlotManager.allocateSlot, 3);
+       fakeReceiveSlotManager.allocateSlot.getCalls().forEach((call) => {
+         const mediaType = call.args[0];
+
+         assert.strictEqual(mediaType, MediaType.VideoMain);
+       });
+    });
+
     it('stops all current video remoteMedia instances when switching to new layout', async () => {
       const audioStopStubs = [];
       const videoStopStubs = [];