@webex/plugin-meetings 3.0.0-beta.25 → 3.0.0-beta.26

package/test/unit/spec/controls-options-manager/index.js

@@ -0,0 +1,124 @@
+import ControlsOptionsManager from '@webex/plugin-meetings/src/controls-options-manager';
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+import { HTTP_VERBS } from '@webex/plugin-meetings/src/constants';
+
+describe('plugin-meetings', () => {
+    describe('controls-options-manager tests', () => {
+        describe('index', () => {
+            let request;
+
+            describe('class tests', () => {
+                it('can set and extract new values later on', () => {
+                    const manager = new ControlsOptionsManager({});
+                    assert.isUndefined(manager.getLocusUrl());
+                    manager.set({
+                      locusUrl: 'test/id',
+                    })
+                    assert(manager.getLocusUrl(), 'test/id');
+                });
+            });
+
+            describe('Mute On Entry', () => {
+                let manager;
+            
+                beforeEach(() => {
+                  request = {
+                    request: sinon.stub().returns(Promise.resolve()),
+                  };
+
+                  manager = new ControlsOptionsManager(request);
+
+                  manager.set({
+                    locusUrl: 'test/id',
+                    displayHints: [],
+                  })
+                });
+
+                describe('setMuteOnEntry', () => {
+                    it('rejects when correct display hint is not present enabled=false', () => {  
+                      const result = manager.setMuteOnEntry(false);
+              
+                      assert.notCalled(request.request);
+              
+                      assert.isRejected(result);
+                    });
+
+                    it('rejects when correct display hint is not present enabled=true', () => {  
+                      const result = manager.setMuteOnEntry(true);
+              
+                      assert.notCalled(request.request);
+              
+                      assert.isRejected(result);
+                    });
+      
+                    it('can set mute on entry when the display hint is available enabled=true', () => {
+                      manager.setDisplayHints(['ENABLE_MUTE_ON_ENTRY']);
+              
+                      const result = manager.setMuteOnEntry(true);
+              
+                      assert.calledWith(request.request, {  uri: 'test/id/controls',
+                      body: { muteOnEntry: { enabled: true } },
+                      method: HTTP_VERBS.PATCH});
+              
+                      assert.deepEqual(result, request.request.firstCall.returnValue);
+                    });
+
+                    it('can set mute on entry when the display hint is available enabled=false', () => {
+                      manager.setDisplayHints(['DISABLE_MUTE_ON_ENTRY']);
+              
+                      const result = manager.setMuteOnEntry(false);
+              
+                      assert.calledWith(request.request, {  uri: 'test/id/controls',
+                      body: { muteOnEntry: { enabled: false } },
+                      method: HTTP_VERBS.PATCH});
+              
+                      assert.deepEqual(result, request.request.firstCall.returnValue);
+                    });
+                  });
+
+                  describe('setDisallowUnmute', () => {
+                    it('rejects when correct display hint is not present enabled=false', () => {  
+                      const result = manager.setDisallowUnmute(false);
+              
+                      assert.notCalled(request.request);
+              
+                      assert.isRejected(result);
+                    });
+
+                    it('rejects when correct display hint is not present enabled=true', () => {  
+                      const result = manager.setDisallowUnmute(true);
+              
+                      assert.notCalled(request.request);
+              
+                      assert.isRejected(result);
+                    });
+      
+                    it('can set mute on entry when the display hint is available enabled=true', () => {
+                      manager.setDisplayHints(['ENABLE_HARD_MUTE']);
+              
+                      const result = manager.setDisallowUnmute(true);
+              
+                      assert.calledWith(request.request, {  uri: 'test/id/controls',
+                      body: { disallowUnmute: { enabled: true } },
+                      method: HTTP_VERBS.PATCH});
+              
+                      assert.deepEqual(result, request.request.firstCall.returnValue);
+                    });
+
+                    it('can set mute on entry when the display hint is available enabled=false', () => {
+                      manager.setDisplayHints(['DISABLE_HARD_MUTE']);
+              
+                      const result = manager.setDisallowUnmute(false);
+              
+                      assert.calledWith(request.request, {  uri: 'test/id/controls',
+                      body: { disallowUnmute: { enabled: false } },
+                      method: HTTP_VERBS.PATCH});
+              
+                      assert.deepEqual(result, request.request.firstCall.returnValue);
+                    });
+                  });
+            });
+          });
+    });
+});

