@webex/plugin-meetings 3.0.0-beta.16 → 3.0.0-beta.161

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

@@ -4,6 +4,7 @@ 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 Metrics from '@webex/plugin-meetings/src/metrics/index';
+import {DISPLAY_HINTS} from '@webex/plugin-meetings/src/constants';
 
 describe('plugin-meetings', () => {
   describe('Meeting utils function', () => {
@@ -25,18 +26,18 @@ describe('plugin-meetings', () => {
       });
       LoggerProxy.set(logger);
 
-      meeting.closeLocalStream = sinon.stub().returns(Promise.resolve());
-      meeting.closeLocalShare = sinon.stub().returns(Promise.resolve());
+      meeting.cleanupLocalTracks = 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.stopKeepAlive = sinon.stub();
       meeting.updateLLMConnection = sinon.stub();
+      meeting.breakouts = {cleanUp: sinon.stub()};
+      meeting.annotaion = {cleanUp: sinon.stub()};
+      meeting.simultaneousInterpretation = {cleanUp: sinon.stub()};
     });
 
     afterEach(() => {
@@ -46,19 +47,17 @@ describe('plugin-meetings', () => {
     describe('#cleanup', () => {
       it('do clean up on meeting object', async () => {
         await MeetingUtil.cleanUp(meeting);
-        assert.calledOnce(meeting.closeLocalStream);
-        assert.calledOnce(meeting.closeLocalStream);
-        assert.calledOnce(meeting.closeLocalShare);
+        assert.calledOnce(meeting.cleanupLocalTracks);
         assert.calledOnce(meeting.closeRemoteTracks);
         assert.calledOnce(meeting.closePeerConnections);
 
-        assert.calledOnce(meeting.unsetLocalVideoTrack);
-        assert.calledOnce(meeting.unsetLocalShareTrack);
         assert.calledOnce(meeting.unsetRemoteTracks);
         assert.calledOnce(meeting.unsetPeerConnections);
         assert.calledOnce(meeting.reconnectionManager.cleanUp);
         assert.calledOnce(meeting.stopKeepAlive);
         assert.calledOnce(meeting.updateLLMConnection);
+        assert.calledOnce(meeting.breakouts.cleanUp);
+        assert.calledOnce(meeting.simultaneousInterpretation.cleanUp);
       });
     });
 
@@ -68,7 +67,9 @@ describe('plugin-meetings', () => {
       });
 
       const mockTrack = {
-        getSettings: fakeDevice,
+        underlyingTrack: {
+          getSettings: fakeDevice,
+        },
       };
 
       it('#log - should log [info, warn, error, log] to console', () => {
@@ -127,51 +128,169 @@ describe('plugin-meetings', () => {
       });
     });
 
-    describe('remoteUpdateAudioVideo', () => {
-      it('#Should call meetingRequest.remoteAudioVideoToggle with correct parameters (multistream)', async () => {
+    describe('addSequence', () => {
+      it('should add the sequence object to a request body', () => {
+        const body = {};
+
+        MeetingUtil.addSequence({
+          locusInfo: {
+            sequence: 'sequence'
+          }
+        }, body);
+
+        assert.deepEqual(body, {
+          sequence: 'sequence'
+        });
+      });
+
+      it('should work with an undefined meeting', () => {
+        const body = {};
+
+        MeetingUtil.addSequence(
+          undefined,
+          body
+        );
+
+        assert.deepEqual(body, {});
+      });
+
+      it('should work with an undefined locusInfo', () => {
+        const body = {};
+
+        MeetingUtil.addSequence({}, body);
+
+        assert.deepEqual(body, {});
+      });
+
+      it('should work with an undefined sequence', () => {
+        const body = {};
+
+        MeetingUtil.addSequence({locusInfo: {}}, body);
+
+        assert.deepEqual(body, {});
+      });
+    });
+
+    describe('updateLocusWithDelta', () => {
+      it('should call onDeltaLocus with the new delta locus', () => {
         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: {}})),
+          locusInfo: {
+            onDeltaLocus: sinon.stub(),
+          }
+        }
+
+        const originalResponse = {
+          body: {
+            locus: 'locus'
+          }
+        };
+
+        const response = MeetingUtil.updateLocusWithDelta(meeting, originalResponse);
+
+        assert.deepEqual(response, originalResponse);
+        assert.calledOnceWithExactly(meeting.locusInfo.onDeltaLocus, 'locus');
+      });
+
+      it('should handle locus being missing from the response', () => {
+        const meeting = {
+          locusInfo: {
+            onDeltaLocus: sinon.stub(),
           },
         };
 
-        await MeetingUtil.remoteUpdateAudioVideo(true, false, meeting);
+        const originalResponse = {
+          body: {},
+        };
 
-        assert.calledOnce(meeting.meetingRequest.remoteAudioVideoToggle);
-        const parameter = meeting.meetingRequest.remoteAudioVideoToggle.getCall(0).args[0];
+        const response = MeetingUtil.updateLocusWithDelta(meeting, originalResponse);
+
+        assert.deepEqual(response, originalResponse);
+        assert.notCalled(meeting.locusInfo.onDeltaLocus);
+      });
+
+      it('should work with an undefined meeting', () => {
+        const originalResponse = {
+          body: {
+            locus: 'locus',
+          },
+        };
+
+        const response = MeetingUtil.updateLocusWithDelta(undefined, originalResponse);
+        assert.deepEqual(response, originalResponse);
+      });
+    });
+
+    describe('generateLocusDeltaRequest', () => {
+
+      afterEach(() => {
+        WeakRef.prototype.deref.restore();
+      });
+
+      it('generates the correct wrapper function', async () => {
+        const updateLocusWithDeltaSpy = sinon.spy(MeetingUtil, 'updateLocusWithDelta');
+        const addSequenceSpy = sinon.spy(MeetingUtil, 'addSequence');
+
+        const meeting = {
+          request: sinon.stub().returns(Promise.resolve('result')),
+        }
+
+        const locusDeltaRequest = MeetingUtil.generateLocusDeltaRequest(meeting);
+
+        const options = {
+          some: 'option',
+          body: {}
+        };
+
+        let result = await locusDeltaRequest(options);
+
+        assert.equal(result, 'result');
+        assert.calledOnceWithExactly(updateLocusWithDeltaSpy, meeting, 'result');
+        assert.calledOnceWithExactly(addSequenceSpy, meeting, options.body);
+
+        updateLocusWithDeltaSpy.resetHistory();
+        addSequenceSpy.resetHistory();
+
+        // body missing from options
+        result = await locusDeltaRequest({});
+        assert.equal(result, 'result');
+        assert.calledOnceWithExactly(updateLocusWithDeltaSpy, meeting, 'result');
+        assert.calledOnceWithExactly(addSequenceSpy, meeting, options.body);
+
+        // meeting disappears so the WeakRef returns undefined
+        sinon.stub(WeakRef.prototype, 'deref').returns(undefined);
+
+        result = await locusDeltaRequest(options);
+        assert.equal(result, undefined);
 
-        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 () => {
+    });
+
+    describe('remoteUpdateAudioVideo', () => {
+      it('#Should call meetingRequest.locusMediaRequest with correct parameters', async () => {
         const meeting = {
-          isMultistream: false,
           mediaId: '12345',
-          meetingRequest: {
-            remoteAudioVideoToggle: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
+          selfUrl: 'self url',
+          locusInfo: {
+            sequence: {},
+          },
+          locusMediaRequest: {
+            send: sinon.stub().resolves({body: {}, headers: {}}),
           },
         };
 
-        await MeetingUtil.remoteUpdateAudioVideo(true, false, meeting);
-
-        assert.calledOnce(meeting.meetingRequest.remoteAudioVideoToggle);
-        const parameter = meeting.meetingRequest.remoteAudioVideoToggle.getCall(0).args[0];
+        await MeetingUtil.remoteUpdateAudioVideo(meeting, true, false);
 
-        assert.equal(parameter.preferTranscoding, true);
+        assert.calledOnceWithExactly(meeting.locusMediaRequest.send, {
+          mediaId: '12345',
+          muteOptions: {
+            audioMuted: true,
+            videoMuted: false,
+          },
+          selfUrl: 'self url',
+          sequence: {},
+          type: 'LocalMute',
+        });
       });
     });
 
@@ -195,6 +314,62 @@ describe('plugin-meetings', () => {
         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 liveAnnotationSupported=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, {
+          liveAnnotationSupported: true,
+        });
+
+        assert.calledOnce(meeting.meetingRequest.joinMeeting);
+        const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
+
+        assert.equal(parameter.liveAnnotationSupported, true);
+      });
+
+      it('#Should call meetingRequest.joinMeeting with locale=en_UK, deviceCapabilities=["TEST"] when they are passed in as those values', async () => {
+        const meeting = {
+          meetingRequest: {
+            joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
+          },
+        };
+
+        MeetingUtil.parseLocusJoin = sinon.stub();
+        await MeetingUtil.joinMeeting(meeting, {
+          locale: 'en_UK',
+          deviceCapabilities: ['TEST'],
+        });
+
+        assert.calledOnce(meeting.meetingRequest.joinMeeting);
+        const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
+
+        assert.equal(parameter.locale, 'en_UK');
+        assert.deepEqual(parameter.deviceCapabilities, ['TEST']);
+      });
+
       it('#Should call meetingRequest.joinMeeting with preferTranscoding=false when multistream is enabled', async () => {
         const meeting = {
           isMultistream: true,
@@ -324,6 +499,23 @@ describe('plugin-meetings', () => {
       });
     });
 
+    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(
@@ -366,35 +558,8 @@ describe('plugin-meetings', () => {
       });
     });
 
-    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'},
@@ -413,102 +578,51 @@ 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('canBroadcastMessageToBreakout', () => {
+      it('works as expected', () => {
+        assert.deepEqual(MeetingUtil.canBroadcastMessageToBreakout(['BROADCAST_MESSAGE_TO_BREAKOUT']), true);
+        assert.deepEqual(MeetingUtil.canBroadcastMessageToBreakout([]), 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('isSuppressBreakoutSupport', () => {
+      it('works as expected', () => {
+        assert.deepEqual(
+          MeetingUtil.isSuppressBreakoutSupport(['UCF_SUPPRESS_BREAKOUTS_SUPPORT']),
+          true
+        );
+        assert.deepEqual(MeetingUtil.isSuppressBreakoutSupport([]), false);
       });
+    });
 
-      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('canAdmitLobbyToBreakout', () => {
+      it('works as expected', () => {
+        assert.deepEqual(MeetingUtil.canAdmitLobbyToBreakout(['DISABLE_LOBBY_TO_BREAKOUT']), false);
+        assert.deepEqual(MeetingUtil.canAdmitLobbyToBreakout([]), 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);
+    describe('canUserAskForHelp', () => {
+      it('works as expected', () => {
+        assert.deepEqual(MeetingUtil.canUserAskForHelp(['DISABLE_ASK_FOR_HELP']), false);
+        assert.deepEqual(MeetingUtil.canUserAskForHelp([]), true);
+      });
+    });
 
-          assert.isRejected(result);
-        });
+    describe('isBreakoutPreassignmentsEnabled', () => {
+      it('works as expected', () => {
+        assert.deepEqual(
+          MeetingUtil.isBreakoutPreassignmentsEnabled(['DISABLE_BREAKOUT_PREASSIGNMENTS']),
+          false
+        );
+        assert.deepEqual(MeetingUtil.isBreakoutPreassignmentsEnabled([]), true);
       });
     });
   });