@webex/plugin-meetings 3.12.0-next.3 → 3.12.0-next.30

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

@@ -1,5 +1,6 @@
 import ControlsOptionsManager from '@webex/plugin-meetings/src/controls-options-manager';
 import Util from '@webex/plugin-meetings/src/controls-options-manager/util';
+import ParameterError from '@webex/plugin-meetings/src/common/errors/parameter';
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
 import { HTTP_VERBS } from '@webex/plugin-meetings/src/constants';
@@ -76,6 +77,19 @@ describe('plugin-meetings', () => {
 
                       assert.deepEqual(result, request.request.firstCall.returnValue);
                     });
+
+                    it('should send setMuteOnEntry to locusUrl without authorizingLocusUrl when in breakout', () => {
+                      manager.setDisplayHints(['ENABLE_MUTE_ON_ENTRY']);
+                      manager.mainLocusUrl = 'test/main';
+
+                      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);
+                    });
                   });
 
                   describe('setDisallowUnmute', () => {
@@ -118,6 +132,19 @@ describe('plugin-meetings', () => {
 
                       assert.deepEqual(result, request.request.firstCall.returnValue);
                     });
+
+                    it('should send setDisallowUnmute to locusUrl without authorizingLocusUrl when in breakout', () => {
+                      manager.setDisplayHints(['ENABLE_HARD_MUTE']);
+                      manager.mainLocusUrl = 'test/main';
+
+                      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);
+                    });
                   });
             });
 
@@ -138,6 +165,18 @@ describe('plugin-meetings', () => {
                 });
               });
 
+              it('should reject with ParameterError when locusUrl is not set', () => {
+                const noLocusManager = new ControlsOptionsManager(request);
+
+                const result = noLocusManager.update({scope: 'audio', properties: {muted: true}});
+
+                assert.notCalled(request.request);
+                return assert.isRejected(result).then((err) => {
+                  assert.instanceOf(err, ParameterError);
+                  assert.match(err.message, /locusUrl.*must be defined/);
+                });
+              });
+
               it('should throw an error if the scope is not supported', () => {
                 const scope = 'invalid';
 
@@ -203,7 +242,7 @@ describe('plugin-meetings', () => {
                   });
               });
 
