@webex/plugin-meetings 3.0.0-beta.7 → 3.0.0-beta.71

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

@@ -14,13 +14,14 @@ import ParameterError from '@webex/plugin-meetings/src/common/errors/parameter';
 import Meetings from '@webex/plugin-meetings';
 import Members from '@webex/plugin-meetings/src/members';
 import MembersUtil from '@webex/plugin-meetings/src/members/util';
+import Trigger from '@webex/plugin-meetings/src/common/events/trigger-proxy';
+import {EVENT_TRIGGERS} from "@webex/plugin-meetings/src/constants";
 
 const {assert} = chai;
 
 chai.use(chaiAsPromised);
 sinon.assert.expose(chai.assert, {prefix: ''});
 
-
 describe('plugin-meetings', () => {
   let webex;
   let url1;
@@ -34,37 +35,33 @@ describe('plugin-meetings', () => {
           id: '6eb08f8b-bf69-3251-a126-b161bead2d21',
           phoneNumber: '+18578675309',
           isExternal: true,
-          primaryDisplayString: '+18578675309'
+          primaryDisplayString: '+18578675309',
         },
         devices: [
           {
             url: 'https://fakeURL.com',
             deviceType: 'SIP',
             state: 'JOINED',
-            intents: [
-              null
-            ],
+            intents: [null],
             correlationId: '1234',
             provisionalUrl: 'dialout:///fake',
-            isSparkPstn: true
+            isSparkPstn: true,
           },
           {
             url: 'dialout:///fakeagain',
             deviceType: 'PROVISIONAL',
             state: 'JOINED',
-            intents: [
-              null
-            ],
+            intents: [null],
             correlationId: '4321',
             isVideoCallback: false,
             clientUrl: 'https://fakeURL',
             provisionalType: 'DIAL_OUT_ONLY',
-            dialingStatus: 'SUCCESS'
-          }
+            dialingStatus: 'SUCCESS',
+          },
         ],
         status: {
           audioStatus: 'SENDRECV',
-          videoStatus: 'INACTIVE'
+          videoStatus: 'INACTIVE',
         },
         id: 'abc-123-abc-123',
         guest: true,
@@ -72,16 +69,15 @@ describe('plugin-meetings', () => {
         moderator: false,
         panelist: false,
         moveToLobbyNotAllowed: true,
-        deviceUrl: 'https://fakeDeviceurl'
+        deviceUrl: 'https://fakeDeviceurl',
       },
       id: 'abc-123-abc-123',
       status: 'IN_MEETING',
       type: 'MEETING',
-      isModerator: false
-    }
+      isModerator: false,
+    },
   };
 
-
   describe('members', () => {
     const sandbox = sinon.createSandbox();
     let createMembers;
@@ -91,21 +87,21 @@ describe('plugin-meetings', () => {
         children: {
           meetings: Meetings,
           credentials: Credentials,
-          support: Support
+          support: Support,
         },
         config: {
           credentials: {
-            client_id: 'mock-client-id'
+            client_id: 'mock-client-id',
           },
           meetings: {
             reconnection: {
-              enabled: false
+              enabled: false,
             },
             mediaSettings: {},
             metrics: {},
-            stats: {}
-          }
-        }
+            stats: {},
+          },
+        },
       });
 
       url1 = `https://example.com/${uuid.v4()}`;
