@webex/plugin-meetings 3.0.0-beta.11 → 3.0.0-beta.111

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

@@ -22,17 +22,20 @@ describe('plugin-meetings', () => {
   beforeEach(() => {
     const webex = new MockWebex({
       children: {
-        meetings: Meetings
-      }
+        meetings: Meetings,
+      },
     });
 
     sandbox = sinon.createSandbox();
 
     url1 = `https://example.com/${uuid.v4()}`;
 
-    membersRequest = new MembersRequest({}, {
-      parent: webex
-    });
+    membersRequest = new MembersRequest(
+      {},
+      {
+        parent: webex,
+      }
+    );
     membersRequest.request = sinon.mock().returns(Promise.resolve({}));
   });
 
@@ -40,7 +43,6 @@ describe('plugin-meetings', () => {
     sandbox.restore();
   });
 
-
   describe('members request library', () => {
     describe('#sendDialPadKey', () => {
       it('sends a POST to the sendDtmf locus endpoint', async () => {
@@ -53,7 +55,7 @@ describe('plugin-meetings', () => {
           url,
           tones,
           memberId,
-          locusUrl
+          locusUrl,
         });
         const requestParams = membersRequest.request.getCall(0).args[0];
 
@@ -68,9 +70,9 @@ describe('plugin-meetings', () => {
       it('sends a PUT to the locus endpoint', async () => {
         const options = {
           invitee: {
-            phoneNumber: '+18578675309'
+            phoneNumber: '+18578675309',
           },
-          locusUrl: url1
+          locusUrl: url1,
         };
 
         await membersRequest.addMembers(options);
@@ -86,9 +88,9 @@ describe('plugin-meetings', () => {
       it('sends a PUT to the locus endpoint', async () => {
         const options = {
           invitee: {
-            phoneNumber: '+18578675309'
+            phoneNumber: '+18578675309',
           },
-          locusUrl: url1
+          locusUrl: url1,
         };
 
         await membersRequest.cancelPhoneInvite(options);
@@ -101,6 +103,31 @@ 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;
@@ -109,7 +136,7 @@ describe('plugin-meetings', () => {
         const options = {
           memberId,
           locusUrl,
-          raised: true
+          raised: true,
         };
 
         await membersRequest.raiseOrLowerHandMember(options);
@@ -122,10 +149,15 @@ describe('plugin-meetings', () => {
     });
 
     describe('#lowerAllHands', () => {
-      const parameterErrorMessage = 'requestingParticipantId must be defined, and the associated locus url for this meeting object must be defined.';
+      const parameterErrorMessage =
+        'requestingParticipantId must be defined, and the associated locus url for this meeting object must be defined.';
 
       const checkInvalid = async (functionParams) => {
-        assert.throws(() => membersRequest.lowerAllHandsMember(functionParams), ParameterError, parameterErrorMessage);
+        assert.throws(
+          () => membersRequest.lowerAllHandsMember(functionParams),
+          ParameterError,
+          parameterErrorMessage
+        );
         assert(membersRequest.request.notCalled);
         assert(membersUtil.getLowerAllHandsMemberRequestParams.notCalled);
       };
@@ -151,7 +183,10 @@ describe('plugin-meetings', () => {
           locusUrl,
         };
 
-        assert.strictEqual(membersRequest.lowerAllHandsMember(options), membersRequest.request.getCall(0).returnValue);
+        assert.strictEqual(
+          membersRequest.lowerAllHandsMember(options),
+          membersRequest.request.getCall(0).returnValue
+        );
       });
 
       it('sends a PATCH to the locus endpoint', async () => {
@@ -163,14 +198,13 @@ describe('plugin-meetings', () => {
           locusUrl,
         };
 
-
         const getRequestParamsSpy = sandbox.spy(membersUtil, 'getLowerAllHandsMemberRequestParams');
 
         await membersRequest.lowerAllHandsMember(options);
 
         assert.calledOnceWithExactly(getRequestParamsSpy, {
           requestingParticipantId: memberId,
-          locusUrl: url1
+          locusUrl: url1,
         });
 
         const requestParams = membersRequest.request.getCall(0).args[0];
@@ -180,12 +214,34 @@ describe('plugin-meetings', () => {
           uri: `${locusUrl}/controls`,
           body: {
             hand: {
-              raised: false
+              raised: false,
             },
-            requestingParticipantId: memberId
-          }
+            requestingParticipantId: memberId,
+          },
         });
       });
     });
+
+    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,
+          aliasValue,
+          locusUrl,
+        };
+
+        await membersRequest.editDisplayNameMember(options);
+        const requestParams = membersRequest.request.getCall(0).args[0];
+
+        assert.equal(requestParams.method, 'POST');
+        assert.equal(requestParams.uri, `${locusUrl}/participant/${memberId}/alias`);
+      });
+    });
   });
 });

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;
 
@@ -11,6 +12,55 @@ 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';
@@ -20,7 +70,7 @@ describe('plugin-meetings', () => {
         assert.deepEqual(MembersUtil.generateRaiseHandMemberOptions(memberId, status, locusUrl), {
           memberId,
           raised: status,
-          locusUrl
+          locusUrl,
         });
       });
     });
@@ -29,10 +79,147 @@ describe('plugin-meetings', () => {
         const requestingParticipantId = 'test';
         const locusUrl = 'urlTest1';
 
-        assert.deepEqual(MembersUtil.generateLowerAllHandsMemberOptions(requestingParticipantId, locusUrl), {
-          requestingParticipantId,
-          locusUrl
+        assert.deepEqual(
+          MembersUtil.generateLowerAllHandsMemberOptions(requestingParticipantId, locusUrl),
+          {
+            requestingParticipantId,
+            locusUrl,
+          }
+        );
+      });
+    });
+    describe('#generateEditDisplayNameMemberOptions', () => {
+      it('returns the correct options', () => {
+        const locusUrl = 'urlTest1';
+        const memberId = 'test1';
+        const requestingParticipantId = 'test2';
+        const alias = 'alias';
+
+        assert.deepEqual(
+          MembersUtil.generateEditDisplayNameMemberOptions(
+            memberId,
+            requestingParticipantId,
+            alias,
+            locusUrl
+          ),
+          {
+            memberId,
+            requestingParticipantId,
+            alias,
+            locusUrl,
+          }
+        );
+      });
+    });
+    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/metrics/index.js

@@ -10,7 +10,6 @@ import {assert} from '@webex/test-helper-chai';
 
 import metrics from '@webex/plugin-meetings/src/metrics';
 
-
 /**
  * Meeting can only run in a browser, so we can only send metrics for
  * browser usage.
@@ -23,7 +22,7 @@ browserOnly(describe)('Meeting metrics', () => {
     clientRegion: 'US-WEST',
     countryCode: 'US',
     regionCode: 'US-WEST',
-    timezone: 'America/Los_Angeles'
+    timezone: 'America/Los_Angeles',
   };
 
   beforeEach(() => {
@@ -31,16 +30,16 @@ browserOnly(describe)('Meeting metrics', () => {
     mockSubmitMetric = sandbox.stub();
     webex = new MockWebex({
       children: {
-        metrics: Metrics
-      }
+        metrics: Metrics,
+      },
     });
 
     webex.version = '1.2.3';
     webex.credentials.getOrgId = sinon.fake.returns('7890');
     webex.credentials.config = {
       _values: {
-        clientId: 'mock-client-id'
-      }
+        clientId: 'mock-client-id',
+      },
     };
     webex.config.metrics.type = ['behavioral'];
     webex.internal.metrics.submitClientMetrics = mockSubmitMetric;
@@ -55,7 +54,7 @@ browserOnly(describe)('Meeting metrics', () => {
     it('should create payload with masked IPv4', () => {
       geoHintInfo.clientAddress = '128.0.0.1';
       webex.meetings = {
-        geoHintInfo
+        geoHintInfo,
       };
       metrics.initialSetup({}, webex);
       const payload = metrics.initPayload('myMetric', {}, {clientType: 'TEAMS_CLIENT'});
@@ -71,7 +70,7 @@ browserOnly(describe)('Meeting metrics', () => {
     it('should create payload with masked IPv6', () => {
       geoHintInfo.clientAddress = '2001:0db8:0000:08d3:0000:0000:0070:0000';
       webex.meetings = {
-        geoHintInfo
+        geoHintInfo,
       };
       metrics.initialSetup({}, webex);
       const payload = metrics.initPayload('myIPv6Metric', {}, {clientType: 'TEAMS_CLIENT'});
@@ -98,19 +97,104 @@ browserOnly(describe)('Meeting metrics', () => {
 
       metrics.sendBehavioralMetric('myMetric', fields, metricTags);
 
-      assert.calledWithMatch(
-        mockSubmitMetric,
-        'myMetric',
-        {
-          type: ['behavioral'],
-          fields: {
-            value: 567
-          },
-          tags: {
-            test: true
-          }
-        }
+      assert.calledWithMatch(mockSubmitMetric, 'myMetric', {
+        type: ['behavioral'],
+        fields: {
+          value: 567,
+        },
+        tags: {
+          test: true,
+        },
+      });
+    });
+  });
+
+  describe('parseWebexApiError', () => {
+    it('returns the correct error data for meeting lookup info error', () => {
+      const err = {
+        body: {
+          code: 58400,
+        },
+        statusCode: 400,
+      };
+      const res = metrics.parseWebexApiError(err, false);
+
+      assert.deepEqual(res, {
+        shownToUser: false,
+        category: 'signaling',
+        errorDescription: 'MeetingInfoLookupError',
+        errorCode: 4100,
+        fatal: true,
+        name: 'other',
+        serviceErrorCode: 58400,
+        errorData:  { error: { code: 58400 } },
+        httpCode: 400
+      });
+    });
+
+    it('returns the correct error data for access rights error error', () => {
+      const err = {
+        body: {
+          code: 403041,
+        },
+        statusCode: 400,
+      };
+      const res = metrics.parseWebexApiError(err, false);
+
+      assert.deepEqual(res, {
+        shownToUser: false,
+        "category": "expected",
+        "errorCode": 4005,
+        errorDescription: 'Moderator_Pin_Or_Guest_PIN_Required',
+        fatal: false,
+        name: 'other',
+        serviceErrorCode: 403041,
+        errorData: { error: { code: 403041 } },
+        httpCode: 400
+      });
+    });
+
+    it('returns  null for unknown error', () => {
+      const err = {
+        body: {
+          code: 123456,
+        },
+      };
+      const res = metrics.parseWebexApiError(err, false);
+
+      assert.deepEqual(res, null);
+    });
+  });
+
+  describe('#generateErrorPayload', () => {
+    it('generates the correct payload for a valid error code', () => {
+      const errorCode = 4008;
+      const shownToUser = true;
+      const name = 'errorName';
+      const errBody = 'some error body';
+      const err = {
+        body: errBody,
+        statusCode: 404,
+      };
+
+      const payload = metrics.generateErrorPayload(
+        errorCode,
+        shownToUser,
+        name,
+        err
       );
+
+      assert.deepEqual(payload, {
+        shownToUser,
+        category: 'expected',
+        errorDescription: 'NewLocusError',
+        errorCode,
+        fatal: true,
+        name,
+        errorData: {error: errBody},
+        serviceErrorCode: undefined,
+        httpCode: 404,
+      });
     });
   });
 });