@webex/plugin-meetings 3.0.0-beta.58 → 3.0.0-beta.59

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

@@ -1,53 +1,356 @@
 import {assert} from '@webex/test-helper-chai';
 import MemberUtil from '@webex/plugin-meetings/src/member/util';
+import { ServerRoles } from '../../../../src/member/types';
 
-describe('isHandRaised', () => {
-  it('throws error when there is no participant', () => {
-    assert.throws(() => {
-      MemberUtil.isHandRaised();
-    }, 'Raise hand could not be processed, participant is undefined.');
+describe('plugin-meetings', () => {
+  describe('isHandRaised', () => {
+    it('throws error when there is no participant', () => {
+      assert.throws(() => {
+        MemberUtil.isHandRaised();
+      }, 'Raise hand could not be processed, participant is undefined.');
+    });
+  
+    it('returns false when controls is not there', () => {
+      const participant = {};
+  
+      assert.isFalse(MemberUtil.isHandRaised(participant));
+    });
+  
+    it('returns false when hand is not there in controls', () => {
+      const participant = {
+        controls: {},
+      };
+  
+      assert.isFalse(MemberUtil.isHandRaised(participant));
+    });
+  
+    it('returns true when hand raised is true', () => {
+      const participant = {
+        controls: {
+          hand: {
+            raised: true,
+          },
+        },
+      };
+  
+      assert.isTrue(MemberUtil.isHandRaised(participant));
+    });
+  
+    it('returns false when hand raised is false', () => {
+      const participant = {
+        controls: {
+          hand: {
+            raised: false,
+          },
+        },
+      };
+  
+      assert.isFalse(MemberUtil.isHandRaised(participant));
+    });
   });
 
-  it('returns false when controls is not there', () => {
-    const participant = {};
+  describe('MemberUtil.extractControlRoles', () => {
+    it('happy path extract control roles', () => {
+      const participant = {
+        controls: {
+          role: {
+            roles: [
+              {type: 'PRESENTER', hasRole: true},
+              {type: 'COHOST', hasRole: true},
+              {type: 'MODERATOR', hasRole: true},
+            ]
+          }
+        }
+      }
 
-    assert.isFalse(MemberUtil.isHandRaised(participant));
+      assert.deepEqual(MemberUtil.extractControlRoles(participant), {cohost: true, moderator: true, presenter: true});
+    });
   });
 
-  it('returns false when hand is not there in controls', () => {
-    const participant = {
-      controls: {},
-    };
+  describe('MemberUtil.getControlsRoles', () => {
+    it('getControlsRoles', () => {
+      const participant = {
+        controls: {
+          role: {
+            roles: [
+              {type: 'PRESENTER', hasRole: true},
+            ]
+          }
+        }
+      }
 
-    assert.isFalse(MemberUtil.isHandRaised(participant));
+      assert.deepEqual(MemberUtil.getControlsRoles(participant), [{type: 'PRESENTER', hasRole: true}]);
+    });
   });
 
-  it('returns true when hand raised is true', () => {
-    const participant = {
-      controls: {
-        hand: {
-          raised: true,
-        },
-      },
-    };
+  describe('MemberUtil.hasRole', () => {
+    describe('PRESENTER', () => {
+      it('getControlsRoles PRESENTER true', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {type: 'PRESENTER', hasRole: true},
+              ]
+            }
+          }
+        }
+  
+        assert.isTrue(MemberUtil.hasRole(participant, ServerRoles.Presenter));
+      });
+
+      it('getControlsRoles PRESENTER false', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {type: 'PRESENTER', hasRole: false},
+              ]
+            }
+          }
+        }
+  
+        assert.isFalse(MemberUtil.hasRole(participant, ServerRoles.Presenter));
+      });
+
+      it('getControlsRoles PRESENTER undefined', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {},
+              ]
+            }
+          }
+        }
+  
+        assert.isFalse(MemberUtil.hasRole(participant, ServerRoles.Presenter));
+      });
+    })
+
+    describe('MODERATOR', () => {
+      it('getControlsRoles MODERATOR true', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {type: 'MODERATOR', hasRole: true},
+              ]
+            }
+          }
+        }
+  
+        assert.isTrue(MemberUtil.hasRole(participant, ServerRoles.Moderator));
+      });
 
-    assert.isTrue(MemberUtil.isHandRaised(participant));
+      it('getControlsRoles MODERATOR false', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {type: 'MODERATOR', hasRole: false},
+              ]
+            }
+          }
+        }
+  
+        assert.isFalse(MemberUtil.hasRole(participant, ServerRoles.Moderator));
+      });
+
+      it('getControlsRoles MODERATOR undefined', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {},
+              ]
+            }
+          }
+        }
+  
+        assert.isFalse(MemberUtil.hasRole(participant, ServerRoles.Moderator));
+      });
+    })
+
+    describe('COHOST', () => {
+      it('getControlsRoles COHOST true', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {type: 'COHOST', hasRole: true},
+              ]
+            }
+          }
+        }
+  
+        assert.isTrue(MemberUtil.hasRole(participant, ServerRoles.Cohost));
+      });
+
+      it('getControlsRoles COHOST false', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {type: 'COHOST', hasRole: false},
+              ]
+            }
+          }
+        }
+  
+        assert.isFalse(MemberUtil.hasRole(participant, ServerRoles.Cohost));
+      });
+
+      it('getControlsRoles COHOST undefined', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {},
+              ]
+            }
+          }
+        }
+  
+        assert.isFalse(MemberUtil.hasRole(participant, ServerRoles.Cohost));
+      });
+    })
   });
 
