@webex/plugin-meetings 3.0.0-beta.80 → 3.0.0-beta.82

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

@@ -1,5 +1,7 @@
+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', () => {
@@ -8,6 +10,8 @@ describe('plugin-meetings', () => {
             let locusInfo;
         
             beforeEach(() => {
+              sinon.restore();
+
               locusInfo = {
                 parsedLocus: {
                   info: {
@@ -16,6 +20,319 @@ describe('plugin-meetings', () => {
                 },
               };
             });
+
+            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('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 all properties after negotiating hints', () => {
+                const properties = {
+                  enabled: true,
+                  showDisplayNameWithReactions: true,
+                };
+
+                ControlsOptionsUtil.canUpdateReactions({properties}, []);
+
+                assert.calledWith(ControlsOptionsUtil.hasHints, {
+                  requiredHints: [
+                    DISPLAY_HINTS.ENABLE_REACTIONS,
+                    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('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 = [];
+              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.canUpdateReactions = sinon.stub().returns(true);
+                ControlsOptionsUtil.canUpdateShareControl = 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.canUpdateReactions, 0);
+                assert.callCount(ControlsOptionsUtil.canUpdateShareControl, 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.calledWith(ControlsOptionsUtil.canUpdateReactions, control, displayHints);
+                assert.callCount(ControlsOptionsUtil.canUpdateShareControl, 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.canUpdateReactions, 0);
+                assert.calledWith(ControlsOptionsUtil.canUpdateShareControl, 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.canUpdateReactions, 0);
+                assert.callCount(ControlsOptionsUtil.canUpdateShareControl, 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.canUpdateReactions, 0);
+                assert.callCount(ControlsOptionsUtil.canUpdateShareControl, 0);
+                assert.callCount(ControlsOptionsUtil.canUpdateViewTheParticipantsList, 0);
+                assert.isFalse(results);
+              });
+            });
         
             describe('canUserSetMuteOnEntry', () => {
               it('can set mute on entry enable', () => {

package/test/unit/spec/media/index.ts

@@ -119,6 +119,7 @@ describe('createMediaConnection', () => {
         username: 'turn username',
         password: 'turn password',
       },
+      bundlePolicy: 'max-bundle',
     });
     assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
     assert.calledWith(
@@ -133,6 +134,7 @@ describe('createMediaConnection', () => {
         ],
         enableMainAudio: true,
         enableMainVideo: true,
+        bundlePolicy: 'max-bundle',
       },
       'some debug id'
     );
@@ -168,6 +170,7 @@ describe('createMediaConnection', () => {
           iceServers: [],
           enableMainAudio,
           enableMainVideo,
+          bundlePolicy: undefined,
         },
         'some debug id'
       );
@@ -198,6 +201,7 @@ describe('createMediaConnection', () => {
         iceServers: [],
         enableMainAudio: true,
         enableMainVideo: true,
+        bundlePolicy: undefined,
       },
       'debug string'
     );

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

@@ -1484,6 +1484,48 @@ describe('plugin-meetings', () => {
             });
           });
         });
+
+        it('should pass bundlePolicy to createMediaConnection', async () => {
+          const FAKE_TURN_URL = 'turns:webex.com:3478';
+          const FAKE_TURN_USER = 'some-turn-username';
+          const FAKE_TURN_PASSWORD = 'some-password';
+
+          meeting.meetingState = 'ACTIVE';
+          Media.createMediaConnection.resetHistory();
+
+          meeting.roap.doTurnDiscovery = sinon.stub().resolves({
+            turnServerInfo: {
+              url: FAKE_TURN_URL,
+              username: FAKE_TURN_USER,
+              password: FAKE_TURN_PASSWORD,
+            },
+            turnServerSkippedReason: undefined,
+          });
+          const media = meeting.addMedia({
+            mediaSettings: {},
+            bundlePolicy: 'bundlePolicy-value',
+          });
+
+          assert.exists(media);
+          await media;
+          assert.calledOnce(meeting.roap.doTurnDiscovery);
+          assert.calledWith(meeting.roap.doTurnDiscovery, meeting, false);
+          assert.calledOnce(Media.createMediaConnection);
+          assert.calledWith(
+            Media.createMediaConnection,
+            false,
+            meeting.getMediaConnectionDebugId(),
+            sinon.match({
+              turnServerInfo: {
+                url: FAKE_TURN_URL,
+                username: FAKE_TURN_USER,
+                password: FAKE_TURN_PASSWORD,
+              },
+              bundlePolicy: 'bundlePolicy-value',
+            })
+          );
+          assert.calledOnce(fakeMediaConnection.initiateOffer);
+        });
       });
       describe('#acknowledge', () => {
         it('should have #acknowledge', () => {