@webex/plugin-meetings 1.145.1 → 1.147.1

package/src/peer-connection-manager/index.js

@@ -186,7 +186,6 @@ pc.iceCandidate = (peerConnection, {remoteQualityLevel}) =>
     const timeout = setTimeout(() => {
       peerConnection.sdp = limitBandwidth(peerConnection.localDescription.sdp);
       peerConnection.sdp = setMaxFs(peerConnection.sdp, remoteQualityLevel);
-      peerConnection.sdp = peerConnection.sdp.replace(/\na=extmap.*/g, '');
 
       if (isSdpInvalid(peerConnection.sdp)) {
         setTimeout(() => {
@@ -214,7 +213,6 @@ pc.iceCandidate = (peerConnection, {remoteQualityLevel}) =>
       if (!evt.candidate && !peerConnection.sdp) {
         peerConnection.sdp = limitBandwidth(peerConnection.localDescription.sdp);
         peerConnection.sdp = setMaxFs(peerConnection.sdp, remoteQualityLevel);
-        peerConnection.sdp = peerConnection.sdp.replace(/\na=extmap.*/g, '');
 
         if (evt.candidate === null && !isSdpInvalid(peerConnection.sdp)) {
           clearTimeout(timeout);
@@ -292,9 +290,7 @@ pc.addStream = (peerConnection, stream) => {
  */
 pc.setRemoteSessionDetails = (peerConnection, typeStr, remoteSdp, meetingId) => {
   LoggerProxy.logger.log(`PeerConnectionManager:index#setRemoteSessionDetails --> Setting the remote description type: ${typeStr}State: ${peerConnection.signalingState}`);
-  let sdp = remoteSdp;
-
-  sdp = sdp.replace(/\na=extmap.*/g, '');
+  const sdp = remoteSdp;
 
   // making sure that the remoteDescription is only set when there is a answer for offer
   // or there is a offer from the server
@@ -363,9 +359,15 @@ pc.setRemoteSessionDetails = (peerConnection, typeStr, remoteSdp, meetingId) =>
  * @param {string} meetingProperties.meetingId
  * @param {string} meetingProperties.remoteQualityLevel LOW|MEDIUM|HIGH
  * @param {string} meetingProperties.enableRtx
+ * @param {string} meetingProperties.enableExtmap
  * @returns {RTCPeerConnection}
  */
-pc.createOffer = (peerConnection, {meetingId, remoteQualityLevel, enableRtx}) => {
+pc.createOffer = (peerConnection, {
+  meetingId,
+  remoteQualityLevel,
+  enableRtx,
+  enableExtmap
+}) => {
   LoggerProxy.logger.log('PeerConnectionManager:index#createOffer --> creating a new offer');
 
   return peerConnection
@@ -389,7 +391,11 @@ pc.createOffer = (peerConnection, {meetingId, remoteQualityLevel, enableRtx}) =>
       if (!checkH264Support(peerConnection.sdp)) {
         throw new MediaError('openH264 is downloading please Wait. Upload logs if not working on second try');
       }
-      peerConnection.sdp = peerConnection.sdp.replace(/\na=extmap.*/g, '');
+
+      if (!enableExtmap) {
+        peerConnection.sdp = peerConnection.sdp.replace(/\na=extmap.*/g, '');
+      }
+
       pc.setContentSlides(peerConnection);
 
       Metrics.postEvent({
@@ -512,8 +518,6 @@ pc.createAnswer = (params, {meetingId, remoteQualityLevel}) => {
         throw new MediaError('openH264 is downloading please Wait. Upload logs if not working on second try');
       }
 
-      peerConnection.sdp = peerConnection.sdp.replace(/\na=extmap.*/g, '');
-
       return peerConnection;
     })
     .catch((error) => {

package/src/reconnection-manager/index.js

@@ -459,7 +459,8 @@ export default class ReconnectionManager {
     return Media.attachMedia(this.meeting.mediaProperties, {
       meetingId: this.meeting.id,
       remoteQualityLevel: this.meeting.mediaProperties.remoteQualityLevel,
-      enableRtx: this.meeting.config.enableRtx
+      enableRtx: this.meeting.config.enableRtx,
+      enableExtmap: this.meeting.config.enableExtmap
     })
       .then((peerConnection) => this.meeting.setRemoteStream(peerConnection))
       .then(() => {

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

@@ -186,6 +186,22 @@ describe('plugin-meetings', () => {
           assert.calledWith(meeting.members.addMember, uuid1, false);
         });
       });
+      describe('#cancelPhoneInvite', () => {
+        it('should have #invite', () => {
+          assert.exists(meeting.cancelPhoneInvite);
+        });
+        beforeEach(() => {
+          meeting.members.cancelPhoneInvite = sinon.stub().returns(Promise.resolve(test1));
+        });
+        it('should proxy members #cancelPhoneInvite and return a promise', async () => {
+          const cancel = meeting.cancelPhoneInvite(uuid1);
+
+          assert.exists(cancel.then);
+          await cancel;
+          assert.calledOnce(meeting.members.cancelPhoneInvite);
+          assert.calledWith(meeting.members.cancelPhoneInvite, uuid1);
+        });
+      });
       describe('#admit', () => {
         it('should have #admit', () => {
           assert.exists(meeting.admit);

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

@@ -0,0 +1,192 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import sinon from 'sinon';
+import uuid from 'uuid';
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import {Credentials} from '@webex/webex-core';
+import Support from '@webex/internal-plugin-support';
+import MockWebex from '@webex/test-helper-mock-webex';
+import Meetings from '@webex/plugin-meetings';
+import Members from '@webex/plugin-meetings/src/members';
+import MembersUtil from '@webex/plugin-meetings/src/members/util';
+
+const {assert} = chai;
+
+chai.use(chaiAsPromised);
+sinon.assert.expose(chai.assert, {prefix: ''});
+
+
+describe('plugin-meetings', () => {
+  let webex;
+  let url1;
+  const fakeMembersCollection = {
+    test1: {
+      namespace: 'Meetings',
+      participant: {
+        state: 'JOINED',
+        type: 'USER',
+        person: {
+          id: '6eb08f8b-bf69-3251-a126-b161bead2d21',
+          phoneNumber: '+18578675309',
+          isExternal: true,
+          primaryDisplayString: '+18578675309'
+        },
+        devices: [
+          {
+            url: 'https://fakeURL.com',
+            deviceType: 'SIP',
+            state: 'JOINED',
+            intents: [
+              null
+            ],
+            correlationId: '1234',
+            provisionalUrl: 'dialout:///fake',
+            isSparkPstn: true
+          },
+          {
+            url: 'dialout:///fakeagain',
+            deviceType: 'PROVISIONAL',
+            state: 'JOINED',
+            intents: [
+              null
+            ],
+            correlationId: '4321',
+            isVideoCallback: false,
+            clientUrl: 'https://fakeURL',
+            provisionalType: 'DIAL_OUT_ONLY',
+            dialingStatus: 'SUCCESS'
+          }
+        ],
+        status: {
+          audioStatus: 'SENDRECV',
+          videoStatus: 'INACTIVE'
+        },
+        id: 'abc-123-abc-123',
+        guest: true,
+        resourceGuest: false,
+        moderator: false,
+        panelist: false,
+        moveToLobbyNotAllowed: true,
+        deviceUrl: 'https://fakeDeviceurl'
+      },
+      id: 'abc-123-abc-123',
+      status: 'IN_MEETING',
+      type: 'MEETING',
+      isModerator: false
+    }
+  };
+
+
+  describe('members', () => {
+    const sandbox = sinon.createSandbox();
+    let createMembers;
+
+    beforeEach(() => {
+      webex = new MockWebex({
+        children: {
+          meetings: Meetings,
+          credentials: Credentials,
+          support: Support
+        },
+        config: {
+          credentials: {
+            client_id: 'mock-client-id'
+          },
+          meetings: {
+            reconnection: {
+              enabled: false
+            },
+            mediaSettings: {},
+            metrics: {},
+            stats: {}
+          }
+        }
+      });
+
+      url1 = `https://example.com/${uuid.v4()}`;
+
+      createMembers = (options) => new Members({locusUrl: options.url}, {parent: webex});
+    });
+
+    afterEach(() => {
+      sandbox.restore();
+    });
+
+    describe('#addMembers', () => {
+      it('should invoke isInvalidInvitee and generateAddMemberOptions from MembersUtil when addMember is called with valid params', async () => {
+        sandbox.spy(MembersUtil, 'isInvalidInvitee');
+        sandbox.spy(MembersUtil, 'generateAddMemberOptions');
+
+        const members = createMembers({url: url1});
+
+        await members.addMember({phoneNumber: '+18578675309'});
+        assert.calledOnce(MembersUtil.isInvalidInvitee);
+        assert.calledOnce(MembersUtil.generateAddMemberOptions);
+      });
+
+      it('should throw a rejection if there is no locus url', async () => {
+        const members = createMembers({url: false});
+
+        assert.isRejected(members.addMember({email: 'test@cisco.com'}));
+      });
+    });
+
+    describe('#sendDialPadKey', () => {
+      it('should throw a rejection when calling sendDialPadKey with no tones', async () => {
+        const members = createMembers({url: url1});
+
+        assert.isRejected(members.sendDialPadKey());
+      });
+
+      it('should throw a rejection when calling sendDialPadKey with no member is found', async () => {
+        const members = createMembers({url: url1});
+
+        assert.isRejected(members.sendDialPadKey('1', '1234'));
+      });
+
+      it('should call genderateSendDTMFOptions with proper options on Members util if we the member is valid', async () => {
+        sandbox.spy(MembersUtil, 'genderateSendDTMFOptions');
+        const members = createMembers({url: url1});
+
+        members.membersCollection.setAll(fakeMembersCollection);
+        await members.sendDialPadKey('1', 'test1');
+        assert.calledWith(MembersUtil.genderateSendDTMFOptions, 'https://fakeURL.com', '1', 'test1', url1);
+      });
+
+      it('should call the sendDialPadKey method on membersRequest if the member is valid', async () => {
+        const members = createMembers({url: url1});
+
+        const {membersRequest} = members;
+
+        assert.exists(membersRequest);
+        const sendDialPadKeyspy = sandbox.spy(membersRequest, 'sendDialPadKey');
+
+        members.membersCollection.setAll(fakeMembersCollection);
+        await members.sendDialPadKey('1', 'test1');
+        assert.calledOnce(sendDialPadKeyspy);
+      });
+    });
+
+    describe('#cancelPhoneInvite', () => {
+      it('should invoke isInvalidInvitee and generateAddMemberOptions from MembersUtil when addMember is called with valid params', async () => {
+        sandbox.spy(MembersUtil, 'isInvalidInvitee');
+        sandbox.spy(MembersUtil, 'cancelPhoneInviteOptions');
+
+        const members = createMembers({url: url1});
+
+        await members.cancelPhoneInvite({phoneNumber: '+18578675309'});
+        assert.calledOnce(MembersUtil.isInvalidInvitee);
+        assert.calledOnce(MembersUtil.cancelPhoneInviteOptions);
+      });
+
+      it('should throw a rejection if there is no locus url', async () => {
+        const members = createMembers({url: false});
+
+        assert.isRejected(members.cancelPhoneInvite({phoneNumber: '+18578675309'}));
+      });
+    });
+  });
+});

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

@@ -0,0 +1,101 @@
+import sinon from 'sinon';
+import chai from 'chai';
+import uuid from 'uuid';
+import chaiAsPromised from 'chai-as-promised';
+import MockWebex from '@webex/test-helper-mock-webex';
+import Meetings from '@webex/plugin-meetings';
+import MembersRequest from '@webex/plugin-meetings/src/members/request';
+
+const {assert} = chai;
+
+chai.use(chaiAsPromised);
+sinon.assert.expose(chai.assert, {prefix: ''});
+
+describe('plugin-meetings', () => {
+  let membersRequest;
+  let url1;
+  let sandbox;
+
+  beforeEach(() => {
+    const webex = new MockWebex({
+      children: {
+        meetings: Meetings
+      }
+    });
+
+    sandbox = sinon.createSandbox();
+
+    url1 = `https://example.com/${uuid.v4()}`;
+
+    membersRequest = new MembersRequest({}, {
+      parent: webex
+    });
+    membersRequest.request = sinon.mock().returns(Promise.resolve({}));
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+
+  describe('members request library', () => {
+    describe('#sendDialPadKey', () => {
+      it('sends a POST to the sendDtmf locus endpoint', async () => {
+        const locusUrl = url1;
+        const url = 'https://fakedeviceurl.com';
+        const tones = '1';
+        const memberId = 'test1';
+
+        await membersRequest.sendDialPadKey({
+          url,
+          tones,
+          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);
+      });
+    });
+
+    describe('#addMembers', () => {
+      it('sends a PUT to the locus endpoint', async () => {
+        const options = {
+          invitee: {
+            phoneNumber: '+18578675309'
+          },
+          locusUrl: url1
+        };
+
+        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');
+      });
+    });
+
+    describe('#cancelPhoneInvite', () => {
+      it('sends a PUT to the locus endpoint', async () => {
+        const options = {
+          invitee: {
+            phoneNumber: '+18578675309'
+          },
+          locusUrl: url1
+        };
+
+        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');
+      });
+    });
+  });
+});