@webex/plugin-meetings 3.0.0-beta.108 → 3.0.0-beta.109

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

@@ -128,6 +128,40 @@ describe('plugin-meetings', () => {
               });
             });
 
+            describe('canUpdateRaiseHand()', () => {
+              beforeEach(() => {
+                ControlsOptionsUtil.hasHints = sinon.stub().returns(true);
+              });
+
+              it('should call hasHints() with proper hints when `enabled` is true', () => {
+                ControlsOptionsUtil.canUpdateRaiseHand({properties: {enabled: true}}, [])
+
+                assert.calledWith(ControlsOptionsUtil.hasHints, {
+                  requiredHints: [DISPLAY_HINTS.ENABLE_RAISE_HAND],
+                  displayHints: [],
+                });
+              });
+
+              it('should call hasHints() with proper hints when `enabled` is false', () => {
+                ControlsOptionsUtil.canUpdateRaiseHand({properties: {enabled: false}}, [])
+
+                assert.calledWith(ControlsOptionsUtil.hasHints, {
+                  requiredHints: [DISPLAY_HINTS.DISABLE_RAISE_HAND],
+                  displayHints: [],
+                });
+              });
+
+              it('should return the resolution of hasHints()', () => {
+                const expected = 'example-return-value'
+                ControlsOptionsUtil.hasHints = sinon.stub().returns(expected);
+
+                const results = ControlsOptionsUtil.canUpdateRaiseHand({properties: {}}, []);
+
+                assert.calledOnce(ControlsOptionsUtil.hasHints);
+                assert.equal(results, expected);
+              });
+            });
+
             describe('canUpdateReactions()', () => {
               beforeEach(() => {
                 ControlsOptionsUtil.hasHints = sinon.stub().returns(true);
@@ -222,6 +256,40 @@ describe('plugin-meetings', () => {
               });
             });
 
+            describe('canUpdateVideo()', () => {
+              beforeEach(() => {
+                ControlsOptionsUtil.hasHints = sinon.stub().returns(true);
+              });
+
+              it('should call hasHints() with proper hints when `enabled` is true', () => {
+                ControlsOptionsUtil.canUpdateVideo({properties: {enabled: true}}, [])
+
+                assert.calledWith(ControlsOptionsUtil.hasHints, {
+                  requiredHints: [DISPLAY_HINTS.ENABLE_VIDEO],
+                  displayHints: [],
+                });
+              });
+
+              it('should call hasHints() with proper hints when `enabled` is false', () => {
+                ControlsOptionsUtil.canUpdateVideo({properties: {enabled: false}}, [])
+
+                assert.calledWith(ControlsOptionsUtil.hasHints, {
+                  requiredHints: [DISPLAY_HINTS.DISABLE_VIDEO],
+                  displayHints: [],
+                });
+              });
+
+              it('should return the resolution of hasHints()', () => {
+                const expected = 'example-return-value'
+                ControlsOptionsUtil.hasHints = sinon.stub().returns(expected);
+
+                const results = ControlsOptionsUtil.canUpdateVideo({properties: {}}, []);
+
+                assert.calledOnce(ControlsOptionsUtil.hasHints);
+                assert.equal(results, expected);
+              });
+            });
+
             describe('canUpdateViewTheParticipantsList()', () => {
               beforeEach(() => {
                 ControlsOptionsUtil.hasHints = sinon.stub().returns(true);
@@ -258,18 +326,13 @@ describe('plugin-meetings', () => {
 
             describe('canUpdate()', () => {
               const displayHints = [];
-              let spies;
 
               beforeEach(() => {
-                // spies = {
-                //   canUpdateAudio: sinon.spy(ControlsOptionsUtil, 'canUpdateAudio'),
-                //   canUpdateReactions: sinon.spy(ControlsOptionsUtil, 'canUpdateReactions'),
-                //   canUpdateShareControl: sinon.spy(ControlsOptionsUtil, 'canUpdateShareControl'),
-                //   canUpdateViewTheParticipantsList: sinon.spy(ControlsOptionsUtil, 'canUpdateViewTheParticipantsList'),
-                // }
                 ControlsOptionsUtil.canUpdateAudio = sinon.stub().returns(true);
+                ControlsOptionsUtil.canUpdateRaiseHand = sinon.stub().returns(true);
                 ControlsOptionsUtil.canUpdateReactions = sinon.stub().returns(true);
                 ControlsOptionsUtil.canUpdateShareControl = sinon.stub().returns(true);
+                ControlsOptionsUtil.canUpdateVideo = sinon.stub().returns(true);
                 ControlsOptionsUtil.canUpdateViewTheParticipantsList = sinon.stub().returns(true);
               });
 
@@ -279,20 +342,38 @@ describe('plugin-meetings', () => {
                 const results = ControlsOptionsUtil.canUpdate(control, displayHints);
 
                 assert.calledWith(ControlsOptionsUtil.canUpdateAudio, control, displayHints);
+                assert.callCount(ControlsOptionsUtil.canUpdateRaiseHand, 0);
                 assert.callCount(ControlsOptionsUtil.canUpdateReactions, 0);
                 assert.callCount(ControlsOptionsUtil.canUpdateShareControl, 0);
+                assert.callCount(ControlsOptionsUtil.canUpdateVideo, 0);
                 assert.callCount(ControlsOptionsUtil.canUpdateViewTheParticipantsList, 0);
                 assert.isTrue(results);
               });
 
+              it('should only call canUpdateRaiseHand() if the scope is raiseHand', () => {
+                const control = { scope: 'raiseHand' };
+
+                const results = ControlsOptionsUtil.canUpdate(control, displayHints);
+
+                assert.callCount(ControlsOptionsUtil.canUpdateAudio, 0);
+                assert.calledWith(ControlsOptionsUtil.canUpdateRaiseHand, control, displayHints);
+                assert.callCount(ControlsOptionsUtil.canUpdateReactions, 0);
+                assert.callCount(ControlsOptionsUtil.canUpdateShareControl, 0);
+                assert.callCount(ControlsOptionsUtil.canUpdateVideo, 0);
+                assert.callCount(ControlsOptionsUtil.canUpdateViewTheParticipantsList, 0);
+                assert.isTrue(results);
+              })
+
               it('should only call canUpdateReactions() if the scope is reactions', () => {
                 const control = { scope: 'reactions' };
 
                 const results = ControlsOptionsUtil.canUpdate(control, displayHints);
 
                 assert.callCount(ControlsOptionsUtil.canUpdateAudio, 0);
+                assert.callCount(ControlsOptionsUtil.canUpdateRaiseHand, 0);
                 assert.calledWith(ControlsOptionsUtil.canUpdateReactions, control, displayHints);
                 assert.callCount(ControlsOptionsUtil.canUpdateShareControl, 0);
+                assert.callCount(ControlsOptionsUtil.canUpdateVideo, 0);
                 assert.callCount(ControlsOptionsUtil.canUpdateViewTheParticipantsList, 0);
                 assert.isTrue(results);
               });
@@ -303,8 +384,24 @@ describe('plugin-meetings', () => {
                 const results = ControlsOptionsUtil.canUpdate(control, displayHints);
 
                 assert.callCount(ControlsOptionsUtil.canUpdateAudio, 0);
+                assert.callCount(ControlsOptionsUtil.canUpdateRaiseHand, 0);
                 assert.callCount(ControlsOptionsUtil.canUpdateReactions, 0);
                 assert.calledWith(ControlsOptionsUtil.canUpdateShareControl, displayHints);
+                assert.callCount(ControlsOptionsUtil.canUpdateVideo, 0);
+                assert.callCount(ControlsOptionsUtil.canUpdateViewTheParticipantsList, 0);
+                assert.isTrue(results);
+              });
+
+              it('should only call canUpdateVideo() if the scope is video', () => {
+                const control = { scope: 'video' };
+
+                const results = ControlsOptionsUtil.canUpdate(control, displayHints);
+
+                assert.callCount(ControlsOptionsUtil.canUpdateAudio, 0);
+                assert.callCount(ControlsOptionsUtil.canUpdateRaiseHand, 0);
+                assert.callCount(ControlsOptionsUtil.canUpdateReactions, 0);
+                assert.callCount(ControlsOptionsUtil.canUpdateShareControl, 0);
+                assert.calledWith(ControlsOptionsUtil.canUpdateVideo, control, displayHints);
                 assert.callCount(ControlsOptionsUtil.canUpdateViewTheParticipantsList, 0);
                 assert.isTrue(results);
               });
@@ -315,8 +412,10 @@ describe('plugin-meetings', () => {
                 const results = ControlsOptionsUtil.canUpdate(control, displayHints);
 
                 assert.callCount(ControlsOptionsUtil.canUpdateAudio, 0);
+                assert.callCount(ControlsOptionsUtil.canUpdateRaiseHand, 0);
                 assert.callCount(ControlsOptionsUtil.canUpdateReactions, 0);
                 assert.callCount(ControlsOptionsUtil.canUpdateShareControl, 0);
+                assert.callCount(ControlsOptionsUtil.canUpdateVideo, 0);
                 assert.calledWith(ControlsOptionsUtil.canUpdateViewTheParticipantsList, control, displayHints);
                 assert.isTrue(results);
               });
@@ -327,8 +426,10 @@ describe('plugin-meetings', () => {
                 const results = ControlsOptionsUtil.canUpdate(control, displayHints);
 
                 assert.callCount(ControlsOptionsUtil.canUpdateAudio, 0);
+                assert.callCount(ControlsOptionsUtil.canUpdateRaiseHand, 0);
                 assert.callCount(ControlsOptionsUtil.canUpdateReactions, 0);
                 assert.callCount(ControlsOptionsUtil.canUpdateShareControl, 0);
+                assert.callCount(ControlsOptionsUtil.canUpdateVideo, 0);
                 assert.callCount(ControlsOptionsUtil.canUpdateViewTheParticipantsList, 0);
                 assert.isFalse(results);
               });

package/test/unit/spec/locus-info/controlsUtils.js

@@ -41,6 +41,62 @@ describe('plugin-meetings', () => {
         assert.equal(parsedControls.entryExitTone, null);
       });
 
+      it('should parse the muteOnEntry control', () => {
+        const newControls = {muteOnEntry: {enabled: true}};
+
+        const parsedControls = ControlsUtils.parse(newControls);
+
+        assert.equal(parsedControls.muteOnEntry.enabled, newControls.muteOnEntry.enabled);
+      });
+
+      it('should parse the shareControl control', () => {
+        const newControls = {shareControl: {control: 'example-value'}};
+
+        const parsedControls = ControlsUtils.parse(newControls);
+
+        assert.equal(parsedControls.shareControl.control, newControls.shareControl.control);
+      });
+
+      it('should parse the disallowUnmute control', () => {
+        const newControls = {disallowUnmute: {enabled: true}};
+
+        const parsedControls = ControlsUtils.parse(newControls);
+
+        assert.equal(parsedControls.disallowUnmute.enabled, newControls.disallowUnmute.enabled);
+      });
+
+      it('should parse the reactions control', () => {
+        const newControls = {reactions: {enabled: true}};
+
+        const parsedControls = ControlsUtils.parse(newControls);
+
+        assert.equal(parsedControls.reactions.enabled, newControls.reactions.enabled);
+      });
+
+      it('should parse the reactionDisplayNames control', () => {
+        const newControls = {reactions: {showDisplayNameWithReactions: true}};
+
+        const parsedControls = ControlsUtils.parse(newControls);
+
+        assert.equal(parsedControls.reactions.showDisplayNameWithReactions, newControls.reactions.showDisplayNameWithReactions);
+      });
+
+      it('should parse the viewTheParticipantList control', () => {
+        const newControls = {viewTheParticipantList: {enabled: true}};
+
+        const parsedControls = ControlsUtils.parse(newControls);
+
+        assert.equal(parsedControls.viewTheParticipantList.enabled, newControls.viewTheParticipantList.enabled);
+      });
+
+      it('should parse the raiseHand control', () => {
+        const newControls = {raiseHand: {enabled: true}};
+
+        const parsedControls = ControlsUtils.parse(newControls);
+
+        assert.equal(parsedControls.raiseHand.enabled, newControls.raiseHand.enabled);
+      });
+
       describe('videoEnabled', () => {
         it('returns expected', () => {
           const result = ControlsUtils.parse({video: {enabled: true}});
@@ -65,6 +121,62 @@ describe('plugin-meetings', () => {
     });
 
     describe('getControls', () => {
+      it('returns hasMuteOnEntryChanged = true when changed', () => {
+        const newControls = {muteOnEntry: {enabled: true}};
+
+        const {updates} = ControlsUtils.getControls(defaultControls, newControls);
+
+        assert.equal(updates.hasMuteOnEntryChanged, true);
+      });
+
+      it('returns hasShareControlChanged = true when changed', () => {
+        const newControls = {shareControl: {control: 'example-value'}};
+
+        const {updates} = ControlsUtils.getControls(defaultControls, newControls);
+
+        assert.equal(updates.hasShareControlChanged, true);
+      });
+
+      it('returns hasDisallowUnmuteChanged = true when changed', () => {
+        const newControls = {disallowUnmute: {enabled: true}};
+
+        const {updates} = ControlsUtils.getControls(defaultControls, newControls);
+
+        assert.equal(updates.hasDisallowUnmuteChanged, true);
+      });
+
+      it('returns hasReactionsChanged = true when changed', () => {
+        const newControls = {reactions: {enabled: true}};
+
+        const {updates} = ControlsUtils.getControls(defaultControls, newControls);
+
+        assert.equal(updates.hasReactionsChanged, true);
+      });
+
+      it('returns hasReactionDisplayNamesChanged = true when changed', () => {
+        const newControls = {reactions: {showDisplayNameWithReactions: true}};
+
+        const {updates} = ControlsUtils.getControls(defaultControls, newControls);
+
+        assert.equal(updates.hasReactionDisplayNamesChanged, true);
+      });
+
+      it('returns hasViewTheParticipantListChanged = true when changed', () => {
+        const newControls = {viewTheParticipantList: {enabled: true}};
+
+        const {updates} = ControlsUtils.getControls(defaultControls, newControls);
+
+        assert.equal(updates.hasViewTheParticipantListChanged, true);
+      });
+
+      it('returns hasRaiseHandChanged = true when changed', () => {
+        const newControls = {raiseHand: {enabled: true}};
+
+        const {updates} = ControlsUtils.getControls(defaultControls, newControls);
+
+        assert.equal(updates.hasRaiseHandChanged, true);
+      });
+
       it('returns hasEntryExitToneChanged = true when mode changed', () => {
         const newControls = {
           entryExitTone: {

package/test/unit/spec/locus-info/index.js

@@ -67,8 +67,12 @@ describe('plugin-meetings', () => {
 
       beforeEach('setup new controls', () => {
         newControls = {
+          disallowUnmute: {enabled: true},
           lock: {},
           meetingFull: {},
+          muteOnEntry: {enabled: true},
+          raiseHand: {enabled: true},
+          reactions: {enabled: true, showDisplayNameWithReactions: true},
           record: {
             recording: false,
             paused: false,
@@ -77,8 +81,9 @@ describe('plugin-meetings', () => {
               modifiedBy: 'George Kittle',
             },
           },
-          shareControl: {},
+          shareControl: {control: 'example-value'},
           transcribe: {},
+          viewTheParticipantList: {enabled: true},
           meetingContainer: {
             meetingContainerUrl: 'http://new-url.com',
           },
@@ -97,6 +102,84 @@ describe('plugin-meetings', () => {
         assert.equal(locusInfo.controls, newControls);
       });
 
+      it('should trigger the CONTROLS_MUTE_ON_ENTRY_CHANGED event when necessary', () => {
+        locusInfo.controls = {};
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateControls(newControls);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {file: 'locus-info', function: 'updateControls'},
+          LOCUSINFO.EVENTS.CONTROLS_MUTE_ON_ENTRY_CHANGED,
+          {state: newControls.muteOnEntry},
+        );
+      });
+
+      it('should trigger the CONTROLS_SHARE_CONTROL_CHANGED event when necessary', () => {
+        locusInfo.controls = {};
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateControls(newControls);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {file: 'locus-info', function: 'updateControls'},
+          LOCUSINFO.EVENTS.CONTROLS_SHARE_CONTROL_CHANGED,
+          {state: newControls.shareControl},
+        );
+      });
+
+      it('should trigger the CONTROLS_DISALLOW_UNMUTE_CHANGED event when necessary', () => {
+        locusInfo.controls = {};
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateControls(newControls);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {file: 'locus-info', function: 'updateControls'},
+          LOCUSINFO.EVENTS.CONTROLS_DISALLOW_UNMUTE_CHANGED,
+          {state: newControls.disallowUnmute},
+        );
+      });
+
+      it('should trigger the CONTROLS_REACTIONS_CHANGED event when necessary', () => {
+        locusInfo.controls = {};
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateControls(newControls);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {file: 'locus-info', function: 'updateControls'},
+          LOCUSINFO.EVENTS.CONTROLS_REACTIONS_CHANGED,
+          {state: newControls.reactions},
+        );
+      });
+
+      it('should trigger the CONTROLS_VIEW_THE_PARTICIPANTS_LIST_CHANGED event when necessary', () => {
+        locusInfo.controls = {};
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateControls(newControls);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {file: 'locus-info', function: 'updateControls'},
+          LOCUSINFO.EVENTS.CONTROLS_VIEW_THE_PARTICIPANTS_LIST_CHANGED,
+          {state: newControls.viewTheParticipantList},
+        );
+      });
+
+      it('should trigger the CONTROLS_RAISE_HAND_CHANGED event when necessary', () => {
+        locusInfo.controls = {};
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateControls(newControls);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {file: 'locus-info', function: 'updateControls'},
+          LOCUSINFO.EVENTS.CONTROLS_RAISE_HAND_CHANGED,
+          {state: newControls.raiseHand},
+        );
+      });
+
       it('should not trigger the CONTROLS_RECORDING_UPDATED event', () => {
         locusInfo.controls = {};
         locusInfo.emitScoped = sinon.stub();

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

@@ -56,6 +56,10 @@ describe('plugin-meetings', () => {
         canUpdateShareControl: null,
         canEnableViewTheParticipantsList: null,
         canDisableViewTheParticipantsList: null,
+        canEnableRaiseHand: null,
+        canDisableRaiseHand: null,
+        canEnableVideo: null,
+        canDisableVideo: null,
         ...expected,
       };
 
@@ -117,6 +121,10 @@ describe('plugin-meetings', () => {
       'canUpdateShareControl',
       'canEnableViewTheParticipantsList',
       'canDisableViewTheParticipantsList',
+      'canEnableRaiseHand',
+      'canDisableRaiseHand',
+      'canEnableVideo',
+      'canDisableVideo',
     ].forEach((key) => {
       it(`get and set for ${key} work as expected`, () => {
         const inMeetingActions = new InMeetingActions();

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

@@ -4839,6 +4839,114 @@ describe('plugin-meetings', () => {
           );
         });
 
+        it('listens to CONTROLS_MUTE_ON_ENTRY_CHANGED', async () => {
+          const state = {example: 'value'}
+
+          await meeting.locusInfo.emitScoped(
+            {function: 'test', file: 'test'},
+            LOCUSINFO.EVENTS.CONTROLS_MUTE_ON_ENTRY_CHANGED,
+            {state}
+          );
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setupLocusControlsListener'},
+            EVENT_TRIGGERS.MEETING_CONTROLS_MUTE_ON_ENTRY_UPDATED,
+            {state},
+          );
+        });
+
+        it('listens to MEETING_CONTROLS_SHARE_CONTROL_UPDATED', async () => {
+          const state = {example: 'value'}
+
+          await meeting.locusInfo.emitScoped(
+            {function: 'test', file: 'test'},
+            LOCUSINFO.EVENTS.CONTROLS_SHARE_CONTROL_CHANGED,
+            {state}
+          );
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setupLocusControlsListener'},
+            EVENT_TRIGGERS.MEETING_CONTROLS_SHARE_CONTROL_UPDATED,
+            {state},
+          );
+        });
+
+        it('listens to MEETING_CONTROLS_DISALLOW_UNMUTE_UPDATED', async () => {
+          const state = {example: 'value'}
+
+          await meeting.locusInfo.emitScoped(
+            {function: 'test', file: 'test'},
+            LOCUSINFO.EVENTS.CONTROLS_DISALLOW_UNMUTE_CHANGED,
+            {state}
+          );
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setupLocusControlsListener'},
+            EVENT_TRIGGERS.MEETING_CONTROLS_DISALLOW_UNMUTE_UPDATED,
+            {state},
+          );
+        });
+
+        it('listens to MEETING_CONTROLS_REACTIONS_UPDATED', async () => {
+          const state = {example: 'value'}
+
+          await meeting.locusInfo.emitScoped(
+            {function: 'test', file: 'test'},
+            LOCUSINFO.EVENTS.CONTROLS_REACTIONS_CHANGED,
+            {state}
+          );
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setupLocusControlsListener'},
+            EVENT_TRIGGERS.MEETING_CONTROLS_REACTIONS_UPDATED,
+            {state},
+          );
+        });
+
+        it('listens to MEETING_CONTROLS_VIEW_THE_PARTICIPANTS_LIST_UPDATED', async () => {
+          const state = {example: 'value'}
+
+          await meeting.locusInfo.emitScoped(
+            {function: 'test', file: 'test'},
+            LOCUSINFO.EVENTS.CONTROLS_VIEW_THE_PARTICIPANTS_LIST_CHANGED,
+            {state}
+          );
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setupLocusControlsListener'},
+            EVENT_TRIGGERS.MEETING_CONTROLS_VIEW_THE_PARTICIPANTS_LIST_UPDATED,
+            {state},
+          );
+        });
+
+        it('listens to MEETING_CONTROLS_RAISE_HAND_UPDATED', async () => {
+          const state = {example: 'value'}
+
+          await meeting.locusInfo.emitScoped(
+            {function: 'test', file: 'test'},
+            LOCUSINFO.EVENTS.CONTROLS_RAISE_HAND_CHANGED,
+            {state}
+          );
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setupLocusControlsListener'},
+            EVENT_TRIGGERS.MEETING_CONTROLS_RAISE_HAND_UPDATED,
+            {state},
+          );
+        });
+
         it('listens to the timing that user joined into breakout', async () => {
           const mainLocusUrl = 'mainLocusUrl123';