@@ -136,6 +132,117 @@ 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('#clearMembers', () => {
+      it('should send clear event if clear members', () => {
+        const members = createMembers({url: url1});
+        members.membersCollection.setAll(fakeMembersCollection);
+        Trigger.trigger = sinon.stub();
+        members.clearMembers();
+        assert.deepEqual(members.membersCollection.members, {});
+        assert.calledWith(Trigger.trigger, members, {
+          file: 'members',
+          function: 'clearMembers',
+        }, EVENT_TRIGGERS.MEMBERS_CLEAR, {})
+      });
+    });
+    describe('#locusParticipantsUpdate', () => {
+      it('should send member update event with session info', () => {
+        const members = createMembers({url: url1});
+        Trigger.trigger = sinon.stub();
+        const fakePayload = {
+          participants: {
+            forEach: sinon.stub(),
+          },
+          isReplace: true,
+        };
+
+        members.locusParticipantsUpdate(fakePayload);
+
+        assert.calledWith(Trigger.trigger, members, {
+          file: 'members',
+          function: 'locusParticipantsUpdate',
+        }, EVENT_TRIGGERS.MEMBERS_UPDATE, {
+          delta: {added: [], updated: []},
+          full: {},
+          isReplace: true,
+        })
+      });
+    });
     describe('#sendDialPadKey', () => {
       it('should throw a rejection when calling sendDialPadKey with no tones', async () => {
         const members = createMembers({url: url1});
@@ -155,7 +262,13 @@ describe('plugin-meetings', () => {
 
         members.membersCollection.setAll(fakeMembersCollection);
         await members.sendDialPadKey('1', 'test1');
-        assert.calledWith(MembersUtil.genderateSendDTMFOptions, 'https://fakeURL.com', '1', 'test1', url1);
+        assert.calledWith(
+          MembersUtil.genderateSendDTMFOptions,
+          'https://fakeURL.com',
+          '1',
+          'test1',
+          url1
+        );
       });
 
       it('should call the sendDialPadKey method on membersRequest if the member is valid', async () => {
@@ -191,12 +304,92 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#assignRoles', () => {
+      const setup = (locusUrl) => {
+        const members = createMembers({url: locusUrl});
+
+        const spies = {
+          generateRoleAssignmentMemberOptions: sandbox.spy(
+            MembersUtil,
+            'generateRoleAssignmentMemberOptions'
+          ),
+          assignRolesMember: sandbox.spy(members.membersRequest, 'assignRolesMember'),
+        };
+
+        return {members, spies};
+      };
+
+      const checkInvalid = async (resultPromise, expectedMessage, spies) => {
+        await assert.isRejected(resultPromise, ParameterError, expectedMessage);
+        assert.notCalled(spies.generateRoleAssignmentMemberOptions);
+        assert.notCalled(spies.assignRolesMember);
+      };
+
+      const checkValid = async (
+        resultPromise,
+        spies,
+        expectedMemberId,
+        expectedRoles,
+        expectedLocusUrl
+      ) => {
+        await assert.isFulfilled(resultPromise);
+        assert.calledOnceWithExactly(
+          spies.generateRoleAssignmentMemberOptions,
+          expectedMemberId,
+          expectedRoles,
+          expectedLocusUrl
+        );
+        assert.calledOnceWithExactly(spies.assignRolesMember, {
+          memberId: expectedMemberId,
+          roles: expectedRoles,
+          locusUrl: expectedLocusUrl,
+        });
+        assert.strictEqual(resultPromise, spies.assignRolesMember.getCall(0).returnValue);
+      };
+
+      it('should not make a request if there is no member id', async () => {
+        const {members, spies} = setup(url1);
+
+        const resultPromise = members.assignRoles();
+
+        await checkInvalid(
+          resultPromise,
+          'The member id must be defined to assign the roles to a member.',
+          spies
+        );
+      });
+
+      it('should not make a request if there is no locus url', async () => {
+        const {members, spies} = setup();
+
+        const resultPromise = members.assignRoles(uuid.v4());
+
+        await checkInvalid(
+          resultPromise,
+          'The associated locus url for this meetings members object must be defined.',
+          spies
+        );
+      });
+
+      it('should make the correct request when called with roles', async () => {
+        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}]);
+
+        await checkValid(resultPromise, spies, memberId, [{type: 'PRESENTER', hasRole: true}, {type: 'MODERATOR', hasRole: false}, {type: 'COHOST', hasRole: true}], url1);
+      });
+    });
+
     describe('#raiseOrLowerHand', () => {
       const setup = (locusUrl) => {
         const members = createMembers({url: locusUrl});
 
         const spies = {
-          generateRaiseHandMemberOptions: sandbox.spy(MembersUtil, 'generateRaiseHandMemberOptions'),
+          generateRaiseHandMemberOptions: sandbox.spy(
+            MembersUtil,
+            'generateRaiseHandMemberOptions'
+          ),
           raiseOrLowerHandMember: sandbox.spy(members.membersRequest, 'raiseOrLowerHandMember'),
         };
 
@@ -209,10 +402,25 @@ describe('plugin-meetings', () => {
         assert.notCalled(spies.raiseOrLowerHandMember);
       };
 
-      const checkValid = async (resultPromise, spies, expectedMemberId, expectedRaise, expectedLocusUrl) => {
+      const checkValid = async (
+        resultPromise,
+        spies,
+        expectedMemberId,
+        expectedRaise,
+        expectedLocusUrl
+      ) => {
         await assert.isFulfilled(resultPromise);
-        assert.calledOnceWithExactly(spies.generateRaiseHandMemberOptions, expectedMemberId, expectedRaise, expectedLocusUrl);
-        assert.calledOnceWithExactly(spies.raiseOrLowerHandMember, {memberId: expectedMemberId, raised: expectedRaise, locusUrl: expectedLocusUrl});
+        assert.calledOnceWithExactly(
+          spies.generateRaiseHandMemberOptions,
+          expectedMemberId,
+          expectedRaise,
+          expectedLocusUrl
+        );
+        assert.calledOnceWithExactly(spies.raiseOrLowerHandMember, {
+          memberId: expectedMemberId,
+          raised: expectedRaise,
+          locusUrl: expectedLocusUrl,
+        });
         assert.strictEqual(resultPromise, spies.raiseOrLowerHandMember.getCall(0).returnValue);
       };
 
@@ -221,7 +429,11 @@ describe('plugin-meetings', () => {
 
         const resultPromise = members.raiseOrLowerHand();
 
-        await checkInvalid(resultPromise, 'The member id must be defined to raise/lower the hand of the member.', spies);
+        await checkInvalid(
+          resultPromise,
+          'The member id must be defined to raise/lower the hand of the member.',
+          spies
+        );
       });
 
       it('should not make a request if there is no locus url', async () => {
@@ -229,7 +441,11 @@ describe('plugin-meetings', () => {
 
         const resultPromise = members.raiseOrLowerHand(uuid.v4());
 
-        await checkInvalid(resultPromise, 'The associated locus url for this meetings members object must be defined.', spies);
+        await checkInvalid(
+          resultPromise,
+          'The associated locus url for this meetings members object must be defined.',
+          spies
+        );
       });
 
       it('should make the correct request when called with raise as true', async () => {
@@ -265,7 +481,10 @@ describe('plugin-meetings', () => {
         const members = createMembers({url: locusUrl});
 
         const spies = {
-          generateLowerAllHandsMemberOptions: sandbox.spy(MembersUtil, 'generateLowerAllHandsMemberOptions'),
+          generateLowerAllHandsMemberOptions: sandbox.spy(
+            MembersUtil,
+            'generateLowerAllHandsMemberOptions'
+          ),
           lowerAllHandsMember: sandbox.spy(members.membersRequest, 'lowerAllHandsMember'),
         };
 
@@ -278,10 +497,22 @@ describe('plugin-meetings', () => {
         assert.notCalled(spies.lowerAllHandsMember);
       };
 
-      const checkValid = async (resultPromise, spies, expectedRequestingMemberId, expectedLocusUrl) => {
+      const checkValid = async (
+        resultPromise,
+        spies,
+        expectedRequestingMemberId,
+        expectedLocusUrl
+      ) => {
         await assert.isFulfilled(resultPromise);
-        assert.calledOnceWithExactly(spies.generateLowerAllHandsMemberOptions, expectedRequestingMemberId, expectedLocusUrl);
-        assert.calledOnceWithExactly(spies.lowerAllHandsMember, {requestingParticipantId: expectedRequestingMemberId, locusUrl: expectedLocusUrl});
+        assert.calledOnceWithExactly(
+          spies.generateLowerAllHandsMemberOptions,
+          expectedRequestingMemberId,
+          expectedLocusUrl
+        );
+        assert.calledOnceWithExactly(spies.lowerAllHandsMember, {
+          requestingParticipantId: expectedRequestingMemberId,
+          locusUrl: expectedLocusUrl,
+        });
         assert.strictEqual(resultPromise, spies.lowerAllHandsMember.getCall(0).returnValue);
       };
 
@@ -290,7 +521,11 @@ describe('plugin-meetings', () => {
 
         const resultPromise = members.lowerAllHands();
 
-        await checkInvalid(resultPromise, 'The requestingMemberId must be defined to lower all hands in a meeting.', spies);
+        await checkInvalid(
+          resultPromise,
+          'The requestingMemberId must be defined to lower all hands in a meeting.',
+          spies
+        );
       });
 
       it('should not make a request if there is no locus url', async () => {
@@ -298,7 +533,11 @@ describe('plugin-meetings', () => {
 
         const resultPromise = members.lowerAllHands(uuid.v4());
 
-        await checkInvalid(resultPromise, 'The associated locus url for this meetings members object must be defined.', spies);
+        await checkInvalid(
+          resultPromise,
+          'The associated locus url for this meetings members object must be defined.',
+          spies
+        );
       });
 
       it('should make the correct request when called with requestingMemberId', async () => {
@@ -317,13 +556,12 @@ describe('plugin-meetings', () => {
       // fake collection that contains all combinations of members data structure (with respect to CSIs)
       const fakeCollection = {
         oneWithoutDevices: {
-          participant: {
-          }
+          participant: {},
         },
         oneWithEmptyDevices: {
           participant: {
             devices: [],
-          }
+          },
         },
         oneWithDevicesWithoutCsis: {
           participant: {
@@ -338,7 +576,7 @@ describe('plugin-meetings', () => {
                 url: 'dialout:///fakeagain',
                 deviceType: 'PROVISIONAL',
                 state: 'JOINED',
-              }
+              },
             ],
           },
           id: 'abc-123-abc-123',
@@ -358,10 +596,10 @@ describe('plugin-meetings', () => {
                 deviceType: 'SIP',
                 state: 'JOINED',
                 csis: [2000, 2001, 2002],
-              }
-            ]
-          }
-        }
+              },
+            ],
+          },
+        },
       };
 
       beforeEach(() => {
@@ -392,14 +630,13 @@ describe('plugin-meetings', () => {
         },
         oneWithoutDevices: {
           id: 'oneWithoutDevices',
-          participant: {
-          }
+          participant: {},
         },
         oneWithEmptyDevices: {
           id: 'oneWithEmptyDevices',
           participant: {
             devices: [],
-          }
+          },
         },
         oneWithDevicesWithoutCsis: {
           id: 'oneWithDevicesWithoutCsis',
@@ -415,7 +652,7 @@ describe('plugin-meetings', () => {
                 url: 'dialout:///fakeagain',
                 deviceType: 'PROVISIONAL',
                 state: 'JOINED',
-              }
+              },
             ],
           },
           status: 'IN_MEETING',
@@ -431,7 +668,7 @@ describe('plugin-meetings', () => {
                 mediaSessions: [
                   {mediaType: 'audio', mediaContent: 'main', csi: 1000},
                   {mediaType: 'video', mediaContent: 'main', csi: 1001},
-                  {mediaType: 'video', mediaContent: 'content', csi: 1002}
+                  {mediaType: 'video', mediaContent: 'content', csi: 1002},
                 ],
               },
               {
@@ -441,12 +678,12 @@ describe('plugin-meetings', () => {
                 mediaSessions: [
                   {mediaType: 'audio', mediaContent: 'main', csi: 2000},
                   {mediaType: 'video', mediaContent: 'main', csi: 2001},
-                  {mediaType: 'video', mediaContent: 'content', csi: 2002}
+                  {mediaType: 'video', mediaContent: 'content', csi: 2002},
                 ],
-              }
-            ]
-          }
-        }
+              },
+            ],
+          },
+        },
       };
 
       beforeEach(() => {
@@ -470,7 +707,10 @@ describe('plugin-meetings', () => {
       });
 
       it('returns correct CSI values when there is a match', () => {
-        assert.deepEqual(members.getCsisForMember('oneWithSomeCsis', 'video', 'main'), [1001, 2001]);
+        assert.deepEqual(
+          members.getCsisForMember('oneWithSomeCsis', 'video', 'main'),
+          [1001, 2001]
+        );
       });
     });
   });