@webex/plugin-meetings 1.151.7 → 1.153.1

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

@@ -31,8 +31,11 @@ import {
   FLOOR_ACTION,
   SHARE_STATUS,
   METRICS_OPERATIONAL_MEASURES,
+  MEETING_INFO_FAILURE_REASON,
+  PASSWORD_STATUS,
   EVENTS,
-  EVENT_TRIGGERS
+  EVENT_TRIGGERS,
+  _SIP_URI_
 } from '@webex/plugin-meetings/src/constants';
 
 import {
@@ -43,8 +46,11 @@ import {
 } from '../../../../src/common/errors/webex-errors';
 import WebExMeetingsErrors from '../../../../src/common/errors/webex-meetings-error';
 import ParameterError from '../../../../src/common/errors/parameter';
+import PasswordError from '../../../../src/common/errors/password-error';
+import CaptchaError from '../../../../src/common/errors/captcha-error';
 import DefaultSDKConfig from '../../../../src/config';
 import testUtils from '../../../utils/testUtils';
+import {MeetingInfoV2CaptchaError, MeetingInfoV2PasswordError} from '../../../../src/meeting-info/meeting-info-v2';
 
 const {
   getBrowserName
@@ -98,7 +104,8 @@ describe('plugin-meetings', () => {
           },
           mediaSettings: {},
           metrics: {},
-          stats: {}
+          stats: {},
+          experimental: {enableUnifiedMeetings: true}
         }
       }
     });
@@ -173,6 +180,9 @@ describe('plugin-meetings', () => {
           assert.instanceOf(meeting.meetingRequest, MeetingRequest);
           assert.instanceOf(meeting.locusInfo, LocusInfo);
           assert.instanceOf(meeting.mediaProperties, MediaProperties);
+          assert.equal(meeting.passwordStatus, PASSWORD_STATUS.UNKNOWN);
+          assert.equal(meeting.requiredCaptcha, null);
+          assert.equal(meeting.meetingInfoFailureReason, undefined);
         });
       });
       describe('#invite', () => {
@@ -632,7 +642,7 @@ describe('plugin-meetings', () => {
           });
 
           it('should create new correlation ID when already joined', async () => {
-            meeting.isCreated = false;
+            meeting.hasJoinedOnce = true;
             await meeting.join();
             sinon.assert.called(meeting.setCorrelationId);
           });
@@ -653,6 +663,14 @@ describe('plugin-meetings', () => {
               });
             });
           });
