@webex/plugin-meetings 2.60.1-next.9 → 2.60.2

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

@@ -3,89 +3,40 @@ 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';
-import {IP_VERSION} from '@webex/plugin-meetings/src/constants';
-import {CallDiagnosticUtils} from '@webex/internal-plugin-metrics';
 
 describe('plugin-meetings', () => {
   let meetingsRequest;
-  let locusDeltaRequestSpy;
-  let webex;
-  const geoHintInfoDefaults = {
-    countryCode: 'US',
-    regionCode: 'WEST-COAST',
-    clientAddress: '127.0.0.1',
-  };
-  let anonymizeIpSpy;
 
   beforeEach(() => {
-    webex = new MockWebex({
+    const webex = new MockWebex({
       children: {
         meetings: Meetings,
       },
     });
 
-    webex.meetings.geoHintInfo = {...geoHintInfoDefaults};
+    webex.meetings.clientRegion = {
+      countryCode: 'US',
+      regionCode: 'WEST-COAST',
+    };
 
     webex.internal = {
       services: {
         get: sinon.mock().returns('locusUrl'),
         waitForCatalog: sinon.mock().returns(Promise.resolve({})),
       },
-      device: {
-        config: {
-          installationId: 'installationId',
-        },
-      },
     };
 
-    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 = request;
-    locusDeltaRequestSpy = sinon.spy(meetingsRequest, 'locusDeltaRequest');
-    anonymizeIpSpy = sinon.spy(CallDiagnosticUtils, 'anonymizeIPAddress');
+    meetingsRequest.request = sinon.mock().returns(Promise.resolve({}));
   });
 
-  afterEach(() => {
-    anonymizeIpSpy.restore();
-  });
-
-  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';
@@ -97,18 +48,12 @@ describe('plugin-meetings', () => {
           deviceUrl,
           tones,
         });
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
 
-        checkRequest({
-          method: 'POST',
-          uri: `${locusUrl}/sendDtmf`,
-          body: {
-            deviceUrl: 'deviceUrl',
-            dtmf: {
-              correlationId: '12345',
-              tones: '1234',
-            },
-          },
-        });
+        assert.equal(requestParams.method, 'POST');
+        assert.equal(requestParams.uri, `${locusUrl}/sendDtmf`);
+        assert.equal(requestParams.body.dtmf.tones, tones);
+        assert.equal(requestParams.body.deviceUrl, deviceUrl);
       });
     });
 
@@ -125,19 +70,14 @@ describe('plugin-meetings', () => {
           main: {width: 640, height: 480},
           content: {width: 1280, height: 720},
         });
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
 
-        checkRequest({
-          method: 'PUT',
-          uri: `${locusUrl}/controls`,
-          body: {
-            layout: {
-              deviceUrl,
-              type: layoutType,
-              layoutParams: {
-                renderInfo: {main: {width: 640, height: 480}, content: {width: 1280, height: 720}},
-              },
-            },
-          },
+        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}},
         });
       });
 
@@ -187,13 +127,12 @@ describe('plugin-meetings', () => {
     });
 
     describe('#joinMeeting', () => {
-      it('sends /call request for join', async () => {
+      it('sends /call requets for join', async () => {
         const locusUrl = 'locusURL';
         const deviceUrl = 'deviceUrl';
         const correlationId = 'random-uuid';
         const roapMessage = 'roap-message';
         const permissionToken = 'permission-token';
-        const installationId = 'installationId';
 
         await meetingsRequest.joinMeeting({
           locusUrl,
@@ -207,43 +146,9 @@ describe('plugin-meetings', () => {
         assert.equal(requestParams.method, 'POST');
         assert.equal(requestParams.uri, `${locusUrl}/participant?alternateRedirect=true`);
         assert.equal(requestParams.body.device.url, deviceUrl);
-        assert.equal(requestParams.body.device.installationId, installationId);
         assert.equal(requestParams.body.device.countryCode, 'US');
         assert.equal(requestParams.body.permissionToken, 'permission-token');
         assert.equal(requestParams.body.device.regionCode, 'WEST-COAST');
-        assert.include(requestParams.body.device.localIp, '127.0.0');
-
-        assert.calledOnceWithExactly(anonymizeIpSpy, '127.0.0.1');
-      });
-
-      describe('clientAddress geoHintInfo undefined', () => {
-        beforeEach(() => {
-          webex.meetings.geoHintInfo = {};
-        });
-
-        // reset
-        afterEach(() => {
-          webex.meetings.geoHintInfo = {...geoHintInfoDefaults};
-        });
-
-        it('doesnt send the clientAddress if not available as localIp', 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.body.device.localIp, undefined);
-        });
       });
 
       it('sends /call with meetingNumber if inviteeAddress does not exist', async () => {
@@ -285,111 +190,6 @@ describe('plugin-meetings', () => {
         assert.equal(requestParams.uri, 'locusUrl/loci/call?alternateRedirect=true');
         assert.equal(requestParams.body.invitee.address, 'sipUrl');
       });
-
-      it('sends uses the locusClusterUrl if available', async () => {
-        const deviceUrl = 'deviceUrl';
-        const correlationId = 'random-uuid';
-        const roapMessage = 'roap-message';
-        const inviteeAddress = 'sipUrl';
-        const locusClusterUrl = 'locusClusterUrl';
-
-        await meetingsRequest.joinMeeting({
-          deviceUrl,
-          correlationId,
-          roapMessage,
-          locusClusterUrl,
-          inviteeAddress,
-        });
-        const requestParams = meetingsRequest.request.getCall(0).args[0];
-
-        assert.equal(requestParams.method, 'POST');
-        assert.equal(
-          requestParams.uri,
-          'https://locusClusterUrl/locus/api/v1/loci/call?alternateRedirect=true'
-        );
-      });
-
-      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 and ipver 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,
-          ipVersion: IP_VERSION.ipv4_and_ipv6,
-        });
-        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,
-          ipver: 1,
-        });
-      });
     });
 
     describe('#pstn', () => {
@@ -405,20 +205,14 @@ describe('plugin-meetings', () => {
           correlationId,
           dialInUrl,
         });
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
 
-        checkRequest({
-          method: 'POST',
-          uri: `${locusUrl}/participant`,
-          body: {
-            device: {
-              url: dialInUrl,
-              deviceType: 'PROVISIONAL',
-              provisionalType: 'DIAL_IN',
-              clientUrl,
-            },
-            correlationId,
-          },
-        });
+        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');
       });
 
       it('sends dial out pstn request', async () => {
@@ -435,21 +229,15 @@ describe('plugin-meetings', () => {
           dialOutUrl,
           phoneNumber,
         });
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
 
-        checkRequest({
-          method: 'POST',
-          uri: `${locusUrl}/participant`,
-          body: {
-            device: {
-              url: dialOutUrl,
-              deviceType: 'PROVISIONAL',
-              provisionalType: 'DIAL_OUT',
-              clientUrl,
-              dialoutAddress: phoneNumber,
-            },
-            correlationId,
-          },
-        });
+        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 () => {
@@ -464,92 +252,12 @@ describe('plugin-meetings', () => {
           correlationId,
           phoneUrl,
         });
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
 
-        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,
-        });
-
-        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},
-          },
-        });
+        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');
       });
     });
 
