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

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

@@ -0,0 +1,518 @@
+import { DISPLAY_HINTS } from '@webex/plugin-meetings/src/constants';
+import ControlsOptionsUtil from '@webex/plugin-meetings/src/controls-options-manager/util';
+import { assert } from 'chai';
+import sinon from 'sinon';
+
+describe('plugin-meetings', () => {
+    describe('controls-option-manager tests', () => {
+        describe('util tests', () => {
+
+            let locusInfo;
+        
+            beforeEach(() => {
+              sinon.restore();
+
+              locusInfo = {
+                parsedLocus: {
+                  info: {
+                    userDisplayHints: [],
+                  },
+                },
+              };
+            });
+
+            describe('hasHints()', () => {
+              it('should return true if all hints are found', () => {
+                const hints = ['EXAMPLE_HINT_A', 'EXAMPLE_HINT_B']
+                
+                locusInfo.parsedLocus.info.userDisplayHints.push(...hints);
+
+                assert.isTrue(ControlsOptionsUtil.hasHints({requiredHints: hints, displayHints: hints}));
+              });
+
+              it('should return false if all hints are not found', () => {
+                const hints = ['EXAMPLE_HINT_A', 'EXAMPLE_HINT_B']
+                
+                locusInfo.parsedLocus.info.userDisplayHints.push(...hints);
+
+                assert.isFalse(ControlsOptionsUtil.hasHints({requiredHints: hints, displayHints: []}));
+              });
+            });
+
+            describe('canUpdateAudio()', () => {
+              beforeEach(() => {
+                ControlsOptionsUtil.hasHints = sinon.stub().returns(true);
+              });
+
+              it('should call hasHints() with proper hints when `muted` is true', () => {
+                ControlsOptionsUtil.canUpdateAudio({properties: {muted: true}}, [])
+
+                assert.calledWith(ControlsOptionsUtil.hasHints, {
+                  requiredHints: [DISPLAY_HINTS.MUTE_ALL],
+                  displayHints: [],
+                });
+              });
+
+              it('should call hasHints() with proper hints when `muted` is false', () => {
+                ControlsOptionsUtil.canUpdateAudio({properties: {muted: false}}, [])
+
+                assert.calledWith(ControlsOptionsUtil.hasHints, {
+                  requiredHints: [DISPLAY_HINTS.UNMUTE_ALL],
+                  displayHints: [],
+                });
+              });
+
+              it('should call hasHints() with proper hints when `disallowUnmute` is true', () => {
+                ControlsOptionsUtil.canUpdateAudio({properties: {disallowUnmute: true}}, [])
+
+                assert.calledWith(ControlsOptionsUtil.hasHints, {
+                  requiredHints: [DISPLAY_HINTS.ENABLE_HARD_MUTE],
+                  displayHints: [],
+                });
+              });
+
+              it('should call hasHints() with proper hints when `disallowUnmute` is false', () => {
+                ControlsOptionsUtil.canUpdateAudio({properties: {disallowUnmute: false}}, [])
+
+                assert.calledWith(ControlsOptionsUtil.hasHints, {
+                  requiredHints: [DISPLAY_HINTS.DISABLE_HARD_MUTE],
+                  displayHints: [],
+                });
+              });
+
+              it('should call hasHints() with proper hints when `muteOnEntry` is true', () => {
+                ControlsOptionsUtil.canUpdateAudio({properties: {muteOnEntry: true}}, [])
+
+                assert.calledWith(ControlsOptionsUtil.hasHints, {
+                  requiredHints: [DISPLAY_HINTS.ENABLE_MUTE_ON_ENTRY],
+                  displayHints: [],
+                });
+              });
+
+              it('should call hasHints() with proper hints when `muteOnEntry` is false', () => {
+                ControlsOptionsUtil.canUpdateAudio({properties: {muteOnEntry: false}}, [])
+
+                assert.calledWith(ControlsOptionsUtil.hasHints, {
+                  requiredHints: [DISPLAY_HINTS.DISABLE_MUTE_ON_ENTRY],
+                  displayHints: [],
+                });
+              });
+
+              it('should call hasHints() with all properties after negotiating hints', () => {
+                const properties = {
+                  muted: true,
+                  disallowUnmute: true,
+                  muteOnEntry: true,
+                };
+
+                ControlsOptionsUtil.canUpdateAudio({properties}, []);
+
+                assert.calledWith(ControlsOptionsUtil.hasHints, {
+                  requiredHints: [
+                    DISPLAY_HINTS.MUTE_ALL,
+                    DISPLAY_HINTS.ENABLE_HARD_MUTE,
+                    DISPLAY_HINTS.ENABLE_MUTE_ON_ENTRY,
+                  ],
+                  displayHints: [],
+                });
+              });
+
+              it('should return the resolution of hasHints()', () => {
+                const expected = 'example-return-value'
+                ControlsOptionsUtil.hasHints = sinon.stub().returns(expected);
+
+                const results = ControlsOptionsUtil.canUpdateAudio({properties: {}}, []);
+
+                assert.calledOnce(ControlsOptionsUtil.hasHints);
+                assert.equal(results, expected);
+              });
+            });
+
+            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);
+              });
+
+              it('should call hasHints() with proper hints when `enabled` is true', () => {
+                ControlsOptionsUtil.canUpdateReactions({properties: {enabled: true}}, [])
+
+                assert.calledWith(ControlsOptionsUtil.hasHints, {
+                  requiredHints: [DISPLAY_HINTS.ENABLE_REACTIONS],
+                  displayHints: [],
+                });
+              });
+
+              it('should call hasHints() with proper hints when `enabled` is false', () => {
+                ControlsOptionsUtil.canUpdateReactions({properties: {enabled: false}}, [])
+
+                assert.calledWith(ControlsOptionsUtil.hasHints, {
+                  requiredHints: [DISPLAY_HINTS.DISABLE_REACTIONS],
+                  displayHints: [],
+                });
+              });
+
+              it('should call hasHints() with proper hints when `showDisplayNameWithReactions` is true', () => {
+                ControlsOptionsUtil.canUpdateReactions({properties: {showDisplayNameWithReactions: true}}, [])
+
+                assert.calledWith(ControlsOptionsUtil.hasHints, {
+                  requiredHints: [DISPLAY_HINTS.ENABLE_SHOW_DISPLAY_NAME],
+                  displayHints: [],
+                });
+              });
+
+              it('should call hasHints() with proper hints when `showDisplayNameWithReactions` is false', () => {
+                ControlsOptionsUtil.canUpdateReactions({properties: {showDisplayNameWithReactions: false}}, [])
+
+                assert.calledWith(ControlsOptionsUtil.hasHints, {
+                  requiredHints: [DISPLAY_HINTS.DISABLE_SHOW_DISPLAY_NAME],
+                  displayHints: [],
+                });
+              });
+
+              it('should call hasHints() with only enabled hints when respective property is provided', () => {
+                const properties = {
+                  enabled: true,
+                };
+
+                ControlsOptionsUtil.canUpdateReactions({properties}, []);
+
+                assert.calledWith(ControlsOptionsUtil.hasHints, {
+                  requiredHints: [
+                    DISPLAY_HINTS.ENABLE_REACTIONS,
+                  ],
+                  displayHints: [],
+                });
+              });
+
+              it('should call hasHints() with only display name hints when respective property is provided', () => {
+                const properties = {
+                  enabled: true,
+                  showDisplayNameWithReactions: true,
+                };
+
+                ControlsOptionsUtil.canUpdateReactions({properties}, []);
+
+                assert.calledWith(ControlsOptionsUtil.hasHints, {
+                  requiredHints: [
+                    DISPLAY_HINTS.ENABLE_SHOW_DISPLAY_NAME,
+                  ],
+                  displayHints: [],
+                });
+              });
+
+              it('should return the resolution of hasHints()', () => {
+                const expected = 'example-return-value'
+                ControlsOptionsUtil.hasHints = sinon.stub().returns(expected);
+
+                const results = ControlsOptionsUtil.canUpdateReactions({properties: {}}, []);
+
+                assert.calledOnce(ControlsOptionsUtil.hasHints);
+                assert.equal(results, expected);
+              });
+            });
+
+            describe('canUpdateShareControl()', () => {
+              beforeEach(() => {
+                ControlsOptionsUtil.hasHints = sinon.stub().returns(true);
+              });
+
+              it('should call hasHints() with proper hints', () => {
+                ControlsOptionsUtil.canUpdateShareControl([])
+
+                assert.calledWith(ControlsOptionsUtil.hasHints, {
+                  requiredHints: [DISPLAY_HINTS.SHARE_CONTROL],
+                  displayHints: [],
+                });
+              });
+
+              it('should return the resolution of hasHints()', () => {
+                const expected = 'example-return-value'
+                ControlsOptionsUtil.hasHints = sinon.stub().returns(expected);
+
+                const results = ControlsOptionsUtil.canUpdateShareControl([]);
+
+                assert.calledOnce(ControlsOptionsUtil.hasHints);
+                assert.equal(results, expected);
+              });
+            });
+
+            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);
+              });
+
+              it('should call hasHints() with proper hints when `enabled` is true', () => {
+                ControlsOptionsUtil.canUpdateViewTheParticipantsList({properties: {enabled: true}}, [])
+
+                assert.calledWith(ControlsOptionsUtil.hasHints, {
+                  requiredHints: [DISPLAY_HINTS.ENABLE_VIEW_THE_PARTICIPANT_LIST],
+                  displayHints: [],
+                });
+              });
+
+              it('should call hasHints() with proper hints when `enabled` is false', () => {
+                ControlsOptionsUtil.canUpdateViewTheParticipantsList({properties: {enabled: false}}, [])
+
+                assert.calledWith(ControlsOptionsUtil.hasHints, {
+                  requiredHints: [DISPLAY_HINTS.DISABLE_VIEW_THE_PARTICIPANT_LIST],
+                  displayHints: [],
+                });
+              });
+
+              it('should return the resolution of hasHints()', () => {
+                const expected = 'example-return-value'
+                ControlsOptionsUtil.hasHints = sinon.stub().returns(expected);
+
+                const results = ControlsOptionsUtil.canUpdateViewTheParticipantsList({properties: {}}, []);
+
+                assert.calledOnce(ControlsOptionsUtil.hasHints);
+                assert.equal(results, expected);
+              });
+            });
+
+            describe('canUpdate()', () => {
+              const displayHints = [];
+
+              beforeEach(() => {
+                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);
+              });
+
+              it('should only call canUpdateAudio() if the scope is audio', () => {
+                const control = { scope: 'audio' };
+
+                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);
+              });
+
+              it('should only call canUpdateShareControl() if the scope is shareControl', () => {
+                const control = { scope: 'shareControl' };
+
+                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);
+              });
+
+              it('should only call canUpdateViewTheParticipantsList() if the scope is viewTheParticipantList', () => {
+                const control = { scope: 'viewTheParticipantList' };
+
+                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);
+              });
+
+              it('should return false when the provided control scope is not supported', () => {
+                const control = { scope: 'invalid' };
+
+                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);
+              });
+            });
+        
+            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);
+              });
+            });
+
+            describe('canSetMuteAll', () => {
+              it('can mute all', () => {
+                locusInfo.parsedLocus.info.userDisplayHints.push('MUTE_ALL');
+
+                assert.equal(ControlsOptionsUtil.canSetMuted(locusInfo.parsedLocus.info.userDisplayHints), true);
+              });
+
+              it('can unmute all', () => {
+                locusInfo.parsedLocus.info.userDisplayHints.push('UNMUTE_ALL');
+
+                assert.equal(ControlsOptionsUtil.canUnsetMuted(locusInfo.parsedLocus.info.userDisplayHints), true);
+              });
+              it('rejects when correct display hint is not present', () => {
+                assert.equal(ControlsOptionsUtil.canSetMuted(locusInfo.parsedLocus.info.userDisplayHints), false);
+              });
+
+              it('rejects when correct display hint is not present', () => {
+                assert.equal(ControlsOptionsUtil.canUnsetMuted(locusInfo.parsedLocus.info.userDisplayHints), false);
+              });
+            });
+        });
+    });
+});

package/test/unit/spec/fixture/locus.js

@@ -240,6 +240,7 @@ export default {
         },
       },
       doesNotSupportBreakouts: true,
+      annotatorAssignmentNotAllowed: true,
       identityTrustLevel: 'INTERNAL',
       id: 'e0d54e94-226c-3290-b75a-83cc1dbf',
       guest: false,

package/test/unit/spec/interpretation/collection.ts

@@ -0,0 +1,15 @@
+import {assert} from '@webex/test-helper-chai';
+import SILanguage from '@webex/plugin-meetings/src/interpretation/siLanguage';
+import SILanguageCollection from '@webex/plugin-meetings/src/interpretation/collection';
+
+describe('plugin-meetings', () => {
+  describe('SILanguageCollection', () => {
+    it('the siLanguages collection is as expected', () => {
+      const collection = new SILanguageCollection();
+
+      assert.equal(collection.model, SILanguage);
+      assert.equal(collection.namespace, 'Meetings');
+      assert.equal(collection.mainIndex, 'languageName');
+    });
+  });
+});