@webex/plugin-meetings 3.0.0-beta.13 → 3.0.0-beta.131

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

@@ -3,55 +3,95 @@ import {assert} from '@webex/test-helper-chai';
 import MockWebex from '@webex/test-helper-mock-webex';
 import Meetings from '@webex/plugin-meetings';
 import MeetingRequest from '@webex/plugin-meetings/src/meeting/request';
+import uuid from 'uuid';
+import { merge } from 'lodash';
+
 
 describe('plugin-meetings', () => {
   let meetingsRequest;
+  let locusDeltaRequestSpy;
 
   beforeEach(() => {
     const webex = new MockWebex({
       children: {
-        meetings: Meetings
-      }
+        meetings: Meetings,
+      },
     });
 
     webex.meetings.clientRegion = {
       countryCode: 'US',
-      regionCode: 'WEST-COAST'
+      regionCode: 'WEST-COAST',
     };
 
     webex.internal = {
       services: {
         get: sinon.mock().returns('locusUrl'),
-        waitForCatalog: sinon.mock().returns(Promise.resolve({}))
-      }
+        waitForCatalog: sinon.mock().returns(Promise.resolve({})),
+      },
     };
 
-    meetingsRequest = new MeetingRequest({}, {
-      parent: webex
-    });
-
+    webex.boundedStorage.get = sinon.mock().returns(Promise.resolve(JSON.stringify({anycastEntryPoint: "aws-eu-west-1"})))
+
+    const request = sinon.mock().returns(Promise.resolve({}));
+
+    meetingsRequest = new MeetingRequest(
+      {
+        meeting: {
+          request,
+          locusInfo: {
+            sequence: {}
+          }
+        }
+      },
+      {
+        parent: webex,
+      }
+    );
 
-    meetingsRequest.request = sinon.mock().returns(Promise.resolve({}));
+    meetingsRequest.request = request;
+    locusDeltaRequestSpy = sinon.spy(meetingsRequest, 'locusDeltaRequest');
   });
 
