@webex/plugin-meetings 3.0.0-beta.28 → 3.0.0-beta.280

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

@@ -14,6 +14,9 @@ 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 * 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';
 
 const {assert} = chai;
 
@@ -79,6 +82,8 @@ describe('plugin-meetings', () => {
   describe('members', () => {
     const sandbox = sinon.createSandbox();
     let createMembers;
+    let meeting;
+    let membersRequestSpy;
 
     beforeEach(() => {
       webex = new MockWebex({
@@ -104,13 +109,31 @@ describe('plugin-meetings', () => {
 
       url1 = `https://example.com/${uuid.v4()}`;
 
-      createMembers = (options) => new Members({locusUrl: options.url}, {parent: webex});
+      membersRequestSpy = sinon.spy(MembersRequestImport, 'default');
+
+      meeting = {
+        request: sinon.mock().returns(Promise.resolve()),
+        locusInfo: {
+          sequence: {}
+        }
+      }
+
+      createMembers = (options) => new Members({locusUrl: options.url, meeting}, {parent: webex});
     });
 
     afterEach(() => {
+      membersRequestSpy.restore();
       sandbox.restore();
     });
 
+    describe('constructor', () => {
+      it('passes the meeting to the MembersRequest', () => {
+        createMembers({});
+
+        assert.calledOnceWithExactly(membersRequestSpy, {meeting}, {parent: webex});
+      });
+    });
+
     describe('#addMembers', () => {
       it('should invoke isInvalidInvitee and generateAddMemberOptions from MembersUtil when addMember is called with valid params', async () => {
         sandbox.spy(MembersUtil, 'isInvalidInvitee');
@@ -130,6 +153,128 @@ 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);
+        sinon.stub(Trigger, 'trigger');
+        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});
+        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});
@@ -191,6 +336,97 @@ 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});
@@ -360,6 +596,88 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#editDisplayName', () => {
+      const setup = (locusUrl) => {
+        const members = createMembers({url: locusUrl});
+
+        const spies = {
+          generateEditDisplayNameMemberOptions: sandbox.spy(
+            MembersUtil,
+            'generateEditDisplayNameMemberOptions'
+          ),
+          editDisplayNameMember: sandbox.spy(members.membersRequest, 'editDisplayNameMember'),
+        };
+
+        return {members, spies};
+      };
+
+      const checkInvalid = async (resultPromise, expectedMessage, spies) => {
+        await assert.isRejected(resultPromise, ParameterError, expectedMessage);
+        assert.notCalled(spies.generateEditDisplayNameMemberOptions);
+        assert.notCalled(spies.editDisplayNameMember);
+      };
+
+      const checkValid = async (
+        resultPromise,
+        spies,
+        expectedMemberId,
+        expectedRequestingParticipantId,
+        expectedAlias,
+        expectedLocusUrl
+      ) => {
+        await assert.isFulfilled(resultPromise);
+        assert.calledOnceWithExactly(
+          spies.generateEditDisplayNameMemberOptions,
+          expectedMemberId,
+          expectedRequestingParticipantId,
+          expectedAlias,
+          expectedLocusUrl
+        );
+        assert.calledOnceWithExactly(spies.editDisplayNameMember, {
+          memberId: expectedMemberId,
+          requestingParticipantId: expectedRequestingParticipantId,
+          alias: expectedAlias,
+          locusUrl: expectedLocusUrl,
+        });
+        assert.strictEqual(resultPromise, spies.editDisplayNameMember.getCall(0).returnValue);
+      };
+
+      it('should not make a request if there is no memberId', async () => {
+        const {members, spies} = setup(url1);
+
+        const resultPromise = members.editDisplayName();
+
+        await checkInvalid(
+          resultPromise,
+          'The member id must be defined to edit display name of the member.',
+          spies
+        );
+      });
+
+      it('should not make a request if there is no locus url', async () => {
+        const {members, spies} = setup();
+
+        const resultPromise = members.editDisplayName(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 respective parameters', async () => {
+        const requestingParticipantId = uuid.v4();
+        const memberId = uuid.v4();
+        const alias = 'aliasName';
+        const {members, spies} = setup(url1);
+
+        const resultPromise = members.editDisplayName(memberId, requestingParticipantId, alias);
+
+        await checkValid(resultPromise, spies, memberId, requestingParticipantId, alias, url1);
+      });
+    });
+
     describe('findMemberByCsi()', () => {
       let members;
 

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

@@ -8,6 +8,7 @@ import Meetings from '@webex/plugin-meetings';
 import MembersRequest from '@webex/plugin-meetings/src/members/request';
 import membersUtil from '@webex/plugin-meetings/src/members/util';
 import ParameterError from '@webex/plugin-meetings/src/common/errors/parameter';
+import { merge } from 'lodash';
 
 const {assert} = chai;
 
@@ -18,6 +19,10 @@ describe('plugin-meetings', () => {
   let membersRequest;
   let url1;
   let sandbox;
+  const sequence = {some: 'sequenceData'};
+  const requestResponse = {some: 'data'};
+  let locusDeltaRequestSpy;
+  const correlationId = '12345';
 
   beforeEach(() => {
     const webex = new MockWebex({
@@ -28,21 +33,43 @@ describe('plugin-meetings', () => {
 
     sandbox = sinon.createSandbox();
 
+    sinon.stub(uuid, 'v4').returns(correlationId);
+
     url1 = `https://example.com/${uuid.v4()}`;
 
+    const request = sinon.mock().returns(Promise.resolve(requestResponse));
+
     membersRequest = new MembersRequest(
-      {},
+      {
+        meeting: {
+          request,
+          locusInfo: {
+            sequence,
+          },
+        },
+      },
       {
         parent: webex,
       }
     );
-    membersRequest.request = sinon.mock().returns(Promise.resolve({}));
+    locusDeltaRequestSpy = sinon.spy(membersRequest, 'locusDeltaRequest');
+
+    membersRequest.request = request;
   });
 
   afterEach(() => {
     sandbox.restore();
+    uuid.v4.restore();
   });
 
+  const checkRequest = (expectedParams) => {
+    assert.calledOnceWithExactly(locusDeltaRequestSpy, expectedParams);
+    assert.calledOnceWithExactly(
+      membersRequest.request,
+      merge(expectedParams, {body: {sequence}})
+    );
+  };
+
   describe('members request library', () => {
     describe('#sendDialPadKey', () => {
       it('sends a POST to the sendDtmf locus endpoint', async () => {
@@ -57,12 +84,22 @@ describe('plugin-meetings', () => {
           memberId,
           locusUrl,
         });
-        const requestParams = membersRequest.request.getCall(0).args[0];
 
-        assert.equal(requestParams.method, 'POST');
-        assert.equal(requestParams.uri, `${locusUrl}/participant/${memberId}/sendDtmf`);
-        assert.equal(requestParams.body.dtmf.tones, tones);
-        assert.equal(requestParams.body.device.url, url);
+        checkRequest({
+          method: 'POST',
+          uri: `${locusUrl}/participant/${memberId}/sendDtmf`,
+          body: {
+            memberId,
+            dtmf: {
+              direction: 'transmit',
+              correlationId,
+              tones,
+            },
+            device: {
+              url,
+            }
+          }
+        });
       });
     });
 
@@ -76,11 +113,91 @@ describe('plugin-meetings', () => {
         };
 
         await membersRequest.addMembers(options);
-        const requestParams = membersRequest.request.getCall(0).args[0];
 
-        assert.equal(requestParams.method, 'PUT');
-        assert.equal(requestParams.uri, url1);
-        assert.equal(requestParams.body.invitees[0].address, '+18578675309');
+        checkRequest({
+          method: 'PUT',
+          uri: url1,
+          body: {
+            alertIfActive: undefined,
+            invitees: [{address: '+18578675309'}]
+          }
+        })
+      });
+    });
+
+    describe('#admitMember', () => {
+      it('sends a request to admit members', async () => {
+        const options = {
+          locusUrl: url1,
+          memberIds: ['1', '2'],
+        };
+  
+        await membersRequest.admitMember(options)
+
+        checkRequest({
+          method: 'PUT',
+          uri: 'https://example.com/12345/controls',
+          body: {
+            admit: {
+              participantIds: options.memberIds
+            }
+          }
+        });
+      });
+    });
+
+    describe('#removeMember', () => {
+      it('sends a request to remove a member', async () => {
+        const options = {
+          locusUrl: url1,
+          memberId: 'member1',
+        };
+
+        await membersRequest.removeMember(options);
+
+        checkRequest({
+          method: 'PUT',
+          uri: 'https://example.com/12345/participant/member1/leave',
+          body: {
+            reason: undefined
+          },
+        });
+      });
+    });
+
+    describe('#muteMember', () => {
+      it('sends a request to mute a member', async () => {
+        const options = {
+          locusUrl: url1,
+          memberId: 'member1',
+          muted: true,
+        };
+
+        await membersRequest.muteMember(options);
+
+        checkRequest({
+          method: 'PATCH',
+          uri: 'https://example.com/12345/participant/member1/controls',
+          body: {audio: {muted: true}},
+        });
+      });
+    });
+
+    describe('#transferHostToMember', () => {
+      it('sends a request to transfer host to a member', async () => {
+        const options = {
+          locusUrl: url1,
+          memberId: 'member1',
+          moderator: true,
+        };
+
+        await membersRequest.transferHostToMember(options);
+
+        checkRequest({
+          method: 'PATCH',
+          uri: 'https://example.com/12345/participant/member1/controls',
+          body: {role: {moderator: true}},
+        });
       });
     });
 
@@ -94,12 +211,45 @@ describe('plugin-meetings', () => {
         };
 
         await membersRequest.cancelPhoneInvite(options);
-        const requestParams = membersRequest.request.getCall(0).args[0];
 
-        assert.equal(requestParams.method, 'PUT');
-        assert.equal(requestParams.uri, url1);
-        assert.equal(requestParams.body.invitees[0].address, '+18578675309');
-        assert.equal(requestParams.body.actionType, 'REMOVE');
+        checkRequest({
+          method: 'PUT',
+          uri: url1,
+          body: {
+            invitees: [{address: '+18578675309'}],
+            actionType: 'REMOVE',
+          },
+        });
+      });
+    });
+
+    describe('#assignRolesMember', () => {
+      it('sends a PATCH to the locus endpoint', async () => {
+        const locusUrl = url1;
+        const memberId = 'test1';
+        const roles = [
+          {type: 'PRESENTER', hasRole: true},
+          {type: 'MODERATOR', hasRole: false},
+          {type: 'COHOST', hasRole: true},
+        ];
+
+        const options = {
+          memberId,
+          locusUrl,
+          roles,
+        };
+
+        await membersRequest.assignRolesMember(options);
+
+        checkRequest({
+          method: 'PATCH',
+          uri: `${locusUrl}/participant/${memberId}/controls`,
+          body: {
+            role: {
+              roles
+            }
+          }
+        });
       });
     });
 
@@ -115,11 +265,16 @@ describe('plugin-meetings', () => {
         };
 
         await membersRequest.raiseOrLowerHandMember(options);
-        const requestParams = membersRequest.request.getCall(0).args[0];
 
-        assert.equal(requestParams.method, 'PATCH');
-        assert.equal(requestParams.uri, `${locusUrl}/participant/${memberId}/controls`);
-        assert.equal(requestParams.body.hand.raised, true);
+        checkRequest({
+          method: 'PATCH',
+          uri: `${locusUrl}/participant/${memberId}/controls`,
+          body: {
+            hand: {
+              raised: true
+            }
+          }
+        });
       });
     });
 
@@ -158,10 +313,9 @@ describe('plugin-meetings', () => {
           locusUrl,
         };
 
-        assert.strictEqual(
-          membersRequest.lowerAllHandsMember(options),
-          membersRequest.request.getCall(0).returnValue
-        );
+        const result = await membersRequest.lowerAllHandsMember(options);
+
+        assert.strictEqual(result, requestResponse);
       });
 
       it('sends a PATCH to the locus endpoint', async () => {
@@ -182,9 +336,7 @@ describe('plugin-meetings', () => {
           locusUrl: url1,
         });
 
-        const requestParams = membersRequest.request.getCall(0).args[0];
-
-        assert.deepEqual(requestParams, {
+        checkRequest({
           method: 'PATCH',
           uri: `${locusUrl}/controls`,
           body: {
@@ -196,5 +348,32 @@ describe('plugin-meetings', () => {
         });
       });
     });
+
+    describe('#editDisplayName', () => {
+      it('sends a POST request to the locus endpoint', async () => {
+        const locusUrl = url1;
+        const memberId = 'test1';
+        const requestingParticipantId = 'test2';
+        const aliasValue = 'alias';
+
+        const options = {
+          memberId,
+          requestingParticipantId,
+          alias: aliasValue,
+          locusUrl,
+        };
+
+        await membersRequest.editDisplayNameMember(options);
+
+        checkRequest({
+          method: 'POST',
+          uri: `${locusUrl}/participant/${memberId}/alias`,
+          body: {
+            aliasValue,
+            requestingParticipantId,
+          }
+        });
+      });
+    });
   });
 });