-              it('should call request with mainLocusUrl and locusUrl as authorizingLocusUrl if mainLocusUrl is exist and not same with locusUrl', () => {
+              it('should send audio controls to locusUrl without authorizingLocusUrl and non-audio to mainLocusUrl with authorizingLocusUrl when in breakout', () => {
                 const restorable = Util.canUpdate;
                 Util.canUpdate = sinon.stub().returns(true);
                 manager.mainLocusUrl = 'test/main';
@@ -213,15 +252,16 @@ describe('plugin-meetings', () => {
 
                 return manager.update(audio, reactions)
                   .then(() => {
+                    // Audio controls go directly to current locusUrl (no cross-locus authorization)
                     assert.calledWith(request.request, {
-                      uri: 'test/main/controls',
+                      uri: 'test/id/controls',
                       body: {
                         audio: audio.properties,
-                        authorizingLocusUrl: 'test/id'
                       },
                       method: HTTP_VERBS.PATCH,
                     });
 
+                    // Non-audio controls go to mainLocusUrl with authorizingLocusUrl
                     assert.calledWith(request.request, {
                       uri: 'test/main/controls',
                       body: {
@@ -234,6 +274,49 @@ describe('plugin-meetings', () => {
                     Util.canUpdate = restorable;
                   });
               });
+
+              it('should send audio controls to locusUrl without authorizingLocusUrl when in breakout', () => {
+                const restorable = Util.canUpdate;
+                Util.canUpdate = sinon.stub().returns(true);
+                manager.mainLocusUrl = 'test/main';
+
+                const audio = {scope: 'audio', properties: {muted: true, disallowUnmute: false}};
+
+                return manager.update(audio)
+                  .then(() => {
+                    assert.calledWith(request.request, {
+                      uri: 'test/id/controls',
+                      body: {
+                        audio: audio.properties,
+                      },
+                      method: HTTP_VERBS.PATCH,
+                    });
+
+                    Util.canUpdate = restorable;
+                  });
+              });
+
+              it('should send non-audio controls to mainLocusUrl with authorizingLocusUrl when in breakout', () => {
+                const restorable = Util.canUpdate;
+                Util.canUpdate = sinon.stub().returns(true);
+                manager.mainLocusUrl = 'test/main';
+
+                const reactions = {scope: 'reactions', properties: {enabled: true}};
+
+                return manager.update(reactions)
+                  .then(() => {
+                    assert.calledWith(request.request, {
+                      uri: 'test/main/controls',
+                      body: {
+                        reactions: reactions.properties,
+                        authorizingLocusUrl: 'test/id',
+                      },
+                      method: HTTP_VERBS.PATCH,
+                    });
+
+                    Util.canUpdate = restorable;
+                  });
+              });
             });
 
             describe('Mute/Unmute All', () => {
@@ -252,6 +335,18 @@ describe('plugin-meetings', () => {
                 })
               });
 
+              it('should reject with ParameterError when locusUrl is not set', () => {
+                const noLocusManager = new ControlsOptionsManager(request);
+
+                const result = noLocusManager.setMuteAll(true, true, true);
+
+                assert.notCalled(request.request);
+                return assert.isRejected(result).then((err) => {
+                  assert.instanceOf(err, ParameterError);
+                  assert.match(err.message, /locusUrl.*must be defined/);
+                });
+              });
+
               it('rejects when correct display hint is not present mutedEnabled=false', () => {
                 const result = manager.setMuteAll(false, false, false);
 
@@ -340,14 +435,27 @@ describe('plugin-meetings', () => {
                 assert.deepEqual(result, request.request.firstCall.returnValue);
               });
 
-              it('request with mainLocusUrl and make locusUrl as authorizingLocusUrl if mainLocusUrl is exist and not same with locusUrl', () => {
+              it('should send setMuteAll to locusUrl without authorizingLocusUrl when in breakout', () => {
                 manager.setDisplayHints(['MUTE_ALL', 'DISABLE_HARD_MUTE', 'DISABLE_MUTE_ON_ENTRY']);
                 manager.mainLocusUrl = `test/main`;
 
                 const result = manager.setMuteAll(true, true, true, ['attendee']);
 
-                assert.calledWith(request.request, {  uri: 'test/main/controls',
-                  body: { audio: { muted: true, disallowUnmute: true, muteOnEntry: true, roles: ['attendee'] }, authorizingLocusUrl: 'test/id' },
+                assert.calledWith(request.request, {  uri: 'test/id/controls',
+                  body: { audio: { muted: true, disallowUnmute: true, muteOnEntry: true, roles: ['attendee'] } },
+                  method: HTTP_VERBS.PATCH});
+
+                assert.deepEqual(result, request.request.firstCall.returnValue);
+              });
+
+              it('should send setMuteAll with PANELIST role to locusUrl without authorizingLocusUrl when in breakout', () => {
+                manager.setDisplayHints(['MUTE_ALL', 'ENABLE_HARD_MUTE', 'ENABLE_MUTE_ON_ENTRY']);
+                manager.mainLocusUrl = `test/main`;
+
+                const result = manager.setMuteAll(true, true, true, ['PANELIST']);
+
+                assert.calledWith(request.request, {  uri: 'test/id/controls',
+                  body: { audio: { muted: true, disallowUnmute: true, muteOnEntry: true, roles: ['PANELIST'] } },
                   method: HTTP_VERBS.PATCH});
 
                 assert.deepEqual(result, request.request.firstCall.returnValue);

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

@@ -799,6 +799,171 @@ describe('plugin-meetings', () => {
           );
         });
       });
+
+      describe('isAudioControl()', () => {
+        it('should return true when all body keys are audio control keys', () => {
+          assert.isTrue(ControlsOptionsUtil.isAudioControl({audio: {muted: true}}));
+        });
+
+        it('should return true when body has muteOnEntry key', () => {
+          assert.isTrue(ControlsOptionsUtil.isAudioControl({muteOnEntry: {enabled: true}}));
+        });
+
+        it('should return true when body has disallowUnmute key', () => {
+          assert.isTrue(ControlsOptionsUtil.isAudioControl({disallowUnmute: {enabled: true}}));
+        });
+
+        it('should return true when body has multiple audio control keys', () => {
+          assert.isTrue(ControlsOptionsUtil.isAudioControl({audio: {muted: true}, muteOnEntry: {enabled: true}, disallowUnmute: {enabled: true}}));
+        });
+
+        it('should return false when body has a non-audio control key', () => {
+          assert.isFalse(ControlsOptionsUtil.isAudioControl({raiseHand: {enabled: true}}));
+        });
+
+        it('should return false when body has a mix of audio and non-audio keys', () => {
+          assert.isFalse(ControlsOptionsUtil.isAudioControl({audio: {muted: true}, raiseHand: {enabled: true}}));
+        });
+
+        it('should return true for an empty body', () => {
+          assert.isTrue(ControlsOptionsUtil.isAudioControl({}));
+        });
+      });
+
+      describe('isBreakoutLocusUrl()', () => {
+        it('should return true when mainLocusUrl differs from locusUrl', () => {
+          assert.isTrue(ControlsOptionsUtil.isBreakoutLocusUrl('locus/breakout', 'locus/main'));
+        });
+
+        it('should return false when mainLocusUrl equals locusUrl', () => {
+          assert.isFalse(ControlsOptionsUtil.isBreakoutLocusUrl('locus/main', 'locus/main'));
+        });
+
+        it('should return false when mainLocusUrl is undefined', () => {
+          assert.isFalse(ControlsOptionsUtil.isBreakoutLocusUrl('locus/breakout', undefined));
+        });
+
+        it('should return false when mainLocusUrl is null', () => {
+          assert.isFalse(ControlsOptionsUtil.isBreakoutLocusUrl('locus/breakout', null));
+        });
+
+        it('should return false when mainLocusUrl is empty string', () => {
+          assert.isFalse(ControlsOptionsUtil.isBreakoutLocusUrl('locus/breakout', ''));
+        });
+      });
+
+      describe('getControlsRequestParams()', () => {
+        const locusUrl = 'locus/breakout';
+        const mainLocusUrl = 'locus/main';
+
+        it('should return full request params targeting locusUrl when not in a breakout', () => {
+          const result = ControlsOptionsUtil.getControlsRequestParams({
+            body: {raiseHand: {enabled: true}},
+            locusUrl: 'locus/main',
+            mainLocusUrl: 'locus/main',
+          });
+
+          assert.equal(result.uri, 'locus/main/controls');
+          assert.deepEqual(result.body, {raiseHand: {enabled: true}});
+          assert.equal(result.method, 'PATCH');
+        });
+
+        it('should return mainLocusUrl with authorizingLocusUrl in body for non-audio controls in a breakout', () => {
+          const result = ControlsOptionsUtil.getControlsRequestParams({
+            body: {raiseHand: {enabled: true}},
+            locusUrl,
+            mainLocusUrl,
+          });
+
+          assert.equal(result.uri, 'locus/main/controls');
+          assert.deepEqual(result.body, {raiseHand: {enabled: true}, authorizingLocusUrl: locusUrl});
+          assert.equal(result.method, 'PATCH');
+        });
+
+        it('should return locusUrl without authorizingLocusUrl for audio controls in a breakout', () => {
+          const result = ControlsOptionsUtil.getControlsRequestParams({
+            body: {audio: {muted: true}},
+            locusUrl,
+            mainLocusUrl,
+          });
+
+          assert.equal(result.uri, 'locus/breakout/controls');
+          assert.deepEqual(result.body, {audio: {muted: true}});
+          assert.equal(result.method, 'PATCH');
+        });
+
+        it('should return locusUrl without authorizingLocusUrl for muteOnEntry in a breakout', () => {
+          const result = ControlsOptionsUtil.getControlsRequestParams({
+            body: {muteOnEntry: {enabled: true}},
+            locusUrl,
+            mainLocusUrl,
+          });
+
+          assert.equal(result.uri, 'locus/breakout/controls');
+          assert.deepEqual(result.body, {muteOnEntry: {enabled: true}});
+          assert.equal(result.method, 'PATCH');
+        });
+
+        it('should return locusUrl without authorizingLocusUrl for disallowUnmute in a breakout', () => {
+          const result = ControlsOptionsUtil.getControlsRequestParams({
+            body: {disallowUnmute: {enabled: true}},
+            locusUrl,
+            mainLocusUrl,
+          });
+
+          assert.equal(result.uri, 'locus/breakout/controls');
+          assert.deepEqual(result.body, {disallowUnmute: {enabled: true}});
+          assert.equal(result.method, 'PATCH');
+        });
+
+        it('should return locusUrl when mainLocusUrl is undefined', () => {
+          const result = ControlsOptionsUtil.getControlsRequestParams({
+            body: {raiseHand: {enabled: true}},
+            locusUrl,
+            mainLocusUrl: undefined,
+          });
+
+          assert.equal(result.uri, 'locus/breakout/controls');
+          assert.deepEqual(result.body, {raiseHand: {enabled: true}});
+          assert.equal(result.method, 'PATCH');
+        });
+
+        it('should return locusUrl when mainLocusUrl is null', () => {
+          const result = ControlsOptionsUtil.getControlsRequestParams({
+            body: {raiseHand: {enabled: true}},
+            locusUrl,
+            mainLocusUrl: null,
+          });
+
+          assert.equal(result.uri, 'locus/breakout/controls');
+          assert.deepEqual(result.body, {raiseHand: {enabled: true}});
+          assert.equal(result.method, 'PATCH');
+        });
+
+        it('should return locusUrl when mainLocusUrl is empty string', () => {
+          const result = ControlsOptionsUtil.getControlsRequestParams({
+            body: {raiseHand: {enabled: true}},
+            locusUrl,
+            mainLocusUrl: '',
+          });
+
+          assert.equal(result.uri, 'locus/breakout/controls');
+          assert.deepEqual(result.body, {raiseHand: {enabled: true}});
+          assert.equal(result.method, 'PATCH');
+        });
+
+        it('should return locusUrl for audio controls when not in a breakout', () => {
+          const result = ControlsOptionsUtil.getControlsRequestParams({
+            body: {audio: {muted: true}},
+            locusUrl: 'locus/main',
+            mainLocusUrl: 'locus/main',
+          });
+
+          assert.equal(result.uri, 'locus/main/controls');
+          assert.deepEqual(result.body, {audio: {muted: true}});
+          assert.equal(result.method, 'PATCH');
+        });
+      });
     });
   });
 });