@webex/plugin-meetings 2.14.1 → 2.14.4

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);
         });
@@ -789,6 +786,7 @@ describe('plugin-meetings', () => {
         beforeEach(() => {
           meeting.setCorrelationId = sinon.stub().returns(true);
           meeting.setLocus = sinon.stub().returns(true);
+          webex.meetings.registered = true;
         });
         describe('successful', () => {
           beforeEach(() => {
@@ -857,6 +855,14 @@ describe('plugin-meetings', () => {
               assert.calledWith(MeetingUtil.joinMeeting, meeting, {moderator: false, pin: '1234'});
             });
           });
+
+          it('should throw error if device is not registered', async () => {
+            webex.meetings.registered = false;
+            await meeting.join().catch((error) => {
+              assert.equal(error.message, 'Meeting:index#join --> Device not registered');
+            });
+          });
+
           it('should post error event if failed', async () => {
             await meeting.join().catch(() => {
               assert.calledWithMatch(Metrics.postEvent, {event: eventType.LOCUS_JOIN_RESPONSE});
@@ -2565,6 +2571,7 @@ describe('plugin-meetings', () => {
           assert.equal(result.failureReason, MEETING_INFO_FAILURE_REASON.WRONG_CAPTCHA);
         });
       });
+
       describe('#mediaNegotiatedEvent', () => {
         it('should have #mediaNegotiatedEvent', () => {
           assert.exists(meeting.mediaNegotiatedEvent);
@@ -2642,6 +2649,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', () => {