+  const checkRequest = (expectedParams) => {
+    assert.calledOnceWithExactly(locusDeltaRequestSpy, expectedParams);
+    assert.calledOnceWithExactly(meetingsRequest.request, merge(expectedParams, {body: {sequence: {}}}));
+  }
+
   describe('meeting request library', () => {
+
+    beforeEach(() => {
+      sinon.stub(uuid, 'v4').returns('12345');
+    });
+
+    afterEach(() => {
+      uuid.v4.restore();
+    });
+
     describe('#sendDTMF', () => {
       it('sends a POST to the sendDtmf locus endpoint', async () => {
         const locusUrl = 'locusURL';
         const deviceUrl = 'deviceUrl';
         const tones = '1234';
 
+
+
         await meetingsRequest.sendDTMF({
           locusUrl,
           deviceUrl,
-          tones
+          tones,
         });
-        const requestParams = meetingsRequest.request.getCall(0).args[0];
 
-        assert.equal(requestParams.method, 'POST');
-        assert.equal(requestParams.uri, `${locusUrl}/sendDtmf`);
-        assert.equal(requestParams.body.dtmf.tones, tones);
-        assert.equal(requestParams.body.deviceUrl, deviceUrl);
+        checkRequest({
+          method: 'POST',
+          uri: `${locusUrl}/sendDtmf`,
+          body: {
+            deviceUrl: 'deviceUrl',
+            dtmf: {
+              correlationId: '12345',
+              tones: '1234',
+            },
+          },
+        });
       });
     });
 
@@ -66,51 +106,66 @@ describe('plugin-meetings', () => {
           deviceUrl,
           layoutType,
           main: {width: 640, height: 480},
-          content: {width: 1280, height: 720}
+          content: {width: 1280, height: 720},
         });
-        const requestParams = meetingsRequest.request.getCall(0).args[0];
 
-        assert.equal(requestParams.method, 'PUT');
-        assert.equal(requestParams.uri, `${locusUrl}/controls`);
-        assert.equal(requestParams.body.layout.type, layoutType);
-        assert.equal(requestParams.body.layout.deviceUrl, deviceUrl);
-        assert.deepEqual(requestParams.body.layout.layoutParams, {renderInfo: {main: {width: 640, height: 480}, content: {width: 1280, height: 720}}});
+        checkRequest({
+          method: 'PUT',
+          uri: `${locusUrl}/controls`,
+          body: {
+            layout: {
+              deviceUrl,
+              type: layoutType,
+              layoutParams: {
+                renderInfo: {main: {width: 640, height: 480}, content: {width: 1280, height: 720}},
+              },
+            },
+          },
+        });
       });
 
       it('throws if width is missing for main', async () => {
-        await assert.isRejected(meetingsRequest.changeVideoLayout({
-          locusUrl,
-          deviceUrl,
-          layoutType,
-          main: {height: 100}
-        }));
+        await assert.isRejected(
+          meetingsRequest.changeVideoLayout({
+            locusUrl,
+            deviceUrl,
+            layoutType,
+            main: {height: 100},
+          })
+        );
       });
 
       it('throws if height is missing for main', async () => {
-        await assert.isRejected(meetingsRequest.changeVideoLayout({
-          locusUrl,
-          deviceUrl,
-          layoutType,
-          main: {width: 100}
-        }));
+        await assert.isRejected(
+          meetingsRequest.changeVideoLayout({
+            locusUrl,
+            deviceUrl,
+            layoutType,
+            main: {width: 100},
+          })
+        );
       });
 
       it('throws if width is missing for content', async () => {
-        await assert.isRejected(meetingsRequest.changeVideoLayout({
-          locusUrl,
-          deviceUrl,
-          layoutType,
-          content: {height: 100}
-        }));
+        await assert.isRejected(
+          meetingsRequest.changeVideoLayout({
+            locusUrl,
+            deviceUrl,
+            layoutType,
+            content: {height: 100},
+          })
+        );
       });
 
       it('throws if height is missing for content', async () => {
-        await assert.isRejected(meetingsRequest.changeVideoLayout({
-          locusUrl,
-          deviceUrl,
-          layoutType,
-          content: {width: 100}
-        }));
+        await assert.isRejected(
+          meetingsRequest.changeVideoLayout({
+            locusUrl,
+            deviceUrl,
+            layoutType,
+            content: {width: 100},
+          })
+        );
       });
     });
 
@@ -127,8 +182,7 @@ describe('plugin-meetings', () => {
           deviceUrl,
           correlationId,
           roapMessage,
-          permissionToken
-
+          permissionToken,
         });
         const requestParams = meetingsRequest.request.getCall(0).args[0];
 
@@ -150,7 +204,7 @@ describe('plugin-meetings', () => {
           deviceUrl,
           correlationId,
           roapMessage,
-          meetingNumber
+          meetingNumber,
         });
         const requestParams = meetingsRequest.request.getCall(0).args[0];
 
@@ -171,7 +225,7 @@ describe('plugin-meetings', () => {
           correlationId,
           roapMessage,
           meetingNumber,
-          inviteeAddress
+          inviteeAddress,
         });
         const requestParams = meetingsRequest.request.getCall(0).args[0];
 
@@ -179,6 +233,82 @@ describe('plugin-meetings', () => {
         assert.equal(requestParams.uri, 'locusUrl/loci/call?alternateRedirect=true');
         assert.equal(requestParams.body.invitee.address, 'sipUrl');
       });
