@webex/plugin-meetings 3.0.0-stream-classes.4 → 3.0.0-test.1

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

@@ -162,9 +162,24 @@ describe('plugin-meetings', () => {
     });
 
     describe("#handleRoapMercury", () => {
-      it('it sends the correct behaviour metric', () => {
-        const roapMessageReceived = sinon.stub();
-        const envelope = {
+      let envelope;
+      let meetingCollection;
+      let roapMessageReceived;
+      let handleTurnDiscoveryResponse;
+      let meeting;
+
+      beforeEach(() => {
+        roapMessageReceived = sinon.stub();
+        handleTurnDiscoveryResponse = sinon.stub();
+
+        meeting = {
+          id: 'meeting-id',
+          roapMessageReceived,
+          roap: {
+            turnDiscovery: {handleTurnDiscoveryResponse}
+          }
+        };
+        envelope = {
           data: {
             message:{
               seq: "seq",
@@ -178,17 +193,12 @@ describe('plugin-meetings', () => {
             eventType: 'locus.message.roap',
           }
         };
-        const meetingCollection = {
-          getByKey: () => ({
-            id: 'meeting-id',
-            mediaProperties: {
-              webrtcMediaConnection: {
-                roapMessageReceived
-              }
-            }
-          })
+        meetingCollection = {
+          getByKey: () => meeting
         };
+      });
 
+      it('it sends the correct behaviour metric', () => {
         MeetingsUtil.handleRoapMercury(envelope, meetingCollection);
         assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.ROAP_MERCURY_EVENT_RECEIVED,  {
           correlation_id: 'correlationId',
@@ -207,6 +217,19 @@ describe('plugin-meetings', () => {
         })
 
       });
+
+      it('calls handleTurnDiscoveryResponse for TURN_DISCOVERY_RESPONSE', () => {
+        envelope.data.message.messageType = 'TURN_DISCOVERY_RESPONSE';
+        delete envelope.data.message.sdps;
+        MeetingsUtil.handleRoapMercury(envelope, meetingCollection);
+        assert.calledWith(meeting.roap.turnDiscovery.handleTurnDiscoveryResponse, {
+          seq: "seq",
+          messageType: 'TURN_DISCOVERY_RESPONSE',
+          errorType: 'errorType',
+          tieBreaker: 'tieBreaker',
+          errorCause: 'errorCause',
+        }, 'from mercury')
+      });
     })
   });
 

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

@@ -17,13 +17,7 @@ describe('member', () => {
     assert.exists(member.supportsInterpretation);
     assert.exists(member.supportsBreakouts);
     assert.exists(member.supportLiveAnnotation);
-  });
-
-  it('checks that processParticipant calls isHandRaised', () => {
-    sinon.spy(MemberUtil, 'isHandRaised');
-    member.processParticipant(participant);
-
-    assert.calledOnceWithExactly(MemberUtil.isHandRaised, participant);
+    assert.exists(member.canReclaimHost);
   });
 
   describe('roles', () => {
@@ -49,6 +43,13 @@ describe('member', () => {
 
       assert.calledOnceWithExactly(MemberUtil.isHandRaised, participant);
     });
+
+    it('checks that processParticipant calls canReclaimHost', () => {
+      sinon.spy(MemberUtil, 'canReclaimHost');
+      member.processParticipant(participant);
+  
+      assert.calledOnceWithExactly(MemberUtil.canReclaimHost, participant);
+    });
   })
 
   describe('#processMember', () => {

package/test/unit/spec/member/util.js

@@ -50,6 +50,38 @@ describe('plugin-meetings', () => {
     });
   });
 
+  describe('MemberUtil.canReclaimHost', () => {
+    it('throws error when there is no participant', () => {
+      assert.throws(() => {
+        MemberUtil.canReclaimHost();
+      }, 'canReclaimHostRole could not be processed, participant is undefined.');
+    });
+
+    it('returns true when canReclaimHostRole is true', () => {
+      const participant = {
+        canReclaimHostRole: true,
+      };
+
+      assert.isTrue(MemberUtil.canReclaimHost(participant));
+    });
+
+    it('returns false when canReclaimHostRole is false', () => {
+      const participant = {
+        canReclaimHostRole: false,
+      };
+
+      assert.isFalse(MemberUtil.canReclaimHost(participant));
+    });
+
+    it('returns false when canReclaimHostRole is falsy', () => {
+      const participant = {
+        canReclaimHostRole: undefined,
+      };
+
+      assert.isFalse(MemberUtil.canReclaimHost(participant));
+    });
+  });
+
   describe('MemberUtil.extractControlRoles', () => {
     it('happy path extract control roles', () => {
       const participant = {

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

@@ -17,6 +17,12 @@ import MembersUtil from '@webex/plugin-meetings/src/members/util';
 import * as MembersRequestImport from '@webex/plugin-meetings/src/members/request';
 import Trigger from '@webex/plugin-meetings/src/common/events/trigger-proxy';
 import {EVENT_TRIGGERS} from '@webex/plugin-meetings/src/constants';
+import {
+  ReclaimHostEmptyWrongKeyError,
+  ReclaimHostIsHostAlreadyError,
+  ReclaimHostNotAllowedError,
+  ReclaimHostNotSupportedError,
+} from '../../../../src/common/errors/reclaim-host-role-errors';
 
 const {assert} = chai;
 
@@ -337,7 +343,17 @@ describe('plugin-meetings', () => {
     });
 
     describe('#assignRoles', () => {
-      const setup = (locusUrl) => {
+      const fakeRoles = [
+        {type: 'PRESENTER', hasRole: true},
+        {type: 'MODERATOR', hasRole: false},
+        {type: 'COHOST', hasRole: true},
+      ];
+
+      const resolvedValue = "it worked";
+
+      const genericMessage = 'Generic error from the API';
+
+      const setup = (locusUrl, errorCode) => {
         const members = createMembers({url: locusUrl});
 
         const spies = {
@@ -345,9 +361,14 @@ describe('plugin-meetings', () => {
             MembersUtil,
             'generateRoleAssignmentMemberOptions'
           ),
-          assignRolesMember: sandbox.spy(members.membersRequest, 'assignRolesMember'),
         };
 
+        if (errorCode) {
+          spies.assignRolesMember = sandbox.stub(members.membersRequest, 'assignRolesMember').rejects({body: {errorCode}, message: genericMessage});
+        } else {
+          spies.assignRolesMember = sandbox.stub(members.membersRequest, 'assignRolesMember').resolves(resolvedValue);
+        }
+
         return {members, spies};
       };
 
@@ -357,6 +378,21 @@ describe('plugin-meetings', () => {
         assert.notCalled(spies.assignRolesMember);
       };
 
+      const checkError = async (error, expectedMemberId, expectedRoles, expectedLocusUrl, resultPromise, expectedMessage, spies) => {
+        await assert.isRejected(resultPromise, error, expectedMessage);
+        assert.calledOnceWithExactly(
+          spies.generateRoleAssignmentMemberOptions,
+          expectedMemberId,
+          expectedRoles,
+          expectedLocusUrl
+        );
+        assert.calledOnceWithExactly(spies.assignRolesMember, {
+          memberId: expectedMemberId,
+          roles: expectedRoles,
+          locusUrl: expectedLocusUrl,
+        });
+      };
+
       const checkValid = async (
         resultPromise,
         spies,
@@ -364,7 +400,7 @@ describe('plugin-meetings', () => {
         expectedRoles,
         expectedLocusUrl
       ) => {
-        await assert.isFulfilled(resultPromise);
+        const resolvedValue = await assert.isFulfilled(resultPromise);
         assert.calledOnceWithExactly(
           spies.generateRoleAssignmentMemberOptions,
           expectedMemberId,
@@ -376,7 +412,7 @@ describe('plugin-meetings', () => {
           roles: expectedRoles,
           locusUrl: expectedLocusUrl,
         });
-        assert.strictEqual(resultPromise, spies.assignRolesMember.getCall(0).returnValue);
+        assert.strictEqual(resolvedValue, resolvedValue);
       };
 
       it('should not make a request if there is no member id', async () => {
@@ -387,7 +423,7 @@ describe('plugin-meetings', () => {
         await checkInvalid(
           resultPromise,
           'The member id must be defined to assign the roles to a member.',
-          spies
+          spies,
         );
       });
 
@@ -399,7 +435,92 @@ describe('plugin-meetings', () => {
         await checkInvalid(
           resultPromise,
           'The associated locus url for this meetings members object must be defined.',
-          spies
+          spies,
+        );
+      });
+
+      it('should not make a request if locus throws ReclaimHostNotSupportedError', async () => {
+        const memberId = uuid.v4();
+        const {members, spies} = setup(url1, 2400127);
+
+        const resultPromise = members.assignRoles(memberId, fakeRoles);
+
+        await checkError(
+          ReclaimHostNotSupportedError,
+          memberId,
+          fakeRoles,
+          url1,
+          resultPromise,
+          'Non converged meetings, PSTN or SIP users in converged meetings are not supported currently.',
+          spies,
+        );
+      });
+
+      it('should not make a request if locus throws ReclaimHostNotAllowedError', async () => {
+        const memberId = uuid.v4();
+        const {members, spies} = setup(url1, 2403135);
+
+        const resultPromise = members.assignRoles(memberId, fakeRoles);
+
+        await checkError(
+          ReclaimHostNotAllowedError,
+          memberId,
+          fakeRoles,
+          url1,
+          resultPromise,
+          'Reclaim Host Role Not Allowed For Other Participants. Participants cannot claim host role in PMR meeting, space instant meeting or escalated instant meeting. However, the original host still can reclaim host role when it manually makes another participant to be the host.',
+          spies,
+        );
+      });
+
+      it('should not make a request if locus throws ReclaimHostEmptyWrongKeyError', async () => {
+        const memberId = uuid.v4();
+        const {members, spies} = setup(url1, 2403136);
+
+        const resultPromise = members.assignRoles(memberId, fakeRoles);
+
+        await checkError(
+          ReclaimHostEmptyWrongKeyError,
+          memberId,
+          fakeRoles,
+          url1,
+          resultPromise,
+          'Host Key Not Specified Or Matched. The original host can reclaim the host role without entering the host key. However, any other person who claims the host role must enter the host key to get it.',
+          spies,
+        );
+      });
+
+      it('should not make a request if locus throws ReclaimHostIsHostAlreadyError', async () => {
+        const memberId = uuid.v4();
+        const {members, spies} = setup(url1, 2409150);
+
+        const resultPromise = members.assignRoles(memberId, fakeRoles);
+
+        await checkError(
+          ReclaimHostIsHostAlreadyError,
+          memberId,
+          fakeRoles,
+          url1,
+          resultPromise,
+          'Participant Having Host Role Already. Participant who sends request to reclaim host role has already a host role.',
+          spies,
+        );
+      });
+
+      it('should not make a request if locus throws a different error', async () => {
+        const memberId = uuid.v4();
+        const {members, spies} = setup(url1, 1234);
+
+        const resultPromise = members.assignRoles(memberId, fakeRoles);
+
+        await checkError(
+          {body: {errorCode: 1234}, message: genericMessage},
+          memberId,
+          fakeRoles,
+          url1,
+          resultPromise,
+          genericMessage,
+          spies,
         );
       });
 
@@ -407,22 +528,14 @@ describe('plugin-meetings', () => {
         const memberId = uuid.v4();
         const {members, spies} = setup(url1);
 
-        const resultPromise = members.assignRoles(memberId, [
-          {type: 'PRESENTER', hasRole: true},
-          {type: 'MODERATOR', hasRole: false},
-          {type: 'COHOST', hasRole: true},
-        ]);
+        const resultPromise = members.assignRoles(memberId, fakeRoles);
 
         await checkValid(
           resultPromise,
           spies,
           memberId,
-          [
-            {type: 'PRESENTER', hasRole: true},
-            {type: 'MODERATOR', hasRole: false},
-            {type: 'COHOST', hasRole: true},
-          ],
-          url1
+          fakeRoles,
+          url1,
         );
       });
     });

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

@@ -59,6 +59,32 @@ describe('plugin-meetings', () => {
           },
         });
       });
+
+      it('returns the correct request params with a hostKey', () => {
+        const format = {
+          locusUrl: 'locusUrl',
+          memberId: 'test',
+          roles: [
+            {type: 'PRESENTER', hasRole: true, hostKey: '123456'},
+            {type: 'MODERATOR', hasRole: false, hostKey: '123456'},
+            {type: 'COHOST', hasRole: true, hostKey: '123456'},
+          ],
+        };
+
+        assert.deepEqual(MembersUtil.getRoleAssignmentMemberRequestParams(format), {
+          method: 'PATCH',
+          uri: `locusUrl/${PARTICIPANT}/test/${CONTROLS}`,
+          body: {
+            role: {
+              roles: [
+                {type: 'PRESENTER', hasRole: true, hostKey: '123456'},
+                {type: 'MODERATOR', hasRole: false, hostKey: '123456'},
+                {type: 'COHOST', hasRole: true, hostKey: '123456'},
+              ],
+            },
+          },
+        });
+      });
     });
 
     describe('#generateRaiseHandMemberOptions', () => {

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

@@ -14,6 +14,7 @@ type ExpectedActiveSpeaker = {
   receiveSlots: Array<ReceiveSlot>;
   maxFs?: number;
   maxMbps?: number;
+  namedMediaGroups?:[{type: number, value: number}];
 };
 type ExpectedReceiverSelected = {
   policy: 'receiver-selected';
@@ -80,7 +81,7 @@ describe('MediaRequestManager', () => {
   });
 
   // helper function for adding an active speaker request
-  const addActiveSpeakerRequest = (priority, receiveSlots, maxFs, commit = false, preferLiveVideo = true) =>
+  const addActiveSpeakerRequest = (priority, receiveSlots, maxFs, commit = false, preferLiveVideo = true, namedMediaGroups = undefined) =>
     mediaRequestManager.addRequest(
       {
         policyInfo: {
@@ -89,6 +90,7 @@ describe('MediaRequestManager', () => {
           crossPriorityDuplication: CROSS_PRIORITY_DUPLICATION,
           crossPolicyDuplication: CROSS_POLICY_DUPLICATION,
           preferLiveVideo,
+          namedMediaGroups,
         },
         receiveSlots,
         codecInfo: {
@@ -590,7 +592,14 @@ describe('MediaRequestManager', () => {
       MAX_FS_720p,
       false
     );
-
+    addActiveSpeakerRequest(
+      254,
+      [fakeReceiveSlots[8], fakeReceiveSlots[9], fakeReceiveSlots[10]],
+      MAX_FS_720p,
+      false,
+      true,
+      [{type: 1, value: 20}],
+    );
     // nothing should be sent out as we didn't commit the requests
     assert.notCalled(sendMediaRequestsCallback);
 
@@ -631,6 +640,15 @@ describe('MediaRequestManager', () => {
         maxFs: MAX_FS_720p,
         maxMbps: MAX_MBPS_720p,
       },
+      {
+        policy: 'active-speaker',
+        priority: 254,
+        receiveSlots: [fakeWcmeSlots[8], fakeWcmeSlots[9], fakeWcmeSlots[10]],
+        maxPayloadBitsPerSecond: MAX_PAYLOADBITSPS_720p,
+        maxFs: MAX_FS_720p,
+        maxMbps: MAX_MBPS_720p,
+        namedMediaGroups: [{type: 1, value: 20}],
+      },
     ]);
   });
 

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

@@ -6,6 +6,7 @@ import {RemoteMedia} from '@webex/plugin-meetings/src/multistream/remoteMedia';
 import {ReceiveSlot} from '@webex/plugin-meetings/src/multistream/receiveSlot';
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
+import { NamedMediaGroup } from "@webex/json-multistream";
 
 class FakeSlot extends EventEmitter {
   public mediaType: MediaType;
@@ -24,6 +25,7 @@ describe('RemoteMediaGroup', () => {
 
   let fakeMediaRequestManager;
   let fakeReceiveSlots;
+  let fakeNamedMediaSlots;
 
   let activeSpeakerRequestCounter;
   let receiverSelectedRequestCounter;
@@ -50,6 +52,10 @@ describe('RemoteMediaGroup', () => {
     fakeReceiveSlots = Array(NUM_SLOTS)
       .fill(null)
       .map((_, index) => new FakeSlot(MediaType.VideoMain, `fake receive slot ${index}`));
+
+    fakeNamedMediaSlots = Array(1)
+      .fill(null)
+      .map((_, index) => new FakeSlot(MediaType.AudioMain, `fake named media receive slot ${index}`));
   });
 
   const getLastActiveSpeakerRequestId = () =>
@@ -144,6 +150,79 @@ describe('RemoteMediaGroup', () => {
 
   });
 
+  describe('setNamedMediaGroup', () => {
+    it('updates named media group', () => {
+
+      const nameGroup1 = { type: 1, value: 20 };
+      const nameGroup2 = { type: 1, value: 24 };
+      const group = new RemoteMediaGroup(fakeMediaRequestManager, fakeNamedMediaSlots, 255, true, {
+        namedMediaGroup: nameGroup1,
+      });
+      fakeMediaRequestManager.addRequest.resetHistory();
+      group.setNamedMediaGroup(nameGroup2, false);
+
+      assert.calledOnce(fakeMediaRequestManager.cancelRequest);
+
+      assert.calledOnce(fakeMediaRequestManager.addRequest);
+
+      assert.calledWith(
+        fakeMediaRequestManager.addRequest,
+        sinon.match({
+          policyInfo: sinon.match({
+            policy: 'active-speaker',
+            priority: 255,
+            namedMediaGroups: sinon.match([{type: 1, value: 24}]),
+          }),
+          receiveSlots: fakeNamedMediaSlots,
+          codecInfo: undefined,
+        }),
+        false,
+      );
+    });
+
+    it('does not call add request when named media group has not changed', () => {
+      const group = new RemoteMediaGroup(fakeMediaRequestManager, fakeNamedMediaSlots, 255, true, {
+        namedMediaGroup: { type: 1, value: 20 },
+      });
+      fakeMediaRequestManager.addRequest.resetHistory();
+      group.setNamedMediaGroup({ type: 1, value: 20 }, false);
+
+      assert.notCalled(fakeMediaRequestManager.cancelRequest);
+
+      assert.notCalled(fakeMediaRequestManager.addRequest);
+    });
+
+    it('remove named media group', () => {
+
+      const nameGroup1 = { type: 1, value: 20 };
+      const nameGroup2 = { type: 1, value: 0 };
+      const group = new RemoteMediaGroup(fakeMediaRequestManager, fakeNamedMediaSlots, 255, true, {
+        namedMediaGroup: nameGroup1,
+      });
+      fakeMediaRequestManager.addRequest.resetHistory();
+      group.setNamedMediaGroup(nameGroup2, true);
+
+      assert.calledOnce(fakeMediaRequestManager.cancelRequest);
+
+      assert.calledOnce(fakeMediaRequestManager.addRequest);
+
+      assert.calledWith(
+        fakeMediaRequestManager.addRequest,
+        sinon.match({
+          policyInfo: sinon.match({
+            policy: 'active-speaker',
+            priority: 255,
+            nameMediaGroups: undefined,
+          }),
+          receiveSlots: fakeNamedMediaSlots,
+          codecInfo: undefined,
+        }),
+        true,
+      );
+    });
+
+  });
+
   describe('setActiveSpeakerCsis', () => {
     it('checks when there is a csi and remote media is not in pinned array', () => {
       const PINNED_INDEX = 2;
@@ -251,7 +330,7 @@ describe('RemoteMediaGroup', () => {
       assert.strictEqual(group.getRemoteMedia('pinned').length, 1);
 
       assert.strictEqual(group.isPinned(remoteMedia), true);
-      
+
       assert.calledTwice(fakeMediaRequestManager.cancelRequest);
       assert.calledWith(fakeMediaRequestManager.cancelRequest, 'fake receiver selected request 1');