@webex/plugin-meetings 2.14.0 → 2.14.3

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

@@ -42,6 +42,7 @@ import {
 } from '@webex/plugin-meetings/src/constants';
 import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
 
+import locus from '../fixture/locus';
 import {
   UserNotJoinedError,
   MeetingNotActiveError,
@@ -724,16 +725,12 @@ describe('plugin-meetings', () => {
       });
       describe('#isTranscriptionSupported', () => {
         it('should return false if the feature is not supported for the meeting', () => {
-          meeting.policy = {
-            WEBEX_ASSISTANT_STATUS_INACTIVE: true
-          };
+          meeting.locusInfo.controls = {transcribe: {transcribing: false}};
 
           assert.equal(meeting.isTranscriptionSupported(), false);
         });
         it('should return true if webex assitant is enabled', () => {
-          meeting.policy = {
-            WEBEX_ASSISTANT_STATUS_ACTIVE: true
-          };
+          meeting.locusInfo.controls = {transcribe: {transcribing: true}};
 
           assert.equal(meeting.isTranscriptionSupported(), true);
         });
@@ -1332,7 +1329,7 @@ describe('plugin-meetings', () => {
 
             sandbox.stub(meeting.mediaProperties, 'peerConnection').value({shareTransceiver: true});
             sandbox.stub(MeetingUtil, 'getTrack').returns({videoTrack: true});
-            sandbox.stub(MeetingUtil, 'validateOptions').resolves(true);
+            MeetingUtil.validateOptions = sinon.stub().returns(Promise.resolve(true));
             sandbox.stub(meeting, 'canUpdateMedia').returns(true);
             sandbox.stub(meeting, 'setLocalShareTrack');
 
@@ -1401,13 +1398,14 @@ describe('plugin-meetings', () => {
             const SENDRECV = 'sendrecv';
             const delay = 1e3;
 
+            MeetingUtil.validateOptions = sinon.stub().returns(Promise.resolve(true));
+            MeetingUtil.updateTransceiver = sinon.stub().returns(Promise.resolve(true));
             sandbox.stub(meeting, 'canUpdateMedia').returns(true);
             sandbox.stub(MeetingUtil, 'getTrack').returns({videoTrack: null});
             sandbox.stub(meeting, 'setLocalShareTrack');
             sandbox.stub(meeting, 'unsetLocalShareTrack');
-            sandbox.stub(MeetingUtil, 'validateOptions').resolves(true);
             sandbox.stub(meeting, 'checkForStopShare').returns(false);
-            sandbox.stub(MeetingUtil, 'updateTransceiver').resolves(true);
+
             sandbox.stub(meeting, 'isLocalShareLive').value(false);
             sandbox.stub(meeting, 'handleShareTrackEnded');
             sandbox.stub(meeting.mediaProperties, 'peerConnection').value({
@@ -2278,11 +2276,6 @@ describe('plugin-meetings', () => {
           assert.equal(meeting.requiredCaptcha, null);
           assert.calledTwice(TriggerProxy.trigger);
           assert.calledWith(TriggerProxy.trigger, meeting, {file: 'meetings', function: 'fetchMeetingInfo'}, 'meeting:meetingInfoAvailable');
-          assert(Metrics.sendBehavioralMetric.calledOnce);
-          assert.calledWith(
-            Metrics.sendBehavioralMetric,
-            BEHAVIORAL_METRICS.VERIFY_PASSWORD_SUCCESS,
-          );
         });
 
         it('calls meetingInfoProvider with all the right parameters and parses the result when random delay is applied', async () => {
@@ -2354,11 +2347,6 @@ describe('plugin-meetings', () => {
 
           assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, null, null);
 
-          assert(Metrics.sendBehavioralMetric.calledOnce);
-          assert.calledWith(
-            Metrics.sendBehavioralMetric,
-            BEHAVIORAL_METRICS.VERIFY_PASSWORD_ERROR,
-          );
           assert.deepEqual(meeting.meetingInfo, FAKE_MEETING_INFO);
           assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD);
           assert.equal(meeting.requiredCaptcha, null);
@@ -2379,11 +2367,7 @@ describe('plugin-meetings', () => {
 
           assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, 'aaa', null);
 
-          assert(Metrics.sendBehavioralMetric.calledOnce);
-          assert.calledWith(
-            Metrics.sendBehavioralMetric,
-            BEHAVIORAL_METRICS.VERIFY_CAPTCHA_ERROR,
-          );
+
           assert.deepEqual(meeting.meetingInfo, {});
           assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD);
           assert.equal(meeting.passwordStatus, PASSWORD_STATUS.REQUIRED);
@@ -2537,6 +2521,11 @@ describe('plugin-meetings', () => {
           meeting.fetchMeetingInfo = sinon.stub().resolves();
           const result = await meeting.verifyPassword('password', 'captcha id');
 
+          assert(Metrics.sendBehavioralMetric.calledOnce);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.VERIFY_PASSWORD_SUCCESS,
+          );
           assert.equal(result.isPasswordValid, true);
           assert.equal(result.requiredCaptcha, null);
           assert.equal(result.failureReason, MEETING_INFO_FAILURE_REASON.NONE);
@@ -2573,6 +2562,7 @@ describe('plugin-meetings', () => {
           assert.equal(result.failureReason, MEETING_INFO_FAILURE_REASON.WRONG_CAPTCHA);
         });
       });
+
       describe('#mediaNegotiatedEvent', () => {
         it('should have #mediaNegotiatedEvent', () => {
           assert.exists(meeting.mediaNegotiatedEvent);
@@ -2650,6 +2640,222 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting?.roap?.stop);
         });
       });
+
+      describe('#moveTo', () => {
+        let sandbox;
+
+        beforeEach(() => {
+          sandbox = sinon.createSandbox();
+          sandbox.stub(meeting, 'closeLocalStream');
+          sandbox.stub(meeting, 'closeLocalShare');
+
+          sandbox.stub(meeting.mediaProperties, 'setMediaDirection');
+          sandbox.stub(meeting.mediaProperties, 'unsetMediaTracks');
+
+          sandbox.stub(meeting.reconnectionManager, 'reconnectMedia').returns(Promise.resolve());
+          sandbox.stub(MeetingUtil, 'joinMeeting').returns(Promise.resolve(MeetingUtil.parseLocusJoin({body: {locus, mediaConnections: []}})));
+        });
+
+        afterEach(() => {
+          sandbox.restore();
+          sandbox = null;
+        });
+
+        it('should throw an error if resourceId not passed', async () => {
+          try {
+            await meeting.moveTo();
+          }
+          catch (err) {
+            assert.instanceOf(err, ParameterError);
+            assert.equal(err.sdkMessage, 'Cannot move call without a resourceId.');
+          }
+        });
+
+        it('should postEvent on moveTo ', async () => {
+          await meeting.moveTo('resourceId');
+          assert.calledWithMatch(Metrics.postEvent, {
+            event: eventType.MEDIA_CAPABILITIES,
+            data: {
+              mediaCapabilities: {
+                rx: {
+                  audio: false,
+                  share: true,
+                  share_audio: false,
+                  video: false,
+                  whiteboard: false
+                },
+                tx: {
+                  audio: false,
+                  share: false,
+                  share_audio: false,
+                  video: false,
+                  whiteboard: false
+                }
+              }
+            }
+          });
+          assert.calledWithMatch(Metrics.postEvent, {event: eventType.MOVE_MEDIA});
+        });
+
+        it('should call `MeetingUtil.joinMeetingOptions` with resourceId', async () => {
+          sinon.spy(MeetingUtil, 'joinMeetingOptions');
+          await meeting.moveTo('resourceId');
+
+          assert.calledWith(MeetingUtil.joinMeetingOptions, meeting, {resourceId: 'resourceId', moveToResource: true});
+        });
+
+        it('should reconnectMedia after DX joins after moveTo', async () => {
+          await meeting.moveTo('resourceId');
+
+
+          await meeting.locusInfo.emitScoped(
+            {
+              file: 'locus-info',
+              function: 'updateSelf'
+            },
+            'SELF_OBSERVING'
+          );
+
+          // beacuse we are calling callback so we need to wait
+
+          assert.called(meeting.closeLocalStream);
+          assert.called(meeting.closeLocalShare);
+
+          // give queued Promise callbacks a chance to run
+          await Promise.resolve();
+
+          assert.called(meeting.mediaProperties.setMediaDirection);
+          assert.called(meeting.mediaProperties.unsetMediaTracks);
+
+          assert.calledWith(meeting.reconnectionManager.reconnectMedia,
+            {
+              mediaDirection: {
+                sendVideo: false,
+                receiveVideo: false,
+                sendAudio: false,
+                receiveAudio: false,
+                sendShare: false,
+                receiveShare: true
+              }
+            });
+        });
+
+        it('should throw an error if moveTo call fails', async () => {
+          MeetingUtil.joinMeeting = sinon.stub().returns(Promise.reject());
+          try {
+            await meeting.moveTo('resourceId');
+          }
+          catch {
+            assert.calledOnce(Metrics.sendBehavioralMetric);
+            assert.calledWith(
+              Metrics.sendBehavioralMetric,
+              BEHAVIORAL_METRICS.MOVE_TO_FAILURE,
+              {
+                correlation_id: meeting.correlationId,
+                locus_id: meeting.locusUrl.split('/').pop(),
+                reason: sinon.match.any,
+                stack: sinon.match.any
+              }
+            );
+          }
+          Metrics.sendBehavioralMetric.reset();
+          meeting.reconnectionManager.reconnectMedia = sinon.stub().returns(Promise.reject());
+          try {
+            await meeting.moveTo('resourceId');
+
+            await meeting.locusInfo.emitScoped(
+              {
+                file: 'locus-info',
+                function: 'updateSelf'
+              },
+              'SELF_OBSERVING'
+            );
+          }
+          catch {
+            assert.calledOnce(Metrics.sendBehavioralMetric);
+            assert.calledWith(
+              Metrics.sendBehavioralMetric,
+              BEHAVIORAL_METRICS.MOVE_TO_FAILURE,
+              {
+                correlation_id: meeting.correlationId,
+                locus_id: meeting.locusUrl.split('/').pop(),
+                reason: sinon.match.any,
+                stack: sinon.match.any
+              }
+            );
+          }
+        });
+      });
+
+      describe('#moveFrom', () => {
+        let sandbox;
+
+        beforeEach(() => {
+          sandbox = sinon.createSandbox();
+          sandbox.stub(MeetingUtil, 'joinMeeting').returns(Promise.resolve(MeetingUtil.parseLocusJoin({body: {locus, mediaConnections: []}})));
+          sandbox.stub(MeetingUtil, 'leaveMeeting').returns(Promise.resolve());
+        });
+
+        afterEach(() => {
+          sandbox.restore();
+          sandbox = null;
+        });
+
+        it('should throw an error if resourceId not passed', async () => {
+          try {
+            await meeting.moveFrom();
+          }
+          catch (err) {
+            assert.instanceOf(err, ParameterError);
+
+            assert.equal(err.sdkMessage, 'Cannot move call without a resourceId.');
+          }
+        });
+
+        it('should postEvent on moveFrom ', async () => {
+          await meeting.moveFrom('resourceId');
+
+          assert.calledWithMatch(Metrics.postEvent, {event: eventType.MOVE_MEDIA});
+        });
+
+        it('should call `MeetingUtil.joinMeetingOptions` with resourceId', async () => {
+          sinon.spy(MeetingUtil, 'joinMeetingOptions');
+          await meeting.moveFrom('resourceId');
+
+          assert.calledWith(MeetingUtil.joinMeetingOptions, meeting);
+          assert.calledWith(MeetingUtil.leaveMeeting, meeting, {
+            resourceId: 'resourceId',
+            correlationId: meeting.correlationId,
+            moveMeeting: true
+          });
+
+          assert.calledOnce(Metrics.sendBehavioralMetric);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.MOVE_FROM_SUCCESS,
+          );
+        });
+
+        it('should throw an error if moveFrom call fails', async () => {
+          MeetingUtil.joinMeeting = sinon.stub().returns(Promise.reject());
+          try {
+            await meeting.moveFrom('resourceId');
+          }
+          catch {
+            assert.calledOnce(Metrics.sendBehavioralMetric);
+            assert.calledWith(
+              Metrics.sendBehavioralMetric,
+              BEHAVIORAL_METRICS.MOVE_FROM_FAILURE,
+              {
+                correlation_id: meeting.correlationId,
+                locus_id: meeting.locusUrl.split('/').pop(),
+                reason: sinon.match.any,
+                stack: sinon.match.any
+              }
+            );
+          }
+        });
+      });
     });
 
     describe('Public Event Triggers', () => {

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

@@ -177,16 +177,17 @@ describe('plugin-meetings', () => {
         meetingInfo.createAdhocSpaceMeeting.restore();
       });
 
+
       it('should throw an error MeetingInfoV2AdhocMeetingError if not able to start adhoc meeting for a conversation', async () => {
         webex.config.meetings.experimental.enableAdhocMeetings = true;
 
-        webex.request = sinon.stub().rejects({statusCode: 403, body: {code: 400000, message: 'Input is invalid'}});
+        webex.request = sinon.stub().rejects({statusCode: 403, body: {code: 400000}});
         try {
           await meetingInfo.createAdhocSpaceMeeting('conversationUrl');
         }
         catch (err) {
           assert.instanceOf(err, MeetingInfoV2AdhocMeetingError);
-          assert.deepEqual(err.message, 'Input is invalid, code=400000');
+          assert.deepEqual(err.message, 'Failed starting the adhoc meeting, Please contact support team , code=400000');
           assert.equal(err.wbxAppApiCode, 400000);
         }
       });
@@ -201,6 +202,11 @@ describe('plugin-meetings', () => {
           assert.fail('fetchMeetingInfo should have thrown, but has not done that');
         }
         catch (err) {
+          assert(Metrics.sendBehavioralMetric.calledOnce);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.VERIFY_PASSWORD_ERROR,
+          );
           assert.instanceOf(err, MeetingInfoV2PasswordError);
           assert.deepEqual(err.meetingInfo, FAKE_MEETING_INFO);
           assert.equal(err.wbxAppApiCode, 403000);
@@ -226,6 +232,11 @@ describe('plugin-meetings', () => {
             assert.fail('fetchMeetingInfo should have thrown, but has not done that');
           }
           catch (err) {
+            assert(Metrics.sendBehavioralMetric.calledOnce);
+            assert.calledWith(
+              Metrics.sendBehavioralMetric,
+              BEHAVIORAL_METRICS.VERIFY_CAPTCHA_ERROR,
+            );
             assert.instanceOf(err, MeetingInfoV2CaptchaError);
             assert.deepEqual(err.captchaInfo, {
               captchaId: 'fake_captcha_id',