@webex/plugin-meetings 3.12.0-next.6 → 3.12.0-next.60

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

@@ -55,6 +55,27 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#locusUrlUpdate', () => {
+      it('should update the locusUrl property', () => {
+        const testLocusUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/test-id';
+
+        aiEnableRequest.locusUrlUpdate(testLocusUrl);
+
+        assert.equal(aiEnableRequest.locusUrl, testLocusUrl);
+      });
+
+      it('should handle updating locusUrl multiple times', () => {
+        const firstUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/test-id-1';
+        const secondUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/test-id-2';
+
+        aiEnableRequest.locusUrlUpdate(firstUrl);
+        assert.equal(aiEnableRequest.locusUrl, firstUrl);
+
+        aiEnableRequest.locusUrlUpdate(secondUrl);
+        assert.equal(aiEnableRequest.locusUrl, secondUrl);
+      });
+    });
+
     describe('#selfParticipantIdUpdate', () => {
       it('should update the selfParticipantId property', () => {
         const testSelfParticipantId = 'participant-123';
@@ -254,6 +275,71 @@ describe('plugin-meetings', () => {
         sinon.assert.notCalled(triggerSpy);
       });
 
+      it('should not trigger event when locusUrl does not match', () => {
+        const testLocusUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/test-id';
+        const differentLocusUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/different-id';
+
+        aiEnableRequest.locusUrl = testLocusUrl;
+
+        // Reset the spy after setting locusUrl to avoid counting property change events
+        triggerSpy.resetHistory();
+
+        aiEnableRequest.listenToApprovalRequests();
+
+        const event = {
+          data: {
+            locusUrl: differentLocusUrl,
+            approval: {
+              resourceType: AI_ENABLE_REQUEST.RESOURCE_TYPE,
+              receivers: [{participantId: testSelfParticipantId}],
+              initiator: {participantId: testInitiatorId},
+              actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+              url: testUrl,
+            },
+          },
+        };
+
+        webex.internal.mercury.emit(`event:${LOCUSEVENT.APPROVAL_REQUEST}`, event);
+
+        sinon.assert.notCalled(triggerSpy);
+      });
+
+      it('should trigger event when locusUrl matches', () => {
+        const testLocusUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/test-id';
+
+        aiEnableRequest.locusUrl = testLocusUrl;
+
+        // Reset the spy after setting locusUrl to avoid counting property change events
+        triggerSpy.resetHistory();
+
+        aiEnableRequest.listenToApprovalRequests();
+
+        const event = {
+          data: {
+            locusUrl: testLocusUrl,
+            approval: {
+              resourceType: AI_ENABLE_REQUEST.RESOURCE_TYPE,
+              receivers: [{participantId: testSelfParticipantId}],
+              initiator: {participantId: testInitiatorId},
+              actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+              url: testUrl,
+            },
+          },
+        };
+
+        webex.internal.mercury.emit(`event:${LOCUSEVENT.APPROVAL_REQUEST}`, event);
+
+        sinon.assert.calledOnce(triggerSpy);
+        sinon.assert.calledWith(triggerSpy, AI_ENABLE_REQUEST.EVENTS.APPROVAL_REQUEST_ARRIVED, {
+          actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+          isApprover: true,
+          isInitiator: false,
+          initiatorId: testInitiatorId,
+          approverId: testSelfParticipantId,
+          url: testUrl,
+        });
+      });
+
       it('should handle events with different action types', () => {
         aiEnableRequest.listenToApprovalRequests();
 

package/test/unit/spec/breakouts/breakout.ts

@@ -26,6 +26,7 @@ describe('plugin-meetings', () => {
       breakout.sessionId = 'sessionId';
       breakout.sessionType = 'BREAKOUT';
       breakout.url = 'url';
+      breakout.resourceLink = 'resource-link';
       breakout.collection = {
         parent: {
           meetingId: 'activeMeetingId',
@@ -45,6 +46,7 @@ describe('plugin-meetings', () => {
     describe('initialize', () => {
       it('creates the object correctly', () => {
         assert.instanceOf(breakout.breakoutRequest, BreakoutRequest);
+        assert.equal(breakout.resourceLink, 'resource-link');
       });
     });
 
@@ -217,10 +219,14 @@ describe('plugin-meetings', () => {
           locusParticipantsUpdate: sinon.stub(),
         };
 
-        const locusData = {some: 'data'};
+        const locusData = {participants: [{id: 'participant-1'}], sequence: {entries: [123]}};
         const result = breakout.parseRoster(locusData);
 
-        assert.calledOnceWithExactly(breakout.members.locusParticipantsUpdate, locusData);
+        assert.calledOnceWithExactly(breakout.members.locusParticipantsUpdate, {
+          participants: [{id: 'participant-1'}],
+          isReplace: true,
+        });
+        assert.equal(breakout.breakoutRosterLocus, locusData);
         assert.equal(result, undefined);
       });
       it('not call locusParticipantsUpdate if sequence is expired', () => {
@@ -228,7 +234,7 @@ describe('plugin-meetings', () => {
           locusParticipantsUpdate: sinon.stub(),
         };
         breakout.isNeedHandleRoster = sinon.stub().returns(false);
-        const locusData = {some: 'data'};
+        const locusData = {participants: [{id: 'participant-1'}], sequence: {entries: [123]}};
         breakout.parseRoster(locusData);
 
         assert.notCalled(breakout.members.locusParticipantsUpdate);

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

@@ -313,6 +313,7 @@ describe('plugin-meetings', () => {
           groupId: 'groupId',
           sessionType: 'sessionType',
           url: 'url',
+          resourceLink: 'resource-link',
           name: 'name',
           allowBackToMain: true,
           delayCloseTime: 10,
@@ -339,6 +340,7 @@ describe('plugin-meetings', () => {
         assert.equal(breakouts.currentBreakoutSession.current, true);
         assert.equal(breakouts.currentBreakoutSession.sessionType, 'sessionType');
         assert.equal(breakouts.currentBreakoutSession.url, 'url');
+        assert.equal(breakouts.currentBreakoutSession.resourceLink, 'resource-link');
         assert.equal(breakouts.currentBreakoutSession.active, false);
         assert.equal(breakouts.currentBreakoutSession.allowed, false);
         assert.equal(breakouts.currentBreakoutSession.assigned, false);
@@ -1847,6 +1849,53 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#removeFromBreakout', () => {
+      it('should make a POST request with correct body and return the result', async () => {
+        breakouts.request = sinon.stub().returns(Promise.resolve('REQUEST_RETURN_VALUE'));
+        breakouts.set('url', 'url');
+        breakouts.set('mainGroupId', 'mainGroupId');
+        breakouts.set('mainSessionId', 'mainSessionId');
+
+        const participants = ['participant1', 'participant2'];
+        const result = await breakouts.removeFromBreakout(participants);
+
+        assert.calledOnceWithExactly(breakouts.request, {
+          method: 'POST',
+          uri: 'url/move',
+          body: {
+            groups: [
+              {
+                id: 'mainGroupId',
+                sessions: [
+                  {
+                    id: 'mainSessionId',
+                    participants,
+                  },
+                ],
+              },
+            ],
+          },
+        });
+        assert.equal(result, 'REQUEST_RETURN_VALUE');
+      });
+
+      it('should throw an error if mainGroupId is missing', () => {
+        breakouts.set('mainSessionId', 'mainSessionId');
+        assert.throws(
+          () => breakouts.removeFromBreakout(['participant1']),
+          'Main group ID and session ID must be available to remove participants from breakout'
+        );
+      });
+
+      it('should throw an error if mainSessionId is missing', () => {
+        breakouts.set('mainGroupId', 'mainGroupId');
+        assert.throws(
+          () => breakouts.removeFromBreakout(['participant1']),
+          'Main group ID and session ID must be available to remove participants from breakout'
+        );
+      });
+    });
+
     describe('#triggerReturnToMainEvent', () => {
       const checkTrigger = ({breakout, shouldTrigger}) => {
         breakouts.trigger = sinon.stub();

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,
                     });
@@ -241,6 +326,7 @@ describe('plugin-meetings', () => {
               beforeEach(() => {
                 request = {
                   request: sinon.stub().returns(Promise.resolve()),
+                  locusDeltaRequest: sinon.stub().returns(Promise.resolve()),
                 };
 
                 manager = new ControlsOptionsManager(request);
@@ -252,6 +338,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 +371,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 +383,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 +395,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 +407,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 +419,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 +431,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);
               });
             });
           });