package/test/unit/spec/controls-options-manager/util.js

@@ -0,0 +1,66 @@
+import ControlsOptionsUtil from '@webex/plugin-meetings/src/controls-options-manager/util';
+import { assert } from 'chai';
+
+describe('plugin-meetings', () => {
+    describe('controls-option-manager tests', () => {
+        describe('util tests', () => {
+
+            let locusInfo;
+        
+            beforeEach(() => {
+              locusInfo = {
+                parsedLocus: {
+                  info: {
+                    userDisplayHints: [],
+                  },
+                },
+              };
+            });
+        
+            describe('canUserSetMuteOnEntry', () => {
+              it('can set mute on entry enable', () => {
+                locusInfo.parsedLocus.info.userDisplayHints.push('ENABLE_MUTE_ON_ENTRY');
+
+                assert.equal(ControlsOptionsUtil.canSetMuteOnEntry(locusInfo.parsedLocus.info.userDisplayHints), true);
+              });
+
+              it('can set mute on entry disable', () => {
+                locusInfo.parsedLocus.info.userDisplayHints.push('DISABLE_MUTE_ON_ENTRY');
+
+                assert.equal(ControlsOptionsUtil.canUnsetMuteOnEntry(locusInfo.parsedLocus.info.userDisplayHints), true);
+              });
+        
+              it('rejects when correct display hint is not present for setting mute on entry', () => {
+                assert.equal(ControlsOptionsUtil.canSetMuteOnEntry(locusInfo.parsedLocus.info.userDisplayHints), false);
+              });
+
+              it('rejects when correct display hint is not present for unsetting mute on entry', () => {
+                assert.equal(ControlsOptionsUtil.canUnsetMuteOnEntry(locusInfo.parsedLocus.info.userDisplayHints), false);
+              });
+            });
+
+            describe('canSetDisallowUnmute', () => {
+              it('can set disallow unmute enable', () => {
+                locusInfo.parsedLocus.info.userDisplayHints.push('ENABLE_HARD_MUTE');
+
+                assert.equal(ControlsOptionsUtil.canSetDisallowUnmute(locusInfo.parsedLocus.info.userDisplayHints), true);
+              });
+
+              it('can set disallow unmute disable', () => {
+                locusInfo.parsedLocus.info.userDisplayHints.push('DISABLE_HARD_MUTE');
+
+                assert.equal(ControlsOptionsUtil.canUnsetDisallowUnmute(locusInfo.parsedLocus.info.userDisplayHints), true);
+              });
+        
+              it('rejects when correct display hint is not present', () => {
+                assert.equal(ControlsOptionsUtil.canSetDisallowUnmute(locusInfo.parsedLocus.info.userDisplayHints), false);
+              });
+
+              it('rejects when correct display hint is not present', () => {
+                assert.equal(ControlsOptionsUtil.canUnsetDisallowUnmute(locusInfo.parsedLocus.info.userDisplayHints), false);
+              });
+            });
+
+        });
+    });
+});

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