-  it('returns false when hand raised is false', () => {
-    const participant = {
-      controls: {
-        hand: {
-          raised: false,
-        },
-      },
-    };
+  describe('MemberUtil.is<Role>', () => {
+    describe('PRESENTER', () => {
+      it('getControlsRoles PRESENTER true', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {type: 'PRESENTER', hasRole: true},
+              ]
+            }
+          }
+        }
+  
+        assert.isTrue(MemberUtil.hasPresenter(participant, ServerRoles.Presenter));
+      });
 
-    assert.isFalse(MemberUtil.isHandRaised(participant));
+      it('getControlsRoles PRESENTER false', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {type: 'PRESENTER', hasRole: false},
+              ]
+            }
+          }
+        }
+  
+        assert.isFalse(MemberUtil.hasPresenter(participant));
+      });
+
+      it('getControlsRoles PRESENTER undefined', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {},
+              ]
+            }
+          }
+        }
+  
+        assert.isFalse(MemberUtil.hasPresenter(participant));
+      });
+    })
+
+    describe('MODERATOR', () => {
+      it('getControlsRoles MODERATOR true', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {type: 'MODERATOR', hasRole: true},
+              ]
+            }
+          }
+        }
+  
+        assert.isTrue(MemberUtil.hasModerator(participant));
+      });
+
+      it('getControlsRoles MODERATOR false', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {type: 'MODERATOR', hasRole: false},
+              ]
+            }
+          }
+        }
+  
+        assert.isFalse(MemberUtil.hasModerator(participant));
+      });
+
+      it('getControlsRoles MODERATOR undefined', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {},
+              ]
+            }
+          }
+        }
+  
+        assert.isFalse(MemberUtil.hasModerator(participant));
+      });
+    })
+
+    describe('COHOST', () => {
+      it('getControlsRoles COHOST true', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {type: 'COHOST', hasRole: true},
+              ]
+            }
+          }
+        }
+  
+        assert.isTrue(MemberUtil.hasCohost(participant));
+      });
+
+      it('getControlsRoles COHOST false', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {type: 'COHOST', hasRole: false},
+              ]
+            }
+          }
+        }
+  
+        assert.isFalse(MemberUtil.hasCohost(participant));
+      });
+
+      it('getControlsRoles COHOST undefined', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {},
+              ]
+            }
+          }
+        }
+  
+        assert.isFalse(MemberUtil.hasCohost(participant));
+      });
+    })
   });
-});
 
-describe('plugin-meetings', () => {
   describe('MemberUtil.isBreakoutsSupported', () => {
     it('throws error when there is no participant', () => {
       assert.throws(() => {

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

@@ -266,6 +266,83 @@ 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});

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

@@ -103,6 +103,27 @@ describe('plugin-meetings', () => {
       });
     });
 
+    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);
+        const requestParams = membersRequest.request.getCall(0).args[0];
+
+        assert.equal(requestParams.method, 'PATCH');
+        assert.equal(requestParams.uri, `${locusUrl}/participant/${memberId}/controls`);
+        assert.deepEqual(requestParams.body.role.roles, roles);
+      });
+    });
+
     describe('#raiseHand', () => {
       it('sends a PATCH to the locus endpoint', async () => {
         const locusUrl = url1;

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

@@ -12,6 +12,34 @@ sinon.assert.expose(chai.assert, {prefix: ''});
 
 describe('plugin-meetings', () => {
   describe('members utils library', () => {
+    describe('#generateRoleAssignmentMemberOptions', () => {
+      it('returns the correct options', () => {
+        const memberId = 'test';
+        const roles = [{type: 'PRESENTER', hasRole: true}, {type: 'MODERATOR', hasRole: true}, {type: 'COHOST', hasRole: true}]
+        const locusUrl = 'urlTest1';
+
+        assert.deepEqual(MembersUtil.generateRoleAssignmentMemberOptions(memberId, roles, locusUrl), {
+          memberId,
+          roles,
+          locusUrl,
+        });
+      });
+    });
+
+    describe('#getRoleAssignmentMemberRequestParams', () => {
+      it('returns the correct request params', () => {
+        const format = {locusUrl: 'locusUrl', memberId: 'test', roles: [{type: 'PRESENTER', hasRole: true}, {type: 'MODERATOR', hasRole: false}, {type: 'COHOST', hasRole: true}]};
+
+        assert.deepEqual(MembersUtil.getRoleAssignmentMemberRequestParams(format), {
+          method: 'PATCH',
+          uri: `locusUrl/${PARTICIPANT}/test/${CONTROLS}`,
+          body: {role: {
+            roles: [{type: 'PRESENTER', hasRole: true}, {type: 'MODERATOR', hasRole: false}, {type: 'COHOST', hasRole: true}]
+          }},
+        });
+      });
+    });
+
     describe('#generateRaiseHandMemberOptions', () => {
       it('returns the correct options', () => {
         const memberId = 'test';