@webex/plugin-meetings 2.14.2 → 2.15.0

package/test/unit/spec/locus-info/infoUtils.js

@@ -33,22 +33,29 @@ describe('plugin-meetings', () => {
       it('only gives includes display hints when user has the correct role', () => {
         assert.deepEqual(InfoUtils.parse(info, ['MODERATOR']), {
           policy: {HINT_3: true},
-          moderator: {HINT_1: true, HINT_2: true},
-          coHost: {HINT_4: true},
-          userDisplayHints: ['HINT_3', 'HINT_1', 'HINT_2']
+          moderator: {HINT_1: true, HINT_2: true, LOWER_SOMEONE_ELSES_HAND: true},
+          coHost: {HINT_4: true, LOWER_SOMEONE_ELSES_HAND: true},
+          userDisplayHints: ['HINT_3', 'HINT_1', 'HINT_2', 'LOWER_SOMEONE_ELSES_HAND']
+        });
+
+        assert.deepEqual(InfoUtils.parse(info, ['MODERATOR', 'COHOST']), {
+          policy: {HINT_3: true},
+          moderator: {HINT_1: true, HINT_2: true, LOWER_SOMEONE_ELSES_HAND: true},
+          coHost: {HINT_4: true, LOWER_SOMEONE_ELSES_HAND: true},
+          userDisplayHints: ['HINT_3', 'HINT_4', 'LOWER_SOMEONE_ELSES_HAND', 'HINT_1', 'HINT_2']
         });
 
         assert.deepEqual(InfoUtils.parse(info, ['COHOST']), {
           policy: {HINT_3: true},
-          moderator: {HINT_1: true, HINT_2: true},
-          coHost: {HINT_4: true},
-          userDisplayHints: ['HINT_3', 'HINT_4']
+          moderator: {HINT_1: true, HINT_2: true, LOWER_SOMEONE_ELSES_HAND: true},
+          coHost: {HINT_4: true, LOWER_SOMEONE_ELSES_HAND: true},
+          userDisplayHints: ['HINT_3', 'HINT_4', 'LOWER_SOMEONE_ELSES_HAND']
         });
 
         assert.deepEqual(InfoUtils.parse(info, []), {
           policy: {HINT_3: true},
-          moderator: {HINT_1: true, HINT_2: true},
-          coHost: {HINT_4: true},
+          moderator: {HINT_1: true, HINT_2: true, LOWER_SOMEONE_ELSES_HAND: true},
+          coHost: {HINT_4: true, LOWER_SOMEONE_ELSES_HAND: true},
           userDisplayHints: ['HINT_3']
         });
       });
@@ -99,7 +106,7 @@ describe('plugin-meetings', () => {
 
         assert.calledWith(parseDisplayHintSectionSpy, info, 'moderator');
 
-        assert.deepEqual(result, parseDisplayHintSectionSpy.firstCall.returnValue);
+        assert.deepEqual(result, {...parseDisplayHintSectionSpy.firstCall.returnValue, LOWER_SOMEONE_ELSES_HAND: true});
       });
 
       it('parsePolicy calls parseDisplayHintSection correctly and returns the result', () => {
@@ -115,7 +122,7 @@ describe('plugin-meetings', () => {
 
         assert.calledWith(parseDisplayHintSectionSpy, info, 'coHost');
 
-        assert.deepEqual(result, parseDisplayHintSectionSpy.firstCall.returnValue);
+        assert.deepEqual(result, {...parseDisplayHintSectionSpy.firstCall.returnValue, LOWER_SOMEONE_ELSES_HAND: true});
       });
     });
   });

package/test/unit/spec/locus-info/selfConstant.js

@@ -66,6 +66,7 @@ export const self = {
       ],
       mediaSessionsExternal: false,
       state: 'JOINED',
+      intent: {type: ''},
       intents: [
         null
       ],

package/test/unit/spec/meeting/in-meeting-actions.js

@@ -16,6 +16,7 @@ describe('plugin-meetings', () => {
         canStopRecording: null,
         canRaiseHand: null,
         canLowerAllHands: null,
+        canLowerSomeoneElsesHand: null,
         ...expected
       };
 
@@ -38,6 +39,7 @@ describe('plugin-meetings', () => {
       'canStopRecording',
       'canRaiseHand',
       'canLowerAllHands',
+      'canLowerSomeoneElsesHand',
     ].forEach((key) => {
       it(`get and set for ${key} work as expected`, () => {
         const inMeetingActions = new InMeetingActions();

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,
@@ -785,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(() => {
@@ -853,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});
@@ -2561,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);
@@ -2638,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', () => {
@@ -3316,6 +3543,7 @@ describe('plugin-meetings', () => {
         let canUserResumeSpy;
         let canUserRaiseHandSpy;
         let canUserLowerAllHandsSpy;
+        let canUserLowerSomeoneElsesHandSpy;
 
 
         beforeEach(() => {
@@ -3329,6 +3557,7 @@ describe('plugin-meetings', () => {
           inMeetingActionsSetSpy = sinon.spy(meeting.inMeetingActions, 'set');
           canUserRaiseHandSpy = sinon.spy(MeetingUtil, 'canUserRaiseHand');
           canUserLowerAllHandsSpy = sinon.spy(MeetingUtil, 'canUserLowerAllHands');
+          canUserLowerSomeoneElsesHandSpy = sinon.spy(MeetingUtil, 'canUserLowerSomeoneElsesHand');
         });
 
         afterEach(() => {
@@ -3363,6 +3592,7 @@ describe('plugin-meetings', () => {
           assert.calledWith(canUserResumeSpy, payload.info.userDisplayHints);
           assert.calledWith(canUserRaiseHandSpy, payload.info.userDisplayHints);
           assert.calledWith(canUserLowerAllHandsSpy, payload.info.userDisplayHints);
+          assert.calledWith(canUserLowerSomeoneElsesHandSpy, payload.info.userDisplayHints);
 
           assert.calledWith(
             TriggerProxy.trigger,

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

@@ -228,6 +228,13 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('canUserLowerSomeoneElsesHand', () => {
+      it('works as expected', () => {
+        assert.deepEqual(MeetingUtil.canUserLowerSomeoneElsesHand(['LOWER_SOMEONE_ELSES_HAND']), true);
+        assert.deepEqual(MeetingUtil.canUserLowerSomeoneElsesHand([]), false);
+      });
+    });
+
     describe('canUserLock', () => {
       it('works as expected', () => {
         assert.deepEqual(MeetingUtil.canUserLock(['LOCK_CONTROL_LOCK', 'LOCK_STATUS_UNLOCKED']), true);