+          it('should fail if password is required', async () => {
+            meeting.passwordStatus = PASSWORD_STATUS.REQUIRED;
+            await assert.isRejected(meeting.join(), PasswordError);
+          });
+          it('should fail if captcha is required', async () => {
+            meeting.requiredCaptcha = {captchaId: 'aaa'};
+            await assert.isRejected(meeting.join(), CaptchaError);
+          });
           describe('total failure', () => {
             beforeEach(() => {
               MeetingUtil.isPinOrGuest = sinon.stub().returns(false);
@@ -2010,6 +2028,279 @@ describe('plugin-meetings', () => {
         });
       });
 
+      describe('#fetchMeetingInfo', () => {
+        const FAKE_DESTINATION = 'something@somecompany.com';
+        const FAKE_TYPE = _SIP_URI_;
+        const FAKE_PASSWORD = '123abc';
+        const FAKE_CAPTCHA_CODE = 'a1b2c3XYZ';
+        const FAKE_CAPTCHA_ID = '987654321';
+        const FAKE_CAPTCHA_IMAGE_URL = 'http://captchaimage';
+        const FAKE_CAPTCHA_AUDIO_URL = 'http://captchaaudio';
+        const FAKE_CAPTCHA_REFRESH_URL = 'http://captcharefresh';
+        const FAKE_MEETING_INFO = {
+          conversationUrl: 'some_convo_url',
+          locusUrl: 'some_locus_url',
+          sipUrl: 'some_sip_url', // or sipMeetingUri
+          meetingNumber: '123456', // this.config.experimental.enableUnifiedMeetings
+          hostId: 'some_host_id' // this.owner;
+        };
+        const FAKE_SDK_CAPTCHA_INFO = {
+          captchaId: FAKE_CAPTCHA_ID,
+          verificationImageURL: FAKE_CAPTCHA_IMAGE_URL,
+          verificationAudioURL: FAKE_CAPTCHA_AUDIO_URL,
+          refreshURL: FAKE_CAPTCHA_REFRESH_URL
+        };
+        const FAKE_WBXAPPAPI_CAPTCHA_INFO = {
+          captchaID: `${FAKE_CAPTCHA_ID}-2`,
+          verificationImageURL: `${FAKE_CAPTCHA_IMAGE_URL}-2`,
+          verificationAudioURL: `${FAKE_CAPTCHA_AUDIO_URL}-2`,
+          refreshURL: `${FAKE_CAPTCHA_REFRESH_URL}-2`
+        };
+
+
+        it('calls meetingInfoProvider with all the right parameters and parses the result', async () => {
+          meeting.attrs.meetingInfoProvider = {fetchMeetingInfo: sinon.stub().resolves({body: FAKE_MEETING_INFO})};
+          meeting.requiredCaptcha = FAKE_SDK_CAPTCHA_INFO;
+          await meeting.fetchMeetingInfo({
+            destination: FAKE_DESTINATION, type: FAKE_TYPE, password: FAKE_PASSWORD, captchaCode: FAKE_CAPTCHA_CODE
+          });
+
+          assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, FAKE_PASSWORD, {code: FAKE_CAPTCHA_CODE, id: FAKE_CAPTCHA_ID});
+
+          assert.deepEqual(meeting.meetingInfo, FAKE_MEETING_INFO);
+          assert.equal(meeting.passwordStatus, PASSWORD_STATUS.NOT_REQUIRED);
+          assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.NONE);
+          assert.equal(meeting.requiredCaptcha, null);
+        });
+
+        it('fails if captchaCode is provided when captcha not needed', async () => {
+          meeting.attrs.meetingInfoProvider = {fetchMeetingInfo: sinon.stub().resolves({body: FAKE_MEETING_INFO})};
+          meeting.requiredCaptcha = null;
+
+          await assert.isRejected(meeting.fetchMeetingInfo({
+            destination: FAKE_DESTINATION, type: FAKE_TYPE, captchaCode: FAKE_CAPTCHA_CODE
+          }), Error, 'fetchMeetingInfo() called with captchaCode when captcha was not required');
+
+          assert.notCalled(meeting.attrs.meetingInfoProvider.fetchMeetingInfo);
+        });
+
+        it('fails if password is provided when not required', async () => {
+          meeting.attrs.meetingInfoProvider = {fetchMeetingInfo: sinon.stub().resolves({body: FAKE_MEETING_INFO})};
+          meeting.passwordStatus = PASSWORD_STATUS.NOT_REQUIRED;
+
+          await assert.isRejected(meeting.fetchMeetingInfo({
+            destination: FAKE_DESTINATION, type: FAKE_TYPE, password: FAKE_PASSWORD
+          }), Error, 'fetchMeetingInfo() called with password when password was not required');
+
+          assert.notCalled(meeting.attrs.meetingInfoProvider.fetchMeetingInfo);
+        });
+
+        it('handles meetingInfoProvider requiring password', async () => {
+          meeting.attrs.meetingInfoProvider = {
+            fetchMeetingInfo: sinon.stub().throws(new MeetingInfoV2PasswordError(403004, FAKE_MEETING_INFO))
+          };
+
+          await assert.isRejected(meeting.fetchMeetingInfo({
+            destination: FAKE_DESTINATION, type: FAKE_TYPE
+          }), PasswordError);
+
+          assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, null, null);
+
+          assert.deepEqual(meeting.meetingInfo, FAKE_MEETING_INFO);
+          assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD);
+          assert.equal(meeting.requiredCaptcha, null);
+          assert.equal(meeting.passwordStatus, PASSWORD_STATUS.REQUIRED);
+        });
+
+        it('handles meetingInfoProvider requiring captcha because of wrong password', async () => {
+          meeting.attrs.meetingInfoProvider = {
+            fetchMeetingInfo: sinon.stub().throws(new MeetingInfoV2CaptchaError(423005, FAKE_SDK_CAPTCHA_INFO))
+          };
+          meeting.requiredCaptcha = null;
+
+          await assert.isRejected(meeting.fetchMeetingInfo({
+            destination: FAKE_DESTINATION, type: FAKE_TYPE, password: 'aaa'
+          }), CaptchaError);
+
+          assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, 'aaa', null);
+
+          assert.deepEqual(meeting.meetingInfo, {});
+          assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD);
+          assert.equal(meeting.passwordStatus, PASSWORD_STATUS.REQUIRED);
+          assert.deepEqual(meeting.requiredCaptcha, {
+            captchaId: FAKE_CAPTCHA_ID,
+            verificationImageURL: FAKE_CAPTCHA_IMAGE_URL,
+            verificationAudioURL: FAKE_CAPTCHA_AUDIO_URL,
+            refreshURL: FAKE_CAPTCHA_REFRESH_URL
+          });
+        });
+
+        it('handles meetingInfoProvider requiring captcha because of wrong captcha', async () => {
+          meeting.attrs.meetingInfoProvider = {
+            fetchMeetingInfo: sinon.stub().throws(new MeetingInfoV2CaptchaError(423005, FAKE_SDK_CAPTCHA_INFO))
+          };
+          meeting.requiredCaptcha = FAKE_SDK_CAPTCHA_INFO;
+
+          await assert.isRejected(meeting.fetchMeetingInfo({
+            destination: FAKE_DESTINATION, type: FAKE_TYPE, password: 'aaa', captchaCode: 'bbb'
+          }), CaptchaError);
+
+          assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, 'aaa', {code: 'bbb', id: FAKE_CAPTCHA_ID});
+
+          assert.deepEqual(meeting.meetingInfo, {});
+          assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.WRONG_CAPTCHA);
+          assert.equal(meeting.passwordStatus, PASSWORD_STATUS.REQUIRED);
+          assert.deepEqual(meeting.requiredCaptcha, FAKE_SDK_CAPTCHA_INFO);
+        });
+
+        it('handles successful response when good password is passed', async () => {
+          meeting.attrs.meetingInfoProvider = {
+            fetchMeetingInfo: sinon.stub().resolves(
+              {
+                statusCode: 200,
+                body: FAKE_MEETING_INFO
+              }
+            )
+          };
+          meeting.passwordStatus = PASSWORD_STATUS.REQUIRED;
+
+          await meeting.fetchMeetingInfo({
+            destination: FAKE_DESTINATION, type: FAKE_TYPE, password: 'aaa'
+          });
+
+          assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, 'aaa', null);
+
+          assert.deepEqual(meeting.meetingInfo, FAKE_MEETING_INFO);
+          assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.NONE);
+          assert.equal(meeting.passwordStatus, PASSWORD_STATUS.VERIFIED);
+          assert.equal(meeting.requiredCaptcha, null);
+        });
+
+        it('refreshes captcha when captcha was required and we received 403 error code', async () => {
+          const refreshedCaptcha = {
+            captchaID: FAKE_WBXAPPAPI_CAPTCHA_INFO.captchaID,
+            verificationImageURL: FAKE_WBXAPPAPI_CAPTCHA_INFO.verificationImageURL,
+            verificationAudioURL: FAKE_WBXAPPAPI_CAPTCHA_INFO.verificationAudioURL
+          };
+
+          meeting.attrs.meetingInfoProvider = {
+            fetchMeetingInfo: sinon.stub().throws(new MeetingInfoV2PasswordError(403004, FAKE_MEETING_INFO))
+          };
+          meeting.meetingRequest.refreshCaptcha = sinon.stub().returns(Promise.resolve(
+            {
+              body: refreshedCaptcha
+            }
+          ));
+          meeting.passwordStatus = PASSWORD_STATUS.REQUIRED;
+          meeting.requiredCaptcha = FAKE_SDK_CAPTCHA_INFO;
+
+          await assert.isRejected(meeting.fetchMeetingInfo({
+            destination: FAKE_DESTINATION, type: FAKE_TYPE, password: 'aaa', captchaCode: 'bbb'
+          }));
+
+          assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, 'aaa', {code: 'bbb', id: FAKE_CAPTCHA_ID});
+
+          assert.deepEqual(meeting.meetingInfo, FAKE_MEETING_INFO);
+          assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD);
+          assert.equal(meeting.passwordStatus, PASSWORD_STATUS.REQUIRED);
+          assert.deepEqual(meeting.requiredCaptcha, {
+            captchaId: refreshedCaptcha.captchaID,
+            verificationImageURL: refreshedCaptcha.verificationImageURL,
+            verificationAudioURL: refreshedCaptcha.verificationAudioURL,
+            refreshURL: FAKE_SDK_CAPTCHA_INFO.refreshURL // refresh url doesn't change
+          });
+        });
+      });
+
+      describe('#refreshCaptcha', () => {
+        it('fails if no captcha required', async () => {
+          assert.isRejected(meeting.refreshCaptcha(), Error);
+        });
+        it('sends correct request to captcha service refresh url', async () => {
+          const REFRESH_URL = 'https://something.webex.com/captchaservice/v1/captchas/refresh?blablabla=something&captchaID=xxx';
+          const EXPECTED_REFRESH_URL = 'https://something.webex.com/captchaservice/v1/captchas/refresh?blablabla=something&captchaID=xxx&siteFullName=something.webex.com';
+
+          const FAKE_SDK_CAPTCHA_INFO = {
+            captchaId: 'some id',
+            verificationImageURL: 'some image url',
+            verificationAudioURL: 'some audio url',
+            refreshURL: REFRESH_URL
+          };
+
+          const FAKE_REFRESHED_CAPTCHA = {
+            captchaID: 'some id',
+            verificationImageURL: 'some image url',
+            verificationAudioURL: 'some audio url'
+          };
+
+          // setup the meeting so that a captcha is required
+          meeting.attrs.meetingInfoProvider = {
+            fetchMeetingInfo: sinon.stub().throws(new MeetingInfoV2CaptchaError(423005, FAKE_SDK_CAPTCHA_INFO))
+          };
+
+          await assert.isRejected(meeting.fetchMeetingInfo({
+            destination: 'something@somecompany.com', type: _SIP_URI_, password: ''
+          }), CaptchaError);
+
+          assert.deepEqual(meeting.requiredCaptcha, FAKE_SDK_CAPTCHA_INFO);
+          meeting.meetingRequest.refreshCaptcha = sinon.stub().returns(Promise.resolve({body: FAKE_REFRESHED_CAPTCHA}));
+
+          // test the captcha refresh
+          await meeting.refreshCaptcha();
+
+          assert.calledWith(meeting.meetingRequest.refreshCaptcha,
+            {
+              captchaRefreshUrl: EXPECTED_REFRESH_URL,
+              captchaId: FAKE_SDK_CAPTCHA_INFO.captchaId
+            });
+
+          assert.deepEqual(meeting.requiredCaptcha, {
+            captchaId: FAKE_REFRESHED_CAPTCHA.captchaID,
+            verificationImageURL: FAKE_REFRESHED_CAPTCHA.verificationImageURL,
+            verificationAudioURL: FAKE_REFRESHED_CAPTCHA.verificationAudioURL,
+            refreshURL: FAKE_SDK_CAPTCHA_INFO.refreshURL // refresh url doesn't change
+          });
+        });
+      });
+
+      describe('#verifyPassword', () => {
+        it('calls fetchMeetingInfo() with the passed password and captcha code', async () => {
+          // simulate successful case
+          meeting.fetchMeetingInfo = sinon.stub().resolves();
+          const result = await meeting.verifyPassword('password', 'captcha id');
+
+          assert.equal(result.isPasswordValid, true);
+          assert.equal(result.requiredCaptcha, null);
+          assert.equal(result.failureReason, MEETING_INFO_FAILURE_REASON.NONE);
+        });
+        it('handles PasswordError returned by fetchMeetingInfo', async () => {
+          meeting.fetchMeetingInfo = sinon.stub().callsFake(() => {
+            meeting.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD;
+
+            return Promise.reject(new PasswordError());
+          });
+          const result = await meeting.verifyPassword('password', 'captcha id');
+
+          assert.equal(result.isPasswordValid, false);
+          assert.equal(result.requiredCaptcha, null);
+          assert.equal(result.failureReason, MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD);
+        });
+        it('handles CaptchaError returned by fetchMeetingInfo', async () => {
+          const FAKE_CAPTCHA = {captchaId: 'some catcha id...'};
+
+          meeting.fetchMeetingInfo = sinon.stub().callsFake(() => {
+            meeting.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.WRONG_CAPTCHA;
+            meeting.requiredCaptcha = FAKE_CAPTCHA;
+
+            return Promise.reject(new CaptchaError());
+          });
+          const result = await meeting.verifyPassword('password', 'captcha id');
+
+          assert.equal(result.isPasswordValid, false);
+          assert.deepEqual(result.requiredCaptcha, FAKE_CAPTCHA);
+          assert.equal(result.failureReason, MEETING_INFO_FAILURE_REASON.WRONG_CAPTCHA);
+        });
+      });
       describe('#mediaNegotiatedEvent', () => {
         it('should have #mediaNegotiatedEvent', () => {
           assert.exists(meeting.mediaNegotiatedEvent);

package/test/unit/spec/meeting-info/meetinginfov2.js

@@ -12,7 +12,7 @@ import {
   _MEETING_ID_,
   _PERSONAL_ROOM_
 } from '@webex/plugin-meetings/src/constants';
-import MeetingInfo from '@webex/plugin-meetings/src/meeting-info/meeting-info-v2';
+import MeetingInfo, {MeetingInfoV2PasswordError, MeetingInfoV2CaptchaError} from '@webex/plugin-meetings/src/meeting-info/meeting-info-v2';
 import MeetingInfoUtil from '@webex/plugin-meetings/src/meeting-info/utilv2';
 
 describe('plugin-meetings', () => {
@@ -80,6 +80,79 @@ describe('plugin-meetings', () => {
         MeetingInfoUtil.getDestinationType.restore();
         MeetingInfoUtil.getRequestBody.restore();
       });
+
+      it('should fetch meeting info with provided password and captcha code', async () => {
+        await meetingInfo.fetchMeetingInfo('1234323', _MEETING_ID_, 'abc', {id: '999', code: 'aabbcc11'});
+
+        assert.calledWith(webex.request, {
+          method: 'POST',
+          service: 'webex-appapi-service',
+          resource: 'meetingInfo',
+          body: {
+            supportHostKey: true,
+            meetingKey: '1234323',
+            password: 'abc',
+            captchaID: '999',
+            captchaVerifyCode: 'aabbcc11'
+          }
+        });
+      });
+
+      it('should throw MeetingInfoV2PasswordError for 403 response', async () => {
+        const FAKE_MEETING_INFO = {blablabla: 'some_fake_meeting_info'};
+
+        webex.request = sinon.stub().rejects({statusCode: 403, body: {code: 403000, data: {meetingInfo: FAKE_MEETING_INFO}}});
+
+        try {
+          await meetingInfo.fetchMeetingInfo('1234323', _MEETING_ID_, 'abc', {id: '999', code: 'aabbcc11'});
+          assert.fail('fetchMeetingInfo should have thrown, but has not done that');
+        }
+        catch (err) {
+          assert.instanceOf(err, MeetingInfoV2PasswordError);
+          assert.deepEqual(err.meetingInfo, FAKE_MEETING_INFO);
+          assert.equal(err.wbxAppApiCode, 403000);
+        }
+      });
+
+      describe('should throw MeetingInfoV2CaptchaError for 423 response', () => {
+        const runTest = async (wbxAppApiCode, expectedIsPasswordRequired) => {
+          webex.request = sinon.stub().rejects(
+            {
+              statusCode: 423,
+              body: {
+                code: wbxAppApiCode,
+                captchaID: 'fake_captcha_id',
+                verificationImageURL: 'fake_image_url',
+                verificationAudioURL: 'fake_audio_url',
+                refreshURL: 'fake_refresh_url'
+              }
+            }
+          );
+          try {
+            await meetingInfo.fetchMeetingInfo('1234323', _MEETING_ID_, 'abc', {id: '999', code: 'aabbcc11'});
+            assert.fail('fetchMeetingInfo should have thrown, but has not done that');
+          }
+          catch (err) {
+            assert.instanceOf(err, MeetingInfoV2CaptchaError);
+            assert.deepEqual(err.captchaInfo, {
+              captchaId: 'fake_captcha_id',
+              verificationImageURL: 'fake_image_url',
+              verificationAudioURL: 'fake_audio_url',
+              refreshURL: 'fake_refresh_url'
+            });
+            assert.equal(err.wbxAppApiCode, wbxAppApiCode);
+            assert.equal(err.isPasswordRequired, expectedIsPasswordRequired);
+          }
+        };
+
+        it('should throw MeetingInfoV2CaptchaError for 423 response (wbxappapi code 423005)', async () => {
+          await runTest(423005, true);
+        });
+
+        it('should throw MeetingInfoV2CaptchaError for 423 response (wbxappapi code 423001)', async () => {
+          await runTest(423001, false);
+        });
+      });
     });
   });
 });

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

