@webex/plugin-meetings 2.2.4 → 2.3.0

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

@@ -1,5 +1,6 @@
 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
@@ -173,6 +174,192 @@ describe('plugin-meetings', () => {
         assert.equal(parameter.meetingNumber, 'meetingNumber');
       });
     });
+
+    describe('getUserDisplayHintsFromLocusInfo', () => {
+      it('returns display hints', () => {
+        assert.deepEqual(MeetingUtil.getUserDisplayHintsFromLocusInfo(), []);
+
+        assert.deepEqual(
+          MeetingUtil.getUserDisplayHintsFromLocusInfo({}),
+          []
+        );
+
+        assert.deepEqual(
+          MeetingUtil.getUserDisplayHintsFromLocusInfo({parsedLocus: {}}),
+          []
+        );
+
+        assert.deepEqual(
+          MeetingUtil.getUserDisplayHintsFromLocusInfo({parsedLocus: {info: {}}}),
+          []
+        );
+
+        assert.deepEqual(
+          MeetingUtil.getUserDisplayHintsFromLocusInfo({parsedLocus: {info: {userDisplayHints: []}}}),
+          []
+        );
+
+        assert.deepEqual(
+          MeetingUtil.getUserDisplayHintsFromLocusInfo({
+            parsedLocus: {
+              info: {
+                userDisplayHints: [
+                  'HINT_1'
+                ]
+              }
+            }
+          }),
+          ['HINT_1']
+        );
+      });
+    });
+
+    describe('canUserLock', () => {
+      it('works as expected', () => {
+        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);
+      });
+    });
+
+    describe('canUserUnlock', () => {
+      it('works as expected', () => {
+        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);
+      });
+    });
+
+    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('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('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('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('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);
+        });
+      });
+    });
   });
 });