@@ -560,11 +268,10 @@ describe('plugin-meetings', () => {
         await meetingsRequest.endMeetingForAll({
           locusUrl,
         });
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
 
-        checkRequest({
-          method: 'POST',
-          uri: `${locusUrl}/end`,
-        });
+        assert.equal(requestParams.method, 'POST');
+        assert.equal(requestParams.uri, `${locusUrl}/end`);
       });
     });
 
@@ -606,192 +313,5 @@ 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('#prepareLeaveMeetingRequestOptions', () => {
-      it('returns expected result', async () => {
-        const result = meetingsRequest.prepareLeaveMeetingRequestOptions({
-          locusUrl: 'locusUrl',
-          selfId: 'selfId',
-          correlationId: 'correlationId',
-          resourceId: 'resourceId',
-          deviceUrl: 'deviceUrl',
-        });
-
-        assert.deepEqual(result, {
-          body: {
-            correlationId: 'correlationId',
-            device: {
-              deviceType: undefined,
-              url: 'deviceUrl',
-            },
-            usingResource: 'resourceId',
-          },
-          method: 'PUT',
-          uri: 'locusUrl/participant/selfId/leave',
-        });
-      });
-    });
-
-    describe('#buildLeaveMeetingRequestOptions', () => {
-      it('calls expected functions and returns expected result', async () => {
-        // return this.buildLocusDeltaRequestOptions(this.prepareLeaveMeetingRequestOptions(options));
-        const prepareLeaveMeetingRequestOptionsSpy = sinon.spy(
-          meetingsRequest,
-          'prepareLeaveMeetingRequestOptions'
-        );
-        const buildLocusDeltaRequestOptionsSpy = sinon.spy(
-          meetingsRequest,
-          'buildLocusDeltaRequestOptions'
-        );
-
-        const inputOpts = {
-          locusUrl: 'locusUrl',
-          selfId: 'selfId',
-          correlationId: 'correlationId',
-          resourceId: 'resourceId',
-          deviceUrl: 'deviceUrl',
-        };
-
-        const result = meetingsRequest.buildLeaveMeetingRequestOptions(inputOpts);
-
-        assert.calledOnceWithExactly(prepareLeaveMeetingRequestOptionsSpy, inputOpts);
-        assert.calledOnceWithExactly(buildLocusDeltaRequestOptionsSpy, {
-          method: 'PUT',
-          uri: 'locusUrl/participant/selfId/leave',
-          body: {
-            device: {deviceType: undefined, url: 'deviceUrl'},
-            usingResource: 'resourceId',
-            correlationId: 'correlationId',
-          },
-        });
-
-        assert.deepEqual(result, {
-          body: {
-            correlationId: 'correlationId',
-            device: {
-              deviceType: undefined,
-              url: 'deviceUrl',
-            },
-            sequence: {},
-            usingResource: 'resourceId',
-          },
-          method: 'PUT',
-          uri: 'locusUrl/participant/selfId/leave',
-        });
-      });
-    });
-  });
-
-  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',
-        annotationInfo: {
-          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,
-      });
-    });
   });
 });