@webex/plugin-meetings 3.12.0-next.9 → 3.12.0-next.90

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';
@@ -26,6 +27,7 @@ describe('plugin-meetings', () => {
                 beforeEach(() => {
                   request = {
                     request: sinon.stub().returns(Promise.resolve()),
+                    locusDeltaRequest: sinon.stub().returns(Promise.resolve()),
                   };
 
                   manager = new ControlsOptionsManager(request);
@@ -58,11 +60,11 @@ describe('plugin-meetings', () => {
 
                       const result = manager.setMuteOnEntry(true);
 
-                      assert.calledWith(request.request, {  uri: 'test/id/controls',
+                      assert.calledWith(request.locusDeltaRequest, {  uri: 'test/id/controls',
                       body: { muteOnEntry: { enabled: true } },
                       method: HTTP_VERBS.PATCH});
 
-                      assert.deepEqual(result, request.request.firstCall.returnValue);
+                      assert.deepEqual(result, request.locusDeltaRequest.firstCall.returnValue);
                     });
 
                     it('can set mute on entry when the display hint is available enabled=false', () => {
@@ -70,11 +72,24 @@ describe('plugin-meetings', () => {
 
                       const result = manager.setMuteOnEntry(false);
 
-                      assert.calledWith(request.request, {  uri: 'test/id/controls',
+                      assert.calledWith(request.locusDeltaRequest, {  uri: 'test/id/controls',
                       body: { muteOnEntry: { enabled: false } },
                       method: HTTP_VERBS.PATCH});
 
-                      assert.deepEqual(result, request.request.firstCall.returnValue);
+                      assert.deepEqual(result, request.locusDeltaRequest.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.locusDeltaRequest, {  uri: 'test/id/controls',
+                      body: { muteOnEntry: { enabled: true } },
+                      method: HTTP_VERBS.PATCH});
+
+                      assert.deepEqual(result, request.locusDeltaRequest.firstCall.returnValue);
                     });
                   });
 
@@ -100,11 +115,11 @@ describe('plugin-meetings', () => {
 
                       const result = manager.setDisallowUnmute(true);
 
-                      assert.calledWith(request.request, {  uri: 'test/id/controls',
+                      assert.calledWith(request.locusDeltaRequest, {  uri: 'test/id/controls',
                       body: { disallowUnmute: { enabled: true } },
                       method: HTTP_VERBS.PATCH});
 
-                      assert.deepEqual(result, request.request.firstCall.returnValue);
+                      assert.deepEqual(result, request.locusDeltaRequest.firstCall.returnValue);
                     });
 
                     it('can set allow unmute when DISABLE_HARD_MUTE display hint is available', () => {
@@ -112,11 +127,24 @@ describe('plugin-meetings', () => {
 
                       const result = manager.setDisallowUnmute(false);
 
-                      assert.calledWith(request.request, {  uri: 'test/id/controls',
+                      assert.calledWith(request.locusDeltaRequest, {  uri: 'test/id/controls',
                       body: { disallowUnmute: { enabled: false } },
                       method: HTTP_VERBS.PATCH});
 
-                      assert.deepEqual(result, request.request.firstCall.returnValue);
+                      assert.deepEqual(result, request.locusDeltaRequest.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.locusDeltaRequest, {  uri: 'test/id/controls',
+                      body: { disallowUnmute: { enabled: true } },
+                      method: HTTP_VERBS.PATCH});
+
+                      assert.deepEqual(result, request.locusDeltaRequest.firstCall.returnValue);
                     });
                   });
             });
@@ -127,6 +155,7 @@ describe('plugin-meetings', () => {
               beforeEach(() => {
                 request = {
                   request: sinon.stub().resolves(),
+                  locusDeltaRequest: sinon.stub().resolves(),
                 };
 
                 manager = new ControlsOptionsManager(request);
@@ -138,6 +167,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';
 
@@ -163,7 +204,7 @@ describe('plugin-meetings', () => {
 
                 return manager.update(audio, reactions)
                   .then(() => {
-                    assert.calledWith(request.request, {
+                    assert.calledWith(request.locusDeltaRequest, {
                       uri: 'test/id/controls',
                       body: {
                         audio: audio.properties,
@@ -171,7 +212,7 @@ describe('plugin-meetings', () => {
                       method: HTTP_VERBS.PATCH,
                     });
 
-                    assert.calledWith(request.request, {
+                    assert.calledWith(request.locusDeltaRequest, {
                       uri: 'test/id/controls',
                       body: {
                         reactions: reactions.properties,
@@ -203,7 +244,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,20 +254,64 @@ describe('plugin-meetings', () => {
 
                 return manager.update(audio, reactions)
                   .then(() => {
+                    // Audio controls go directly to current locusUrl (no cross-locus authorization)
+                    assert.calledWith(request.locusDeltaRequest, {
+                      uri: 'test/id/controls',
+                      body: {
+                        audio: audio.properties,
+                      },
+                      method: HTTP_VERBS.PATCH,
+                    });
+
+                    // Non-audio controls go to mainLocusUrl with authorizingLocusUrl
                     assert.calledWith(request.request, {
                       uri: 'test/main/controls',
                       body: {
-                        audio: audio.properties,
+                        reactions: reactions.properties,
                         authorizingLocusUrl: 'test/id'
                       },
                       method: HTTP_VERBS.PATCH,
                     });
 
+                    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.locusDeltaRequest, {
+                      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'
+                        authorizingLocusUrl: 'test/id',
                       },
                       method: HTTP_VERBS.PATCH,
                     });
@@ -234,6 +319,110 @@ describe('plugin-meetings', () => {
                     Util.canUpdate = restorable;
                   });
               });
+
+              describe('viewTheParticipantList fill-in', () => {
+                let restorable;
+
+                afterEach(() => {
+                  Util.canUpdate = restorable;
+                });
+
+                describe('when meeting is a webinar', () => {
+                  beforeEach(() => {
+                    restorable = Util.canUpdate;
+                    Util.canUpdate = sinon.stub().returns(true);
+                    manager.set({
+                      locusUrl: 'test/id',
+                      displayHints: [],
+                      getControls: () => ({viewTheParticipantList: {enabled: true, panelistEnabled: true, attendeeCount: true}}),
+                      isWebinar: () => true,
+                    });
+                  });
+
+                  it('should fill in all undefined properties from current state', () => {
+                    const control = {scope: 'viewTheParticipantList', properties: {}};
+
+                    return manager.update(control).then(() => {
+                      assert.calledOnceWithExactly(request.locusDeltaRequest, {
+                        uri: 'test/id/controls',
+                        body: {
+                          viewTheParticipantList: {enabled: true, panelistEnabled: true, attendeeCount: true},
+                        },
+                        method: HTTP_VERBS.PATCH,
+                      });
+                    });
+                  });
+
+                  it('should keep explicitly provided properties and fill in the rest', () => {
+                    const control = {scope: 'viewTheParticipantList', properties: {enabled: false}};
+
+                    return manager.update(control).then(() => {
+                      assert.calledOnceWithExactly(request.locusDeltaRequest, {
+                        uri: 'test/id/controls',
+                        body: {
+                          viewTheParticipantList: {enabled: false, panelistEnabled: true, attendeeCount: true},
+                        },
+                        method: HTTP_VERBS.PATCH,
+                      });
+                    });
+                  });
+
+                  it('should not fill in properties when all are explicitly provided', () => {
+                    const control = {scope: 'viewTheParticipantList', properties: {enabled: false, panelistEnabled: false, attendeeCount: false}};
+
+                    return manager.update(control).then(() => {
+                      assert.calledOnceWithExactly(request.locusDeltaRequest, {
+                        uri: 'test/id/controls',
+                        body: {
+                          viewTheParticipantList: {enabled: false, panelistEnabled: false, attendeeCount: false},
+                        },
+                        method: HTTP_VERBS.PATCH,
+                      });
+                    });
+                  });
+                });
+
+                describe('when meeting is not a webinar', () => {
+                  beforeEach(() => {
+                    restorable = Util.canUpdate;
+                    Util.canUpdate = sinon.stub().returns(true);
+                    manager.set({
+                      locusUrl: 'test/id',
+                      displayHints: [],
+                      getControls: () => ({viewTheParticipantList: {enabled: true, panelistEnabled: true, attendeeCount: true}}),
+                      isWebinar: () => false,
+                    });
+                  });
+
+                  it('should only send enabled property', () => {
+                    const control = {scope: 'viewTheParticipantList', properties: {}};
+
+                    return manager.update(control).then(() => {
+                      assert.calledOnceWithExactly(request.locusDeltaRequest, {
+                        uri: 'test/id/controls',
+                        body: {
+                          viewTheParticipantList: {enabled: true},
+                        },
+                        method: HTTP_VERBS.PATCH,
+                      });
+                    });
+                  });
+
+                  it('should not include panelistEnabled or attendeeCount even if explicitly provided', () => {
+                    const control = {scope: 'viewTheParticipantList', properties: {enabled: false, panelistEnabled: true, attendeeCount: true}};
+
+                    return manager.update(control).then(() => {
+                      assert.calledOnceWithExactly(request.locusDeltaRequest, {
+                        uri: 'test/id/controls',
+                        body: {
+                          viewTheParticipantList: {enabled: false},
+                        },
+                        method: HTTP_VERBS.PATCH,
+                      });
+                    });
+                  });
+                });
+              });
             });
 
             describe('Mute/Unmute All', () => {
@@ -241,6 +430,7 @@ describe('plugin-meetings', () => {
               beforeEach(() => {
                 request = {
                   request: sinon.stub().returns(Promise.resolve()),
+                  locusDeltaRequest: sinon.stub().returns(Promise.resolve()),
                 };
 
                 manager = new ControlsOptionsManager(request);
@@ -252,6 +442,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);
 
@@ -273,11 +475,11 @@ describe('plugin-meetings', () => {
 
                 const result = manager.setMuteAll(true, true, true);
 
-                assert.calledWith(request.request, {  uri: 'test/id/controls',
+                assert.calledWith(request.locusDeltaRequest, {  uri: 'test/id/controls',
                 body: { audio: { muted: true, disallowUnmute: true, muteOnEntry: true } },
                 method: HTTP_VERBS.PATCH});
 
-                assert.deepEqual(result, request.request.firstCall.returnValue);
+                assert.deepEqual(result, request.locusDeltaRequest.firstCall.returnValue);
               });
 
               it('can set mute all when the display hint is available mutedEnabled=true', () => {
@@ -285,11 +487,11 @@ describe('plugin-meetings', () => {
 
                 const result = manager.setMuteAll(true, true, true);
 
-                assert.calledWith(request.request, {  uri: 'test/id/controls',
+                assert.calledWith(request.locusDeltaRequest, {  uri: 'test/id/controls',
                 body: { audio: { muted: true, disallowUnmute: true, muteOnEntry: true } },
                 method: HTTP_VERBS.PATCH});
 
-                assert.deepEqual(result, request.request.firstCall.returnValue);
+                assert.deepEqual(result, request.locusDeltaRequest.firstCall.returnValue);
               });
 
               it('can set mute all when the display hint is available mutedEnabled=true', () => {
@@ -297,11 +499,11 @@ describe('plugin-meetings', () => {
 
                 const result = manager.setMuteAll(true, true, true);
 
-                assert.calledWith(request.request, {  uri: 'test/id/controls',
+                assert.calledWith(request.locusDeltaRequest, {  uri: 'test/id/controls',
                 body: { audio: { muted: true, disallowUnmute: true, muteOnEntry: true } },
                 method: HTTP_VERBS.PATCH});
 
-                assert.deepEqual(result, request.request.firstCall.returnValue);
+                assert.deepEqual(result, request.locusDeltaRequest.firstCall.returnValue);
               });
 
               it('can set mute all when the display hint is available mutedEnabled=false', () => {
@@ -309,11 +511,11 @@ describe('plugin-meetings', () => {
 
                 const result = manager.setMuteAll(false, false, false);
 
-                assert.calledWith(request.request, {  uri: 'test/id/controls',
+                assert.calledWith(request.locusDeltaRequest, {  uri: 'test/id/controls',
                 body: { audio: { muted: false, disallowUnmute: false, muteOnEntry: false } },
                 method: HTTP_VERBS.PATCH});
 
-                assert.deepEqual(result, request.request.firstCall.returnValue);
+                assert.deepEqual(result, request.locusDeltaRequest.firstCall.returnValue);
               });
 
               it('can set mute all panelists when the display hint is available mutedEnabled=true', () => {
@@ -321,11 +523,11 @@ describe('plugin-meetings', () => {
 
                 const result = manager.setMuteAll(true, true, true, ['panelist']);
 
-                assert.calledWith(request.request, {  uri: 'test/id/controls',
+                assert.calledWith(request.locusDeltaRequest, {  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);
+                assert.deepEqual(result, request.locusDeltaRequest.firstCall.returnValue);
               });
 
               it('can set mute all attendees when the display hint is available mutedEnabled=true', () => {
@@ -333,24 +535,37 @@ describe('plugin-meetings', () => {
 
                 const result = manager.setMuteAll(true, true, true, ['attendee']);
 
-                assert.calledWith(request.request, {  uri: 'test/id/controls',
+                assert.calledWith(request.locusDeltaRequest, {  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);
+                assert.deepEqual(result, request.locusDeltaRequest.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.locusDeltaRequest, {  uri: 'test/id/controls',
+                  body: { audio: { muted: true, disallowUnmute: true, muteOnEntry: true, roles: ['attendee'] } },
+                  method: HTTP_VERBS.PATCH});
+
+                assert.deepEqual(result, request.locusDeltaRequest.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.locusDeltaRequest, {  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);
+                assert.deepEqual(result, request.locusDeltaRequest.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');
+        });
+      });
     });
   });
 });