@webex/plugin-meetings 3.0.0-beta.1 → 3.0.0-beta.104

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

@@ -2,10 +2,9 @@ import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
-import LoggerConfig
-  from '@webex/plugin-meetings/src/common/logs/logger-config';
+import LoggerConfig from '@webex/plugin-meetings/src/common/logs/logger-config';
 import Metrics from '@webex/plugin-meetings/src/metrics/index';
-
+import {DISPLAY_HINTS} from '@webex/plugin-meetings/src/constants';
 
 describe('plugin-meetings', () => {
   describe('Meeting utils function', () => {
@@ -18,31 +17,29 @@ describe('plugin-meetings', () => {
         info: sandbox.stub(),
         log: sandbox.stub(),
         error: sandbox.stub(),
-        warn: sandbox.stub()
+        warn: sandbox.stub(),
       };
 
       LoggerConfig.set({
         verboseEvents: true,
-        enable: true
+        enable: true,
       });
       LoggerProxy.set(logger);
 
-      meeting.closeLocalStream = sinon.stub()
-        .returns(Promise.resolve());
-      meeting.closeLocalShare = sinon.stub()
-        .returns(Promise.resolve());
-      meeting.closeRemoteTracks = sinon.stub()
-        .returns(Promise.resolve());
-      meeting.closePeerConnections = sinon.stub()
-        .returns(Promise.resolve());
+      meeting.closeLocalStream = sinon.stub().returns(Promise.resolve());
+      meeting.closeLocalShare = sinon.stub().returns(Promise.resolve());
+      meeting.closeRemoteTracks = sinon.stub().returns(Promise.resolve());
+      meeting.closePeerConnections = sinon.stub().returns(Promise.resolve());
 
       meeting.unsetLocalVideoTrack = sinon.stub();
       meeting.unsetLocalShareTrack = sinon.stub();
       meeting.unsetRemoteTracks = sinon.stub();
       meeting.unsetPeerConnections = sinon.stub();
       meeting.reconnectionManager = {cleanUp: sinon.stub()};
-      meeting.roap = {stop: sinon.stub()};
       meeting.stopKeepAlive = sinon.stub();
+      meeting.updateLLMConnection = sinon.stub();
+      meeting.breakouts = {cleanUp: sinon.stub()};
+      meeting.annotaion = {cleanUp: sinon.stub()};
     });
 
     afterEach(() => {
@@ -63,18 +60,21 @@ describe('plugin-meetings', () => {
         assert.calledOnce(meeting.unsetRemoteTracks);
         assert.calledOnce(meeting.unsetPeerConnections);
         assert.calledOnce(meeting.reconnectionManager.cleanUp);
-        assert.calledOnce(meeting.roap.stop);
         assert.calledOnce(meeting.stopKeepAlive);
+        assert.calledOnce(meeting.updateLLMConnection);
+        assert.calledOnce(meeting.breakouts.cleanUp);
       });
     });
 
     describe('logging', () => {
       const fakeDevice = sinon.fake.returns({
-        deviceId: 'device-1'
+        deviceId: 'device-1',
       });
 
       const mockTrack = {
-        getSettings: fakeDevice
+        underlyingTrack: {
+          getSettings: fakeDevice,
+        },
       };
 
       it('#log - should log [info, warn, error, log] to console', () => {
@@ -124,10 +124,7 @@ describe('plugin-meetings', () => {
         });
 
         it('should log device settings', () => {
-          const mockDevices = [
-            {deviceId: 'device-1'},
-            {deviceId: 'device-2'}
-          ];
+          const mockDevices = [{deviceId: 'device-1'}, {deviceId: 'device-2'}];
 
           assert(MeetingUtil.handleDeviceLogging, 'is defined');
           MeetingUtil.handleDeviceLogging(mockDevices);
@@ -136,9 +133,101 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('remoteUpdateAudioVideo', () => {
+      it('#Should call meetingRequest.remoteAudioVideoToggle with correct parameters (multistream)', async () => {
+        const meeting = {
+          correlationId: 'correlation id',
+          isMultistream: true,
+          mediaId: '12345',
+          meetingJoinUrl: 'meetingJoinUrl',
+          locusUrl: 'locusUrl',
+          deviceUrl: 'some device url',
+          selfId: 'self id',
+          meetingRequest: {
+            remoteAudioVideoToggle: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
+          },
+        };
+
+        await MeetingUtil.remoteUpdateAudioVideo(true, false, meeting);
+
+        assert.calledOnce(meeting.meetingRequest.remoteAudioVideoToggle);
+        const parameter = meeting.meetingRequest.remoteAudioVideoToggle.getCall(0).args[0];
+
+        assert.equal(parameter.locusUrl, 'locusUrl');
+        assert.equal(parameter.selfId, 'self id');
+        assert.equal(parameter.correlationId, 'correlation id');
+        assert.equal(parameter.deviceUrl, 'some device url');
+        assert.deepEqual(parameter.localMedias, [
+          {localSdp: '{"audioMuted":true,"videoMuted":false}', mediaId: '12345'},
+        ]);
+        assert.equal(parameter.preferTranscoding, false);
+      });
+
+      it('#Should call meetingRequest.remoteAudioVideoToggle with preferTranscoding:true for non multistream connections', async () => {
+        const meeting = {
+          isMultistream: false,
+          mediaId: '12345',
+          meetingRequest: {
+            remoteAudioVideoToggle: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
+          },
+        };
+
+        await MeetingUtil.remoteUpdateAudioVideo(true, false, meeting);
+
+        assert.calledOnce(meeting.meetingRequest.remoteAudioVideoToggle);
+        const parameter = meeting.meetingRequest.remoteAudioVideoToggle.getCall(0).args[0];
+
+        assert.equal(parameter.preferTranscoding, true);
+      });
+    });
+
     describe('joinMeeting', () => {
       it('#Should call `meetingRequest.joinMeeting', async () => {
-        const meeting = {meetingJoinUrl: 'meetingJoinUrl', locusUrl: 'locusUrl', meetingRequest: {joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}}))}};
+        const meeting = {
+          meetingJoinUrl: 'meetingJoinUrl',
+          locusUrl: 'locusUrl',
+          meetingRequest: {
+            joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
+          },
+        };
+
+        MeetingUtil.parseLocusJoin = sinon.stub();
+        await MeetingUtil.joinMeeting(meeting, {});
+
+        assert.calledOnce(meeting.meetingRequest.joinMeeting);
+        const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
+
+        assert.equal(parameter.inviteeAddress, 'meetingJoinUrl');
+        assert.equal(parameter.preferTranscoding, true);
+      });
+
+      it('#Should call meetingRequest.joinMeeting with breakoutsSupported=true when passed in as true', async () => {
+        const meeting = {
+          meetingRequest: {
+            joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
+          },
+        };
+
+        MeetingUtil.parseLocusJoin = sinon.stub();
+        await MeetingUtil.joinMeeting(meeting, {
+          breakoutsSupported: true,
+        });
+
+        assert.calledOnce(meeting.meetingRequest.joinMeeting);
+        const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
+
+        assert.equal(parameter.breakoutsSupported, true);
+      });
+
+      it('#Should call meetingRequest.joinMeeting with preferTranscoding=false when multistream is enabled', async () => {
+        const meeting = {
+          isMultistream: true,
+          meetingJoinUrl: 'meetingJoinUrl',
+          locusUrl: 'locusUrl',
+          meetingRequest: {
+            joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
+          },
+        };
 
         MeetingUtil.parseLocusJoin = sinon.stub();
         await MeetingUtil.joinMeeting(meeting, {});
@@ -147,10 +236,17 @@ describe('plugin-meetings', () => {
         const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
 
         assert.equal(parameter.inviteeAddress, 'meetingJoinUrl');
+        assert.equal(parameter.preferTranscoding, false);
       });
 
       it('#Should fallback sipUrl if meetingJoinUrl does not exists', async () => {
-        const meeting = {sipUri: 'sipUri', locusUrl: 'locusUrl', meetingRequest: {joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}}))}};
+        const meeting = {
+          sipUri: 'sipUri',
+          locusUrl: 'locusUrl',
+          meetingRequest: {
+            joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
+          },
+        };
 
         MeetingUtil.parseLocusJoin = sinon.stub();
         await MeetingUtil.joinMeeting(meeting, {});
@@ -162,7 +258,13 @@ describe('plugin-meetings', () => {
       });
 
       it('#Should fallback to meetingNumber if meetingJoinUrl/sipUrl  does not exists', async () => {
-        const meeting = {meetingNumber: 'meetingNumber', locusUrl: 'locusUrl', meetingRequest: {joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}}))}};
+        const meeting = {
+          meetingNumber: 'meetingNumber',
+          locusUrl: 'locusUrl',
+          meetingRequest: {
+            joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
+          },
+        };
 
         MeetingUtil.parseLocusJoin = sinon.stub();
         await MeetingUtil.joinMeeting(meeting, {});
@@ -179,15 +281,9 @@ describe('plugin-meetings', () => {
       it('returns display hints', () => {
         assert.deepEqual(MeetingUtil.getUserDisplayHintsFromLocusInfo(), []);
 
-        assert.deepEqual(
-          MeetingUtil.getUserDisplayHintsFromLocusInfo({}),
-          []
-        );
+        assert.deepEqual(MeetingUtil.getUserDisplayHintsFromLocusInfo({}), []);
 
-        assert.deepEqual(
-          MeetingUtil.getUserDisplayHintsFromLocusInfo({parsedLocus: {}}),
-          []
-        );
+        assert.deepEqual(MeetingUtil.getUserDisplayHintsFromLocusInfo({parsedLocus: {}}), []);
 
         assert.deepEqual(
           MeetingUtil.getUserDisplayHintsFromLocusInfo({parsedLocus: {info: {}}}),
@@ -195,7 +291,9 @@ describe('plugin-meetings', () => {
         );
 
         assert.deepEqual(
-          MeetingUtil.getUserDisplayHintsFromLocusInfo({parsedLocus: {info: {userDisplayHints: []}}}),
+          MeetingUtil.getUserDisplayHintsFromLocusInfo({
+            parsedLocus: {info: {userDisplayHints: []}},
+          }),
           []
         );
 
@@ -203,11 +301,9 @@ describe('plugin-meetings', () => {
           MeetingUtil.getUserDisplayHintsFromLocusInfo({
             parsedLocus: {
               info: {
-                userDisplayHints: [
-                  'HINT_1'
-                ]
-              }
-            }
+                userDisplayHints: ['HINT_1'],
+              },
+            },
           }),
           ['HINT_1']
         );
@@ -244,23 +340,55 @@ describe('plugin-meetings', () => {
 
     describe('canUserLowerSomeoneElsesHand', () => {
       it('works as expected', () => {
-        assert.deepEqual(MeetingUtil.canUserLowerSomeoneElsesHand(['LOWER_SOMEONE_ELSES_HAND']), true);
+        assert.deepEqual(
+          MeetingUtil.canUserLowerSomeoneElsesHand(['LOWER_SOMEONE_ELSES_HAND']),
+          true
+        );
         assert.deepEqual(MeetingUtil.canUserLowerSomeoneElsesHand([]), false);
       });
     });
 
+    describe('canUserRenameSelfAndObserved', () => {
+      it('works as expected', () => {
+        assert.deepEqual(
+          MeetingUtil.canUserRenameSelfAndObserved(['CAN_RENAME_SELF_AND_OBSERVED']),
+          true
+        );
+        assert.deepEqual(MeetingUtil.canUserRenameSelfAndObserved([]), false);
+      });
+    });
+
+    describe('canUserRenameOthers', () => {
+      it('works as expected', () => {
+        assert.deepEqual(MeetingUtil.canUserRenameOthers(['CAN_RENAME_OTHERS']), true);
+        assert.deepEqual(MeetingUtil.canUserRenameOthers([]), false);
+      });
+    });
+
     describe('bothLeaveAndEndMeetingAvailable', () => {
       it('works as expected', () => {
-        assert.deepEqual(MeetingUtil.bothLeaveAndEndMeetingAvailable(['LEAVE_TRANSFER_HOST_END_MEETING']), true);
+        assert.deepEqual(
+          MeetingUtil.bothLeaveAndEndMeetingAvailable(['LEAVE_TRANSFER_HOST_END_MEETING']),
+          true
+        );
         assert.deepEqual(MeetingUtil.bothLeaveAndEndMeetingAvailable(['LEAVE_END_MEETING']), true);
-        assert.deepEqual(MeetingUtil.bothLeaveAndEndMeetingAvailable(['LEAVE_TRANSFER_HOST_END_MEETING', 'LEAVE_END_MEETING']), true);
+        assert.deepEqual(
+          MeetingUtil.bothLeaveAndEndMeetingAvailable([
+            'LEAVE_TRANSFER_HOST_END_MEETING',
+            'LEAVE_END_MEETING',
+          ]),
+          true
+        );
         assert.deepEqual(MeetingUtil.bothLeaveAndEndMeetingAvailable([]), false);
       });
     });
 
     describe('canUserLock', () => {
       it('works as expected', () => {
-        assert.deepEqual(MeetingUtil.canUserLock(['LOCK_CONTROL_LOCK', 'LOCK_STATUS_UNLOCKED']), true);
+        assert.deepEqual(
+          MeetingUtil.canUserLock(['LOCK_CONTROL_LOCK', 'LOCK_STATUS_UNLOCKED']),
+          true
+        );
         assert.deepEqual(MeetingUtil.canUserLock(['LOCK_CONTROL_LOCK']), false);
         assert.deepEqual(MeetingUtil.canUserLock(['LOCK_STATUS_UNLOCKED']), false);
         assert.deepEqual(MeetingUtil.canUserLock([]), false);
@@ -269,43 +397,18 @@ describe('plugin-meetings', () => {
 
     describe('canUserUnlock', () => {
       it('works as expected', () => {
-        assert.deepEqual(MeetingUtil.canUserUnlock(['LOCK_CONTROL_UNLOCK', 'LOCK_STATUS_LOCKED']), true);
+        assert.deepEqual(
+          MeetingUtil.canUserUnlock(['LOCK_CONTROL_UNLOCK', 'LOCK_STATUS_LOCKED']),
+          true
+        );
         assert.deepEqual(MeetingUtil.canUserUnlock(['LOCK_CONTROL_UNLOCK']), false);
         assert.deepEqual(MeetingUtil.canUserUnlock(['LOCK_STATUS_LOCKED']), false);
         assert.deepEqual(MeetingUtil.canUserUnlock([]), false);
       });
     });
 
-    describe('canUserRecord', () => {
-      it('works as expected', () => {
-        assert.deepEqual(MeetingUtil.canUserRecord(['RECORDING_CONTROL_START']), true);
-        assert.deepEqual(MeetingUtil.canUserRecord([]), false);
-      });
-    });
-
-    describe('canUserPause', () => {
-      it('works as expected', () => {
-        assert.deepEqual(MeetingUtil.canUserPause(['RECORDING_CONTROL_PAUSE']), true);
-        assert.deepEqual(MeetingUtil.canUserPause([]), false);
-      });
-    });
-
-    describe('canUserResume', () => {
-      it('works as expected', () => {
-        assert.deepEqual(MeetingUtil.canUserResume(['RECORDING_CONTROL_RESUME']), true);
-        assert.deepEqual(MeetingUtil.canUserResume([]), false);
-      });
-    });
-
-
-    describe('canUserStop', () => {
-      it('works as expected', () => {
-        assert.deepEqual(MeetingUtil.canUserStop(['RECORDING_CONTROL_STOP']), true);
-        assert.deepEqual(MeetingUtil.canUserStop([]), false);
-      });
-    });
-
     [
+      {functionName: 'isSaveTranscriptsEnabled', displayHint: 'SAVE_TRANSCRIPTS_ENABLED'},
       {functionName: 'canEnableClosedCaption', displayHint: 'CAPTION_START'},
       {functionName: 'canStartTranscribing', displayHint: 'TRANSCRIPTION_CONTROL_START'},
       {functionName: 'canStopTranscribing', displayHint: 'TRANSCRIPTION_CONTROL_STOP'},
@@ -324,105 +427,44 @@ describe('plugin-meetings', () => {
       });
     });
 
-
-    describe('recording tests', () => {
-      let request;
-      let locusInfo;
-      const locusUrl = 'locusUrl';
-
-      beforeEach(() => {
-        locusInfo = {
-          parsedLocus: {
-            info: {
-              userDisplayHints: [
-                'RECORDING_CONTROL_START'
-              ]
-            }
-          }
-        };
-        request = {
-          recordMeeting: sinon.stub().returns(Promise.resolve())
-        };
+    describe('canManageBreakout', () => {
+      it('works as expected', () => {
+        assert.deepEqual(MeetingUtil.canManageBreakout(['BREAKOUT_MANAGEMENT']), true);
+        assert.deepEqual(MeetingUtil.canManageBreakout([]), false);
       });
+    });
 
-      describe('startRecording', () => {
-        it('can start recording when the correct display hint is present', () => {
-          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_START');
-
-          const result = MeetingUtil.startRecording(request, locusUrl, locusInfo);
-
-          assert.calledWith(request.recordMeeting, {locusUrl, recording: true, paused: false});
-
-          assert.deepEqual(result, request.recordMeeting.firstCall.returnValue);
-        });
-
-        it('rejects when correct display hint is not present', () => {
-          const result = MeetingUtil.startRecording(request, locusUrl, {});
-
-          assert.notCalled(request.recordMeeting);
-
-          assert.isRejected(result);
-        });
+    describe('isSuppressBreakoutSupport', () => {
+      it('works as expected', () => {
+        assert.deepEqual(
+          MeetingUtil.isSuppressBreakoutSupport(['UCF_SUPPRESS_BREAKOUTS_SUPPORT']),
+          true
+        );
+        assert.deepEqual(MeetingUtil.isSuppressBreakoutSupport([]), false);
       });
+    });
 
-      describe('pauseRecording', () => {
-        it('can pause recording when the correct display hint is present', () => {
-          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_PAUSE');
-
-          const result = MeetingUtil.pauseRecording(request, locusUrl, locusInfo);
-
-          assert.calledWith(request.recordMeeting, {locusUrl, recording: true, paused: true});
-
-          assert.deepEqual(result, request.recordMeeting.firstCall.returnValue);
-        });
-
-        it('rejects when correct display hint is not present', () => {
-          const result = MeetingUtil.pauseRecording(request, locusUrl, {});
-
-          assert.notCalled(request.recordMeeting);
-
-          assert.isRejected(result);
-        });
+    describe('canAdmitLobbyToBreakout', () => {
+      it('works as expected', () => {
+        assert.deepEqual(MeetingUtil.canAdmitLobbyToBreakout(['DISABLE_LOBBY_TO_BREAKOUT']), false);
+        assert.deepEqual(MeetingUtil.canAdmitLobbyToBreakout([]), true);
       });
+    });
 
-      describe('resumeRecording', () => {
-        it('can resume recording when the correct display hint is present', () => {
-          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_RESUME');
-
-          const result = MeetingUtil.resumeRecording(request, locusUrl, locusInfo);
-
-          assert.calledWith(request.recordMeeting, {locusUrl, recording: true, paused: false});
-
-          assert.deepEqual(result, request.recordMeeting.firstCall.returnValue);
-        });
-
-        it('rejects when correct display hint is not present', () => {
-          const result = MeetingUtil.resumeRecording(request, locusUrl, {});
-
-          assert.notCalled(request.recordMeeting);
-
-          assert.isRejected(result);
-        });
+    describe('canUserAskForHelp', () => {
+      it('works as expected', () => {
+        assert.deepEqual(MeetingUtil.canUserAskForHelp(['DISABLE_ASK_FOR_HELP']), false);
+        assert.deepEqual(MeetingUtil.canUserAskForHelp([]), true);
       });
+    });
 
-      describe('stopRecording', () => {
-        it('can stop recording when the correct display hint is present', () => {
-          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_STOP');
-
-          const result = MeetingUtil.stopRecording(request, locusUrl, locusInfo);
-
-          assert.calledWith(request.recordMeeting, {locusUrl, recording: false, paused: false});
-
-          assert.deepEqual(result, request.recordMeeting.firstCall.returnValue);
-        });
-
-        it('rejects when correct display hint is not present', () => {
-          const result = MeetingUtil.stopRecording(request, locusUrl, {});
-
-          assert.notCalled(request.recordMeeting);
-
-          assert.isRejected(result);
-        });
+    describe('isBreakoutPreassignmentsEnabled', () => {
+      it('works as expected', () => {
+        assert.deepEqual(
+          MeetingUtil.isBreakoutPreassignmentsEnabled(['DISABLE_BREAKOUT_PREASSIGNMENTS']),
+          false
+        );
+        assert.deepEqual(MeetingUtil.isBreakoutPreassignmentsEnabled([]), true);
       });
     });
   });