+
+      it('adds deviceCapabilities to request when breakouts are supported', async () => {
+        await meetingsRequest.joinMeeting({
+          breakoutsSupported: true
+        });
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
+
+        assert.deepEqual(requestParams.body.deviceCapabilities, ['BREAKOUTS_SUPPORTED']);
+      });
+
+      it('adds deviceCapabilities to request when live annotation are supported', async () => {
+        await meetingsRequest.joinMeeting({
+          liveAnnotationSupported: true
+        });
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
+        assert.deepEqual(requestParams.body.deviceCapabilities, ['ANNOTATION_ON_SHARE_SUPPORTED']);
+      });
+      it('adds deviceCapabilities to request when breakouts and live annotation are supported', async () => {
+        await meetingsRequest.joinMeeting({
+          liveAnnotationSupported: true,
+          breakoutsSupported: true,
+        });
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
+        assert.deepEqual(requestParams.body.deviceCapabilities, ['BREAKOUTS_SUPPORTED','ANNOTATION_ON_SHARE_SUPPORTED']);
+      });
+      it('does not add deviceCapabilities to request when breakouts and live annotation are not supported', async () => {
+        await meetingsRequest.joinMeeting({});
+
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
+
+        assert.deepEqual(requestParams.body.deviceCapabilities, undefined);
+
+      });
+
+      it('adds deviceCapabilities and locale to request when they are provided', async () => {
+        await meetingsRequest.joinMeeting({
+          locale: 'en_UK',
+          deviceCapabilities: ['SERVER_AUDIO_ANNOUNCEMENT_SUPPORTED']
+        });
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
+
+        assert.deepEqual(requestParams.body.deviceCapabilities, ['SERVER_AUDIO_ANNOUNCEMENT_SUPPORTED']);
+        assert.deepEqual(requestParams.body.locale, 'en_UK');
+      });
+
+      it('does not add deviceCapabilities and locale to request when they are not provided', async () => {
+        await meetingsRequest.joinMeeting({});
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
+
+        assert.deepEqual(requestParams.body.deviceCapabilities, undefined);
+        assert.deepEqual(requestParams.body.locale, undefined);
+      });
+
+      it('includes joinCookie correctly', async () => {
+        const locusUrl = 'locusURL';
+        const deviceUrl = 'deviceUrl';
+        const correlationId = 'random-uuid';
+        const roapMessage = 'roap-message';
+        const permissionToken = 'permission-token';
+
+        await meetingsRequest.joinMeeting({
+          locusUrl,
+          deviceUrl,
+          correlationId,
+          roapMessage,
+          permissionToken,
+        });
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
+
+        assert.equal(requestParams.method, 'POST');
+        assert.equal(requestParams.uri, `${locusUrl}/participant?alternateRedirect=true`);
+        assert.deepEqual(requestParams.body.clientMediaPreferences, {
+          "joinCookie": {anycastEntryPoint: "aws-eu-west-1"},
+          "preferTranscoding": true
+        });
+      });
     });
 
     describe('#pstn', () => {
@@ -192,16 +322,22 @@ describe('plugin-meetings', () => {
           locusUrl,
           clientUrl,
           correlationId,
-          dialInUrl
+          dialInUrl,
         });
-        const requestParams = meetingsRequest.request.getCall(0).args[0];
 
-        assert.equal(requestParams.method, 'POST');
-        assert.equal(requestParams.uri, `${locusUrl}/participant`);
-        assert.equal(requestParams.body.device.url, dialInUrl);
-        assert.equal(requestParams.body.device.deviceType, 'PROVISIONAL');
-        assert.equal(requestParams.body.device.provisionalType, 'DIAL_IN');
-        assert.equal(requestParams.body.device.clientUrl, 'clientUrl');
+        checkRequest({
+          method: 'POST',
+          uri: `${locusUrl}/participant`,
+          body: {
+            device: {
+              url: dialInUrl,
+              deviceType: 'PROVISIONAL',
+              provisionalType: 'DIAL_IN',
+              clientUrl,
+            },
+            correlationId
+          }
+        });
       });
 
       it('sends dial out pstn request', async () => {
@@ -216,17 +352,24 @@ describe('plugin-meetings', () => {
           clientUrl,
           correlationId,
           dialOutUrl,
-          phoneNumber
+          phoneNumber,
+        });
+
+        checkRequest({
+          method: 'POST',
+          uri: `${locusUrl}/participant`,
+          body: {
+            device: {
+              url: dialOutUrl,
+              deviceType: 'PROVISIONAL',
+              provisionalType: 'DIAL_OUT',
+              clientUrl,
+              dialoutAddress: phoneNumber,
+            },
+            correlationId,
+          },
         });
-        const requestParams = meetingsRequest.request.getCall(0).args[0];
 
-        assert.equal(requestParams.method, 'POST');
-        assert.equal(requestParams.uri, `${locusUrl}/participant`);
-        assert.equal(requestParams.body.device.url, dialOutUrl);
-        assert.equal(requestParams.body.device.deviceType, 'PROVISIONAL');
-        assert.equal(requestParams.body.device.provisionalType, 'DIAL_OUT');
-        assert.equal(requestParams.body.device.clientUrl, 'clientUrl');
-        assert.equal(requestParams.body.device.dialoutAddress, phoneNumber);
       });
 
       it('sends disconnect phone audio request', async () => {
@@ -239,17 +382,98 @@ describe('plugin-meetings', () => {
           locusUrl,
           selfId,
           correlationId,
-          phoneUrl
+          phoneUrl,
+        });
+
+        checkRequest({
+          method: 'PUT',
+          uri: `${locusUrl}/participant/${selfId}/leave`,
+          body: {
+            device: {
+              url: phoneUrl,
+              deviceType: 'PROVISIONAL'
+            },
+            correlationId
+          }
+        });
+      });
+    });
+
+    describe('#leaveMeeting', () => {
+      it('sends the request to leave the meeting', async () => {
+        const locusUrl = 'locusUrl';
+        const selfId = 'selfId';
+        const correlationId = 'random-uuid';
+        const resourceId = 'resourceId';
+        const deviceUrl = 'deviceUrl';
+
+        meetingsRequest.config.meetings.deviceType = 'deviceType';
+
+        await meetingsRequest.leaveMeeting({
+          locusUrl,
+          selfId,
+          deviceUrl,
+          resourceId,
+          correlationId,
+        });
+
+        checkRequest({
+          method: 'PUT',
+          uri: 'locusUrl/participant/selfId/leave',
+          body: {
+            device: {deviceType: 'deviceType', url: 'deviceUrl'},
+            usingResource: 'resourceId',
+            correlationId: 'random-uuid',
+          },
+        });
+      });
+    });
+
+    describe('#acknowledgeMeeting', () => {
+      it('sends the request to acknowledge the meeting', async () => {
+        const locusUrl = 'locusUrl';
+        const correlationId = 'random-uuid';
+        const deviceUrl = 'deviceUrl';
+
+        meetingsRequest.config.meetings.deviceType = 'deviceType';
+
+        await meetingsRequest.acknowledgeMeeting({
+          locusUrl,
+          deviceUrl,
+          correlationId,
         });
-        const requestParams = meetingsRequest.request.getCall(0).args[0];
 
-        assert.equal(requestParams.method, 'PUT');
-        assert.equal(requestParams.uri, `${locusUrl}/participant/${selfId}/leave`);
-        assert.equal(requestParams.body.device.url, phoneUrl);
-        assert.equal(requestParams.body.device.deviceType, 'PROVISIONAL');
+        checkRequest({
+          method: 'PUT',
+          uri: 'locusUrl/participant/alert',
+          body: {
+            device: {deviceType: 'deviceType', url: 'deviceUrl'},
+            correlationId: 'random-uuid',
+          },
+        });
+      });
+    });
+
+    describe('#lockMeeting', () => {
+      it('sends request to lock the meeting', async () => {
+        const locusUrl = 'locusURL';
+
+        await meetingsRequest.lockMeeting({
+          locusUrl,
+          lock: true,
+        });
+
+        checkRequest({
+          method: 'PATCH',
+          uri: `${locusUrl}/controls`,
+          body: {
+            lock: {locked: true}
+          }
+        });
       });
     });
 