@@ -13,6 +13,10 @@ describe('plugin-meetings', () => {
         canStartRecording: null,
         canPauseRecording: null,
         canResumeRecording: null,
+        canSetMuteOnEntry: null,
+        canUnsetMuteOnEntry: null,
+        canSetDisallowUnmute: null,
+        canUnsetDisallowUnmute: null,
         canStopRecording: null,
         canRaiseHand: null,
         canLowerAllHands: null,
@@ -51,6 +55,10 @@ describe('plugin-meetings', () => {
       'canPauseRecording',
       'canResumeRecording',
       'canStopRecording',
+      'canSetMuteOnEntry',
+      'canUnsetMuteOnEntry',
+      'canSetDisallowUnmute',
+      'canUnsetDisallowUnmute',
       'canRaiseHand',
       'canLowerAllHands',
       'canLowerSomeoneElsesHand',

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

@@ -38,6 +38,7 @@ import Media from '@webex/plugin-meetings/src/media/index';
 import ReconnectionManager from '@webex/plugin-meetings/src/reconnection-manager';
 import MediaUtil from '@webex/plugin-meetings/src/media/util';
 import RecordingUtil from '@webex/plugin-meetings/src/recording-controller/util';
+import ControlsOptionsUtil from '@webex/plugin-meetings/src/controls-options-manager/util';
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
 import LoggerConfig from '@webex/plugin-meetings/src/common/logs/logger-config';
 import TriggerProxy from '@webex/plugin-meetings/src/common/events/trigger-proxy';
@@ -4419,6 +4420,7 @@ describe('plugin-meetings', () => {
 
           meeting.members = {locusUrlUpdate: sinon.stub().returns(Promise.resolve(test1))};
           meeting.recordingController = {setLocusUrl: sinon.stub().returns(undefined)};
+          meeting.controlsOptionsManager = {setLocusUrl: sinon.stub().returns(undefined)};
 
           meeting.breakouts.locusUrlUpdate = sinon.stub();
 
@@ -4430,6 +4432,7 @@ describe('plugin-meetings', () => {
           assert.calledOnceWithExactly(meeting.breakouts.locusUrlUpdate, newLocusUrl);
           assert.calledWith(meeting.members.locusUrlUpdate, newLocusUrl);
           assert.calledWith(meeting.recordingController.setLocusUrl, newLocusUrl);
+          assert.calledWith(meeting.controlsOptionsManager.setLocusUrl, newLocusUrl);
           assert.equal(meeting.locusUrl, newLocusUrl);
           assert(meeting.locusId, '12345');
           done();
@@ -4870,6 +4873,10 @@ describe('plugin-meetings', () => {
         let canUserStopSpy;
         let canUserPauseSpy;
         let canUserResumeSpy;
+        let canSetMuteOnEntrySpy;
+        let canUnsetMuteOnEntrySpy;
+        let canSetDisallowUnmuteSpy;
+        let canUnsetDisallowUnmuteSpy;
         let canUserRaiseHandSpy;
         let bothLeaveAndEndMeetingAvailableSpy;
         let canUserLowerAllHandsSpy;
@@ -4887,6 +4894,10 @@ describe('plugin-meetings', () => {
           canUserStopSpy = sinon.spy(RecordingUtil, 'canUserStop');
           canUserPauseSpy = sinon.spy(RecordingUtil, 'canUserPause');
           canUserResumeSpy = sinon.spy(RecordingUtil, 'canUserResume');
+          canSetMuteOnEntrySpy = sinon.spy(ControlsOptionsUtil, 'canSetMuteOnEntry');
+          canUnsetMuteOnEntrySpy = sinon.spy(ControlsOptionsUtil, 'canUnsetMuteOnEntry');
+          canSetDisallowUnmuteSpy = sinon.spy(ControlsOptionsUtil, 'canSetDisallowUnmute');
+          canUnsetDisallowUnmuteSpy = sinon.spy(ControlsOptionsUtil, 'canUnsetDisallowUnmute');
           inMeetingActionsSetSpy = sinon.spy(meeting.inMeetingActions, 'set');
           canUserRaiseHandSpy = sinon.spy(MeetingUtil, 'canUserRaiseHand');
           canUserLowerAllHandsSpy = sinon.spy(MeetingUtil, 'canUserLowerAllHands');
@@ -4932,6 +4943,10 @@ describe('plugin-meetings', () => {
           assert.calledWith(canUserStopSpy, payload.info.userDisplayHints);
           assert.calledWith(canUserPauseSpy, payload.info.userDisplayHints);
           assert.calledWith(canUserResumeSpy, payload.info.userDisplayHints);
+          assert.calledWith(canSetMuteOnEntrySpy, payload.info.userDisplayHints);
+          assert.calledWith(canUnsetMuteOnEntrySpy, payload.info.userDisplayHints);
+          assert.calledWith(canSetDisallowUnmuteSpy, payload.info.userDisplayHints);
+          assert.calledWith(canUnsetDisallowUnmuteSpy, payload.info.userDisplayHints);
           assert.calledWith(canUserRaiseHandSpy, payload.info.userDisplayHints);
           assert.calledWith(bothLeaveAndEndMeetingAvailableSpy, payload.info.userDisplayHints);
           assert.calledWith(canUserLowerAllHandsSpy, payload.info.userDisplayHints);