@webex/plugin-meetings 2.2.2 → 2.3.0

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

@@ -0,0 +1,55 @@
+import {assert} from '@webex/test-helper-chai';
+
+import InMeetingActions from '@webex/plugin-meetings/src/meeting/in-meeting-actions';
+
+
+describe('plugin-meetings', () => {
+  describe('in-meeting-actions', () => {
+    const checkValues = (actions, expected) => {
+      const expectedValues = {
+        canLock: null,
+        canUnlock: null,
+        canAssignHost: null,
+        canStartRecording: null,
+        canPauseRecording: null,
+        canResumeRecording: null,
+        canStopRecording: null,
+        ...expected
+      };
+
+      // Check get retuns all the correct values at once
+      assert.deepEqual(actions.get(), expectedValues);
+
+      // Check each value individually
+      Object.keys(expectedValues).forEach((key) => {
+        assert.deepEqual(actions[key], expectedValues[key]);
+      });
+    };
+
+    [
+      'canLock',
+      'canUnlock',
+      'canAssignHost',
+      'canStartRecording',
+      'canPauseRecording',
+      'canResumeRecording',
+      'canStopRecording'
+    ].forEach((key) => {
+      it(`get and set for ${key} work as expected`, () => {
+        const inMeetingActions = new InMeetingActions();
+
+        checkValues(inMeetingActions);
+
+        let changed = inMeetingActions.set({[key]: true});
+
+        assert.isTrue(changed);
+
+        checkValues(inMeetingActions, {[key]: true});
+
+        changed = inMeetingActions.set({[key]: true});
+
+        assert.isFalse(changed);
+      });
+    });
+  });
+});

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

@@ -3145,6 +3145,126 @@ describe('plugin-meetings', () => {
           assert.equal(meeting.correlationId, uuid1);
         });
       });
+
+      describe('#setUpLocusInfoAssignHostListener', () => {
+        let locusInfoOnSpy;
+        let inMeetingActionsSetSpy;
+
+        beforeEach(() => {
+          locusInfoOnSpy = sinon.spy(meeting.locusInfo, 'on');
+          inMeetingActionsSetSpy = sinon.spy(meeting.inMeetingActions, 'set');
+        });
+
+        afterEach(() => {
+          locusInfoOnSpy.restore();
+          inMeetingActionsSetSpy.restore();
+        });
+
+        it('registers the correct event', () => {
+          meeting.setUpLocusInfoAssignHostListener();
+
+          assert.calledOnce(locusInfoOnSpy);
+
+          assert.equal(locusInfoOnSpy.firstCall.args[0], 'LOCUS_INFO_CAN_ASSIGN_HOST');
+          const callback = locusInfoOnSpy.firstCall.args[1];
+
+          const payload = {canAssignHost: true};
+
+          callback(payload);
+
+          assert.calledWith(inMeetingActionsSetSpy, payload);
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {
+              file: 'meeting/index',
+              function: 'setUpLocusInfoAssignHostListener'
+            },
+            'meeting:actionsUpdate',
+            meeting.inMeetingActions.get()
+          );
+
+          TriggerProxy.trigger.resetHistory();
+
+          callback(payload);
+
+          assert.notCalled(TriggerProxy.trigger);
+        });
+      });
+
+      describe('#setUpLocusInfoMeetingInfoListener', () => {
+        let locusInfoOnSpy;
+        let inMeetingActionsSetSpy;
+        let canUserLockSpy;
+        let canUserUnlockSpy;
+        let canUserRecordSpy;
+        let canUserStopSpy;
+        let canUserPauseSpy;
+        let canUserResumeSpy;
+
+
+        beforeEach(() => {
+          locusInfoOnSpy = sinon.spy(meeting.locusInfo, 'on');
+          canUserLockSpy = sinon.spy(MeetingUtil, 'canUserLock');
+          canUserUnlockSpy = sinon.spy(MeetingUtil, 'canUserUnlock');
+          canUserRecordSpy = sinon.spy(MeetingUtil, 'canUserRecord');
+          canUserStopSpy = sinon.spy(MeetingUtil, 'canUserStop');
+          canUserPauseSpy = sinon.spy(MeetingUtil, 'canUserPause');
+          canUserResumeSpy = sinon.spy(MeetingUtil, 'canUserResume');
+          inMeetingActionsSetSpy = sinon.spy(meeting.inMeetingActions, 'set');
+        });
+
+        afterEach(() => {
+          locusInfoOnSpy.restore();
+          inMeetingActionsSetSpy.restore();
+        });
+
+
+        it('registers the correct MEETING_INFO_UPDATED event', () => {
+          meeting.setUpLocusInfoMeetingInfoListener();
+
+          assert.calledThrice(locusInfoOnSpy);
+
+          assert.equal(locusInfoOnSpy.firstCall.args[0], 'MEETING_LOCKED');
+          assert.equal(locusInfoOnSpy.secondCall.args[0], 'MEETING_UNLOCKED');
+          assert.equal(locusInfoOnSpy.thirdCall.args[0], 'MEETING_INFO_UPDATED');
+          const callback = locusInfoOnSpy.thirdCall.args[1];
+
+          const payload = {
+            info: {
+              userDisplayHints: ['LOCK_CONTROL_UNLOCK']
+            }
+          };
+
+          callback(payload);
+
+          assert.calledWith(canUserLockSpy, payload.info.userDisplayHints);
+          assert.calledWith(canUserUnlockSpy, payload.info.userDisplayHints);
+          assert.calledWith(canUserRecordSpy, payload.info.userDisplayHints);
+          assert.calledWith(canUserStopSpy, payload.info.userDisplayHints);
+          assert.calledWith(canUserPauseSpy, payload.info.userDisplayHints);
+          assert.calledWith(canUserResumeSpy, payload.info.userDisplayHints);
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {
+              file: 'meeting/index',
+              function: 'setUpLocusInfoMeetingInfoListener'
+            },
+            'meeting:actionsUpdate',
+            meeting.inMeetingActions.get()
+          );
+
+          TriggerProxy.trigger.resetHistory();
+
+          callback(payload);
+
+          assert.notCalled(TriggerProxy.trigger);
+        });
+      });
+
       describe('#setLocus', () => {
         beforeEach(() => {
           meeting.locusInfo.initialSetup = sinon.stub().returns(true);

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);
+        });
+      });
+    });
   });
 });
 

package/test/unit/spec/metrics/index.js

@@ -76,12 +76,12 @@ browserOnly(describe)('Meeting metrics', () => {
       metrics.initialSetup({}, webex);
       const payload = metrics.initPayload('myIPv6Metric', {}, {clientType: 'TEAMS_CLIENT'});
 
-      assert(payload.origin.clientInfo.localNetworkPrefix === '2001:d00::');
+      assert(payload.origin.clientInfo.localNetworkPrefix === '2001:db8:0:8d3::');
       assert(payload.event.name === 'myIPv6Metric');
 
       const payload2 = metrics.initMediaPayload('myIPv6Metric', {}, {clientType: 'TEAMS_CLIENT'});
 
-      assert(payload2.origin.clientInfo.localNetworkPrefix === '2001:d00::');
+      assert(payload2.origin.clientInfo.localNetworkPrefix === '2001:db8:0:8d3::');
     });
   });