+
     describe('#endMeetingForAll', () => {
       it('sends request to endMeetingForAll', async () => {
         const locusUrl = 'locusURL';
@@ -257,10 +481,11 @@ describe('plugin-meetings', () => {
         await meetingsRequest.endMeetingForAll({
           locusUrl,
         });
-        const requestParams = meetingsRequest.request.getCall(0).args[0];
 
-        assert.equal(requestParams.method, 'POST');
-        assert.equal(requestParams.uri, `${locusUrl}/end`);
+        checkRequest({
+          method: 'POST',
+          uri: `${locusUrl}/end`,
+        });
       });
     });
 
@@ -286,13 +511,13 @@ describe('plugin-meetings', () => {
           type: 'thumb_down',
           codepoints: '1F44E',
           shortcodes: ':thumbsdown:',
-          tone: {type: 'normal_skin_tone', codepoints: '', shortcodes: ''}
+          tone: {type: 'normal_skin_tone', codepoints: '', shortcodes: ''},
         };
 
         await meetingsRequest.sendReaction({
           reactionChannelUrl,
           reaction,
-          participantId
+          participantId,
         });
         const requestParams = meetingsRequest.request.getCall(0).args[0];
 
@@ -302,5 +527,122 @@ describe('plugin-meetings', () => {
         assert.equal(requestParams.body.reaction, reaction);
       });
     });
+
+    describe('#toggleReactions', () => {
+      it('sends request to toggleReactions', async () => {
+        const locusUrl = 'locusUrl';
+        const requestingParticipantId = 'requestingParticipantId';
+
+        await meetingsRequest.toggleReactions({
+          enable: true,
+          locusUrl,
+          requestingParticipantId,
+        });
+
+        checkRequest({
+          method: 'PUT',
+          uri: `${locusUrl}/controls`,
+          body: {
+            reactions: {
+              enabled: true,
+            },
+            requestingParticipantId,
+          },
+        });
+      });
+    });
+  });
+
+  describe('#declineMeeting', () => {
+
+    it('sends a request to decline the meeting', async () => {
+      const reason = 'reason';
+      const deviceUrl = 'deviceUrl';
+      const locusUrl = 'locusUrl';
+      meetingsRequest.config.meetings.deviceType = 'deviceType';
+  
+      await meetingsRequest.declineMeeting({
+        locusUrl,
+        deviceUrl,
+        reason
+      });
+  
+      const expectedBody = {
+        device: {
+          deviceType: 'deviceType',
+          url: deviceUrl,
+        },
+        reason,
+      };
+  
+      checkRequest({
+        method: 'PUT',
+        uri: `${locusUrl}/participant/decline`,
+        body: expectedBody,
+      });
+    });
+
+  });
+
+  describe('#getLocusStatusByUrl', () => {
+    it('check locus status', async () => {
+      const locusUrl = 'locusUrl';
+
+      await meetingsRequest.getLocusStatusByUrl(locusUrl);
+      assert.deepEqual(meetingsRequest.request.getCall(0).args[0], {
+        method: 'GET',
+        uri: locusUrl,
+      })
+    });
+  });
+
+  describe('#changeMeetingFloor', () => {
+
+    it('change meeting floor', async () => {
+      const options = {
+        disposition: 'GRANTED',
+        personUrl: 'personUrl',
+        deviceUrl: 'deviceUrl',
+        resourceId: 'resourceId',
+        resourceUrl: 'resourceUrl',
+        uri: 'optionsUrl',
+        annotation:{
+          version: '1',
+          policy: 'Approval',
+        },
+      }
+
+      const expectBody = {
+        annotation: {
+          policy: 'Approval',
+          version: '1',
+        },
+        floor: {
+          beneficiary: {
+            devices: [
+              {
+                deviceType: undefined,
+                url: "deviceUrl"
+              }
+            ],
+            url: 'personUrl',
+          },
+          disposition: 'GRANTED',
+          requester: {
+            "url": "personUrl"
+          }
+        },
+        resourceUrl: 'resourceUrl',
+      };
+
+
+      await meetingsRequest.changeMeetingFloor(options);
+
+      assert.deepEqual(meetingsRequest.request.getCall(0).args[0], {
+        method: 'PUT',
+        uri: 'optionsUrl',
+        body: expectBody,
+      })
+    });
   });
 });