@@ -68,6 +68,12 @@ skipInBrowser(describe)('plugin-meetings', () => {
         }
       });
 
+      Object.assign(webex.meetings.config, {
+        experimental: {
+          enableUnifiedMeetings: true
+        }
+      });
+
       Object.assign(webex.internal, {
         device: {
           deviceType: 'FAKE_DEVICE',
@@ -97,6 +103,29 @@ skipInBrowser(describe)('plugin-meetings', () => {
       assert.calledOnce(MeetingsUtil.triggerH264Codec);
     });
 
+    describe('#_toggleUnifiedMeetings', () => {
+      it('should have toggleUnifiedMeetings', () => {
+        assert.equal(typeof webex.meetings._toggleUnifiedMeetings, 'function');
+      });
+
+      describe('success', () => {
+        it('should update meeting info to v1', () => {
+          webex.meetings._toggleUnifiedMeetings(false);
+          assert.equal(webex.meetings.config.experimental.enableUnifiedMeetings, false);
+          assert.equal(webex.meetings.meetingInfo.constructor.name, 'MeetingInfo');
+        });
+      });
+
+      describe('failure', () => {
+        it('should not accept non boolean input', () => {
+          const currentEnableUnifiedMeetings = webex.meetings.config.experimental.enableUnifiedMeetings;
+
+          webex.meetings._toggleUnifiedMeetings('test');
+          assert.equal(webex.meetings.config.experimental.enableUnifiedMeetings, currentEnableUnifiedMeetings);
+        });
+      });
+    });
+
     describe('Public API Contracts', () => {
       describe('#register', () => {
         it('emits an event and resolves when register succeeds', (done) => {

package/test/unit/spec/peerconnection-manager/index.js

@@ -0,0 +1,66 @@
+
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+import PeerConnectionManager from '@webex/plugin-meetings/src/peer-connection-manager/index';
+import StaticConfig from '@webex/plugin-meetings/src/common/config';
+
+describe('Peerconnection Manager', () => {
+  describe('Methods', () => {
+    describe('setRemoteSessionDetails', () => {
+      it('change the start bitrate on remoteSDP', async () => {
+        StaticConfig.set({bandwidth: {audio: 50, video: 500, startBitrate: 2000}});
+        let result = null;
+        const setRemoteDescription = sinon.stub().callsFake((args) => {
+          result = args;
+
+          return Promise.resolve();
+        });
+        const remoteSdp = 'v=0\r\n' +
+        'm=video 5004 UDP/TLS/RTP/SAVPF 102 127 97 99\r\n' +
+        'a=fmtp:102 profile-level-id=42e016;packetization-mode=1;max-mbps=244800;max-fs=8160;max-fps=3000;max-dpb=12240;max-rcmd-nalu-size=196608;level-asymmetry-allowed=1\r\n' +
+        'a=rtpmap:127 H264/90000\r\n' +
+        'a=fmtp:127 profile-level-id=42e016;max-mbps=244800;max-fs=8160;max-fps=3000;max-dpb=12240;max-rcmd-nalu-size=196608;level-asymmetry-allowed=1\r\n';
+
+        const resultSdp = 'v=0\r\n' +
+        'm=video 5004 UDP/TLS/RTP/SAVPF 102 127 97 99\r\n' +
+        'a=fmtp:102 profile-level-id=42e016;packetization-mode=1;max-mbps=244800;max-fs=8160;max-fps=3000;max-dpb=12240;max-rcmd-nalu-size=196608;level-asymmetry-allowed=1;x-google-start-bitrate=2000\r\n' +
+        'a=rtpmap:127 H264/90000\r\n' +
+        'a=fmtp:127 profile-level-id=42e016;max-mbps=244800;max-fs=8160;max-fps=3000;max-dpb=12240;max-rcmd-nalu-size=196608;level-asymmetry-allowed=1;x-google-start-bitrate=2000\r\n';
+        const peerConnection = {
+          signalingState: 'have-local-offer',
+          setRemoteDescription
+
+        };
+
+        await PeerConnectionManager.setRemoteSessionDetails(peerConnection, 'answer', remoteSdp, {});
+
+        assert.equal(result.sdp, resultSdp);
+      });
+
+      it('dont change the start bitrate on remoteSDP if default value is 0', async () => {
+        StaticConfig.set({bandwidth: {audio: 50, video: 500, startBitrate: 0}});
+        let result = null;
+        const setRemoteDescription = sinon.stub().callsFake((args) => {
+          result = args;
+
+          return Promise.resolve();
+        });
+        const remoteSdp = 'v=0\r\n' +
+        'm=video 5004 UDP/TLS/RTP/SAVPF 102 127 97 99\r\n' +
+        'a=fmtp:102 profile-level-id=42e016;packetization-mode=1;max-mbps=244800;max-fs=8160;max-fps=3000;max-dpb=12240;max-rcmd-nalu-size=196608;level-asymmetry-allowed=1\r\n' +
+        'a=rtpmap:127 H264/90000\r\n' +
+        'a=fmtp:127 profile-level-id=42e016;max-mbps=244800;max-fs=8160;max-fps=3000;max-dpb=12240;max-rcmd-nalu-size=196608;level-asymmetry-allowed=1\r\n';
+
+        const peerConnection = {
+          signalingState: 'have-local-offer',
+          setRemoteDescription
+
+        };
+
+        await PeerConnectionManager.setRemoteSessionDetails(peerConnection, 'answer', remoteSdp, {});
+
+        assert.equal(result.sdp, remoteSdp);
+      });
+    });
+  });
+});

package/test/unit/spec/peerconnection-manager/utils.js

@@ -0,0 +1,25 @@
+
+import {assert} from '@webex/test-helper-chai';
+import PeerConnectionUtils from '@webex/plugin-meetings/src/peer-connection-manager/util';
+
+describe('Peerconnection Manager', () => {
+  describe('Utils', () => {
+    describe('convertCLineToIpv4', () => {
+      it('changes ipv6 to ipv4 default', () => {
+        const localSdp = 'v=0\r\n' +
+        'm=video 5004 UDP/TLS/RTP/SAVPF 102 127 97 99\r\n' +
+        'c=IN IP6 2607:fb90:d27c:b314:211a:32dd:c47f:ffe\r\n' +
+        'a=rtpmap:127 H264/90000\r\n';
+        const resultSdp = 'v=0\r\n' +
+        'm=video 5004 UDP/TLS/RTP/SAVPF 102 127 97 99\r\n' +
+        'c=IN IP4 0.0.0.0\r\n' +
+        'a=rtpmap:127 H264/90000\r\n';
+
+
+        const temp = PeerConnectionUtils.convertCLineToIpv4(localSdp);
+
+        assert.equal(temp, resultSdp);
+      });
+    });
+  });
+});