@webex/plugin-meetings 3.0.0-beta.134 → 3.0.0-beta.136

package/src/breakouts/index.ts

@@ -41,10 +41,10 @@ const Breakouts = WebexPlugin.extend({
     groups: 'array', // appears when create breakouts
     manageGroups: 'array', // appears when manage breakouts
     preAssignments: 'array', // appears when getPreAssignments info hasBreakoutPreAssignments = true
-    shouldFetchPreassignments: 'boolean', // Controlling the lifecycle of the pre-assign API
     editLock: 'object', // appears when getBreakout info editlock = true
     intervalID: 'number',
     meetingId: 'string',
+    canManageBreakouts: 'boolean', // appear the ability to manage breakouts
   },
   children: {
     currentBreakoutSession: Breakout,
@@ -80,7 +80,7 @@ const Breakouts = WebexPlugin.extend({
       cache: false,
       deps: ['manageGroups'],
       /**
-       * Returns the actived group id
+       * Returns the active group id
        * @returns {boolean}
        */
       fn() {
@@ -104,6 +104,21 @@ const Breakouts = WebexPlugin.extend({
         return this.isInMainSession ? this.groups?.[0]?.status : this.status;
       },
     },
+    shouldQueryPreAssignments: {
+      cache: false,
+      deps: ['canManageBreakouts', 'enableBreakoutSession', 'hasBreakoutPreAssignments'],
+      /**
+       * Returns should query preAssignments or not
+       * @returns {boolean}
+       */
+      fn() {
+        return !!(
+          this.canManageBreakouts &&
+          this.enableBreakoutSession &&
+          this.hasBreakoutPreAssignments
+        );
+      },
+    },
   },
 
   /**
@@ -116,6 +131,11 @@ const Breakouts = WebexPlugin.extend({
         this.trigger(BREAKOUTS.EVENTS.BREAKOUTS_CLOSING);
       }
     });
+    this.listenTo(this, 'change:shouldQueryPreAssignments', () => {
+      if (this.shouldQueryPreAssignments && !this.preAssignments) {
+        this.queryPreAssignments();
+      }
+    });
     this.debouncedQueryRosters = debounce(this.queryRosters, 10, {
       leading: true,
       trailing: false,
@@ -156,6 +176,15 @@ const Breakouts = WebexPlugin.extend({
     }
   },
 
+  /**
+   * Update whether self is moderator/cohost or not
+   * @param {boolean} canManageBreakouts
+   * @returns {void}
+   */
+  updateCanManageBreakouts(canManageBreakouts) {
+    this.set('canManageBreakouts', canManageBreakouts);
+  },
+
   /**
    * Update the current breakout resource url
    * @param {string} breakoutServiceUrl
@@ -273,7 +302,6 @@ const Breakouts = WebexPlugin.extend({
    * @returns {void}
    */
   updateBreakout(params) {
-    const preEnableBreakoutSession = this.get('enableBreakoutSession');
     this.set(params);
 
     // These values are set manually so they are unset when they are not included in params
@@ -295,11 +323,6 @@ const Breakouts = WebexPlugin.extend({
       [BREAKOUTS.SESSION_STATES.REQUESTED]: false,
     });
 
-    // We need to call queryPreAssignments when enableBreakoutSession become true
-    if (preEnableBreakoutSession !== params.enableBreakoutSession) {
-      this.queryPreAssignments(params);
-    }
-
     if (
       this.currentBreakoutSession.previous('sessionId') !== this.currentBreakoutSession.sessionId ||
       this.currentBreakoutSession.previous('groupId') !== this.currentBreakoutSession.groupId
@@ -529,7 +552,6 @@ const Breakouts = WebexPlugin.extend({
       });
 
     this._setManageGroups(breakoutInfo);
-    this.shouldFetchPreassignments = false;
 
     return breakoutInfo;
   },
@@ -788,27 +810,21 @@ const Breakouts = WebexPlugin.extend({
   },
 
   /**
-   * The pre-assignments need to be queried when "hasBreakoutPreAssignments" is true
-   * @param {Object} params
+   * query preAssignments
    * @returns {void}
    */
-  queryPreAssignments(params) {
-    if (!params || !params.enableBreakoutSession || !params.hasBreakoutPreAssignments) {
-      return;
-    }
-    if (!this.shouldFetchPreassignments) {
-      this.webex
-        .request({uri: `${this.url}/preassignments`, qs: {locusUrl: btoa(this.locusUrl)}})
-        .then((result) => {
-          if (result.body?.groups) {
-            this.set('preAssignments', result.body.groups);
-          }
-        })
-        .catch((error) => {
-          LoggerProxy.logger.error('Meeting:breakouts#queryPreAssignments failed', error);
-        });
-      this.shouldFetchPreassignments = true;
-    }
+  queryPreAssignments() {
+    this.webex
+      .request({uri: `${this.url}/preassignments`, qs: {locusUrl: btoa(this.locusUrl)}})
+      .then((result) => {
+        if (result.body?.groups) {
+          this.set('preAssignments', result.body.groups);
+          this.trigger(BREAKOUTS.EVENTS.PRE_ASSIGNMENTS_UPDATE);
+        }
+      })
+      .catch((error) => {
+        LoggerProxy.logger.error('Meeting:breakouts#queryPreAssignments failed', error);
+      });
   },
   /**
    * assign participants dynamically after breakout sessions started,

package/src/constants.ts

@@ -318,6 +318,7 @@ export const EVENT_TRIGGERS = {
   MEETING_BREAKOUTS_ASK_RETURN_TO_MAIN: 'meeting:breakouts:askReturnToMain',
   MEETING_BREAKOUTS_LEAVE: 'meeting:breakouts:leave',
   MEETING_BREAKOUTS_ASK_FOR_HELP: 'meeting:breakouts:askForHelp',
+  MEETING_BREAKOUTS_PRE_ASSIGNMENTS_UPDATE: 'meeting:breakouts:preAssignmentsUpdate',
   MEMBERS_UPDATE: 'members:update',
   MEMBERS_CLEAR: 'members:clear',
   MEMBERS_CONTENT_UPDATE: 'members:content:update',
@@ -563,6 +564,7 @@ export const BREAKOUTS = {
     ASK_RETURN_TO_MAIN: 'ASK_RETURN_TO_MAIN',
     LEAVE_BREAKOUT: 'LEAVE_BREAKOUT',
     ASK_FOR_HELP: 'ASK_FOR_HELP',
+    PRE_ASSIGNMENTS_UPDATE: 'PRE_ASSIGNMENTS_UPDATE',
   },
   SESSION_TYPES: {
     MAIN: 'MAIN',
@@ -633,7 +635,6 @@ export const LOCUSINFO = {
     SELF_MEETING_BREAKOUTS_CHANGED: 'SELF_MEETING_BREAKOUTS_CHANGED',
     MEDIA_INACTIVITY: 'MEDIA_INACTIVITY',
     LINKS_SERVICES: 'LINKS_SERVICES',
-    SELF_MODERATOR_OR_COHOST_UPGRADE: 'SELF_MODERATOR_OR_COHOST_UPGRADE',
   },
 };
 

package/src/locus-info/index.ts

@@ -1237,18 +1237,7 @@ export default class LocusInfo extends EventsScope {
           {oldRoles: parsedSelves.previous?.roles, newRoles: parsedSelves.current?.roles}
         );
       }
-      // When the user upgrades to moderator or cohost
-      if (parsedSelves.updates.isUpgradeToModeratorOrCohost) {
-        this.emitScoped(
-          {
-            file: 'locus-info',
-            function: 'updateSelf',
-          },
-          LOCUSINFO.EVENTS.SELF_MODERATOR_OR_COHOST_UPGRADE,
-          self
-        );
-      }
-      //
+
       if (parsedSelves.updates.isVideoMutedByOthersChanged) {
         this.emitScoped(
           {

package/src/locus-info/selfUtils.ts

@@ -14,7 +14,6 @@ import {
   AUDIO,
   VIDEO,
   MediaContent,
-  SELF_ROLES,
 } from '../constants';
 import ParameterError from '../common/errors/parameter';
 
@@ -109,7 +108,6 @@ SelfUtils.getSelves = (oldSelf, newSelf, deviceId) => {
   );
   updates.moderatorChanged = SelfUtils.moderatorChanged(previous, current);
   updates.isRolesChanged = SelfUtils.isRolesChanged(previous, current);
-  updates.isUpgradeToModeratorOrCohost = SelfUtils.isUpgradeToModeratorOrCohost(previous, current);
   updates.isMediaInactiveOrReleased = SelfUtils.wasMediaInactiveOrReleased(previous, current);
   updates.isUserObserving = SelfUtils.isDeviceObserving(previous, current);
   updates.layoutChanged = SelfUtils.layoutChanged(previous, current);
@@ -340,38 +338,20 @@ SelfUtils.moderatorChanged = (oldSelf, changedSelf) => {
   return oldSelf.moderator !== changedSelf.moderator;
 };
 
-SelfUtils.isRolesChanged = (oldSelf, changedSelf) => {
-  if (!oldSelf || !changedSelf) {
-    return false;
-  }
-
-  return !isEqual(oldSelf.roles, changedSelf.roles);
-};
 /**
+ * determine whether the roles of self is changed or not
  * @param {Object} oldSelf
  * @param {Object} changedSelf
  * @returns {Boolean}
- * @throws {Error} if changed self was undefined
  */
-SelfUtils.isUpgradeToModeratorOrCohost = (oldSelf, changedSelf) => {
-  if (!oldSelf) {
-    return false;
-  }
+SelfUtils.isRolesChanged = (oldSelf, changedSelf) => {
   if (!changedSelf) {
-    throw new ParameterError(
-      'New self must be defined to determine if self transitioned moderator or cohost status.'
-    );
+    // no new self means no change
+    return false;
   }
-  const isAttendeeOnly =
-    oldSelf.roles.includes(SELF_ROLES.ATTENDEE) &&
-    !oldSelf.roles.includes(SELF_ROLES.COHOST) &&
-    !oldSelf.roles.includes(SELF_ROLES.MODERATOR);
-  const isCohost = changedSelf.roles.includes(SELF_ROLES.COHOST);
-  const isModerator = changedSelf.roles.includes(SELF_ROLES.MODERATOR);
-
-  return isAttendeeOnly && (isCohost || isModerator);
-};
 
+  return !isEqual(oldSelf?.roles, changedSelf?.roles);
+};
 /**
  * @param {Object} oldSelf
  * @param {Object} changedSelf

package/src/meeting/index.ts

@@ -1523,6 +1523,17 @@ export default class Meeting extends StatelessWebexPlugin {
         helpEvent
       );
     });
+
+    this.breakouts.on(BREAKOUTS.EVENTS.PRE_ASSIGNMENTS_UPDATE, () => {
+      Trigger.trigger(
+        this,
+        {
+          file: 'meeting/index',
+          function: 'setUpBreakoutsListener',
+        },
+        EVENT_TRIGGERS.MEETING_BREAKOUTS_PRE_ASSIGNMENTS_UPDATE
+      );
+    });
   }
 
   /**
@@ -2922,6 +2933,11 @@ export default class Meeting extends StatelessWebexPlugin {
     });
 
     this.locusInfo.on(LOCUSINFO.EVENTS.SELF_ROLES_CHANGED, (payload) => {
+      const isModeratorOrCohost =
+        payload.newRoles?.includes(SELF_ROLES.MODERATOR) ||
+        payload.newRoles?.includes(SELF_ROLES.COHOST);
+      this.breakouts.updateCanManageBreakouts(isModeratorOrCohost);
+
       Trigger.trigger(
         this,
         {
@@ -2935,12 +2951,6 @@ export default class Meeting extends StatelessWebexPlugin {
       );
     });
 
-    // We need to reinitialize  when user upgrades to host or cohost
-    this.locusInfo.on(LOCUSINFO.EVENTS.SELF_MODERATOR_OR_COHOST_UPGRADE, (payload) => {
-      this.breakouts.queryPreAssignments(payload);
-      // ...
-    });
-
     this.locusInfo.on(LOCUSINFO.EVENTS.SELF_IS_SHARING_BLOCKED_CHANGE, (payload) => {
       Trigger.trigger(
         this,

package/src/multistream/remoteMediaGroup.ts

@@ -151,6 +151,13 @@ export class RemoteMediaGroup {
     throw new Error(`remote media object ${remoteMedia.id} not found in the group`);
   }
 
+  public setPreferLiveVideo(preferLiveVideo: boolean, commit: boolean) {
+    if (this.options.preferLiveVideo !== preferLiveVideo) {
+      this.options.preferLiveVideo = preferLiveVideo;
+      this.sendActiveSpeakerMediaRequest(commit);
+    }
+  }
+
   private sendActiveSpeakerMediaRequest(commit: boolean) {
     this.cancelActiveSpeakerMediaRequest(false);
 

package/src/multistream/remoteMediaManager.ts

@@ -491,6 +491,20 @@ export class RemoteMediaManager extends EventsScope {
     return this.currentLayoutId;
   }
 
+  /**
+   * sets the preferLiveVideo
+   */
+  public setPreferLiveVideo(preferLiveVideo: boolean) {
+    LoggerProxy.logger.log(
+      `RemoteMediaManager#setPreferLiveVideo --> setPreferLiveVideo is called to set preferLiveVideo to ${preferLiveVideo}`
+    );
+    this.config.video.preferLiveVideo = preferLiveVideo;
+    Object.values(this.media.video.activeSpeakerGroups).forEach((activeSpeakerGroup) => {
+      activeSpeakerGroup.setPreferLiveVideo(preferLiveVideo, false);
+    });
+    this.mediaRequestManagers.video.commit();
+  }
+
   /**
    * Creates the audio slots
    */

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

@@ -6,9 +6,7 @@ import sinon from 'sinon';
 import MockWebex from '@webex/test-helper-mock-webex';
 import testUtils from '../../../utils/testUtils';
 import BreakoutEditLockedError from '@webex/plugin-meetings/src/breakouts/edit-lock-error';
-import breakoutEvent from "../../../../src/breakouts/events";
-import SelfUtils from "../../../../src/locus-info/selfUtils";
-import { self } from "../locus-info/selfConstant";
+import breakoutEvent from '../../../../src/breakouts/events';
 
 const getBOResponse = (status: string) => {
   return {
@@ -150,6 +148,16 @@ describe('plugin-meetings', () => {
         breakouts.breakouts.get('session1').set({requestedLastModifiedTime: "2023-05-09T17:16:01.000Z"});
         assert.calledOnceWithExactly(breakouts.triggerReturnToMainEvent, breakouts.breakouts.get('session1'));
       });
+
+      it('call queryPreAssignments correctly when should query preAssignments is true', () => {
+        breakouts.queryPreAssignments = sinon.stub();
+        breakouts.set({
+          canManageBreakouts: true,
+          enableBreakoutSession: true,
+          hasBreakoutPreAssignments: true,
+        });
+        assert.calledThrice(breakouts.queryPreAssignments);
+      });
     });
 
     describe('#listenToCurrentSessionTypeChange', () => {
@@ -448,6 +456,18 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#updateCanManageBreakouts', () => {
+      it('update canManageBreakouts', () => {
+        breakouts.updateCanManageBreakouts(true);
+
+        assert.equal(breakouts.canManageBreakouts, true);
+
+        breakouts.updateCanManageBreakouts(false);
+
+        assert.equal(breakouts.canManageBreakouts, false);
+      });
+    });
+
     describe('#cleanUp', () => {
       it('stops listening', () => {
         breakouts.stopListening = sinon.stub();
@@ -504,6 +524,18 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#shouldQueryPreAssignments', () => {
+      it('returns should query preAssignments depends on status', () => {
+        assert.equal(breakouts.shouldQueryPreAssignments, false);
+        breakouts.set('canManageBreakouts', true);
+        assert.equal(breakouts.shouldQueryPreAssignments, false);
+        breakouts.set('enableBreakoutSession', true);
+        assert.equal(breakouts.shouldQueryPreAssignments, false);
+        breakouts.set('hasBreakoutPreAssignments', true);
+        assert.equal(breakouts.shouldQueryPreAssignments, true);
+      });
+    });
+
     describe('#breakoutStatus', () => {
       it('return status from groups with session type', () => {
         breakouts.set('groups', [{status: "OPEN"}]);
@@ -1453,58 +1485,50 @@ describe('plugin-meetings', () => {
       });
     });
 
-    describe('queryPreAssignments', () => {
+    describe('#queryPreAssignments', () => {
       it('makes the expected query', async () => {
-        webex.request.returns(
-          Promise.resolve({
-            body: {
-              groups: [
+        const mockPreAssignments = [
+            {
+              sessions: [
                 {
-                  sessions: [
-                    {
-                      name: 'Breakout session 1',
-                      assignedEmails: ['a@a.com', 'b@b.com', 'jial2@cisco.com'],
-                      anyoneCanJoin: false,
-                    },
-                    {
-                      name: 'Breakout session 2',
-                      anyoneCanJoin: false,
-                    },
-                    {
-                      name: 'Breakout session 3',
-                      assignedEmails: ['c@c.com'],
-                      anyoneCanJoin: false,
-                    },
-                  ],
-                  unassignedInvitees: {
-                    emails: ['d@d.com'],
-                  },
-                  type: 'BREAKOUT',
+                  name: 'Breakout session 1',
+                  assignedEmails: ['aa@aa.com', 'bb@bb.com', 'cc@cc.com'],
+                  anyoneCanJoin: false,
+                },
+                {
+                  name: 'Breakout session 2',
+                  anyoneCanJoin: false,
+                },
+                {
+                  name: 'Breakout session 3',
+                  assignedEmails: ['cc@cc.com'],
+                  anyoneCanJoin: false,
                 },
               ],
+              unassignedInvitees: {
+                emails: ['dd@dd.com'],
+              },
+              type: 'BREAKOUT',
+            },
+          ];
+        webex.request.returns(
+          Promise.resolve({
+            body: {
+              groups: mockPreAssignments,
             },
           })
         );
-        breakouts.shouldFetchPreassignments = false;
-        const result = await breakouts.queryPreAssignments({enableBreakoutSession: true, hasBreakoutPreAssignments: true});
-        const arg = webex.request.getCall(0).args[0];
-        assert.equal(arg.uri, 'url/preassignments');
-        assert.equal(breakouts.preAssignments[0].unassignedInvitees.emails[0], 'd@d.com');
-        assert.equal(breakouts.preAssignments[0].sessions[0].name, 'Breakout session 1');
-        assert.equal(breakouts.preAssignments[0].sessions[0].anyoneCanJoin, false);
-        assert.equal(
-          breakouts.preAssignments[0].sessions[0].assignedEmails.toString(),
-          ['a@a.com', 'b@b.com', 'jial2@cisco.com'].toString()
-        );
-        assert.equal(breakouts.preAssignments[0].sessions[1].name, 'Breakout session 2');
-        assert.equal(breakouts.preAssignments[0].sessions[1].anyoneCanJoin, false);
-        assert.equal(breakouts.preAssignments[0].sessions[1].assignedEmails, undefined);
-        assert.equal(breakouts.preAssignments[0].sessions[2].name, 'Breakout session 3');
-        assert.equal(breakouts.preAssignments[0].sessions[2].anyoneCanJoin, false);
-        assert.equal(breakouts.preAssignments[0].sessions[2].assignedEmails[0], 'c@c.com');
-        assert.equal(breakouts.preAssignments[0].unassignedInvitees.emails[0], 'd@d.com');
-        assert.equal(breakouts.preAssignments[0].type, 'BREAKOUT');
-        assert.equal(breakouts.shouldFetchPreassignments, true);
+        breakouts.set('locusUrl', 'test');
+
+        await breakouts.queryPreAssignments();
+        assert.calledOnceWithExactly(webex.request, {
+          uri: 'url/preassignments',
+          qs: {
+            locusUrl: 'dGVzdA==',
+          }
+        });
+
+        assert.deepEqual(breakouts.preAssignments, mockPreAssignments);
       });
 
       it('rejects when no pre-assignments created for this meeting', async () => {

package/test/unit/spec/locus-info/index.js

@@ -971,27 +971,6 @@ describe('plugin-meetings', () => {
         );
       });
 
-      it('should trigger upgradeToModeratorOrCohost for breakouts', () => {
-
-        locusInfo.self = self;
-        const upgradeToModeratorOrCohost = cloneDeep(self);
-        upgradeToModeratorOrCohost.roles = ['ATTENDEE','COHOST'];
-
-        locusInfo.webex.internal.device.url = self.deviceUrl;
-        locusInfo.emitScoped = sinon.stub();
-        locusInfo.updateSelf(upgradeToModeratorOrCohost, []);
-
-        assert.neverCalledWith(
-          locusInfo.emitScoped,
-          {
-            file: 'locus-info',
-            function: 'updateSelf',
-          },
-          LOCUSINFO.EVENTS.SELF_MODERATOR_OR_COHOST_UPGRADE,
-          self
-        );
-      });
-
       it('should trigger SELF_REMOTE_MUTE_STATUS_UPDATED if muted and disallowUnmute changed', () => {
         locusInfo.self = self;
         const selfWithMutedByOthersAndDissalowUnmute = cloneDeep(self);

package/test/unit/spec/locus-info/selfUtils.js

@@ -316,43 +316,6 @@ describe('plugin-meetings', () => {
     });
   });
 
-  describe('isUpgradeToModeratorOrCohost', () => {
-    it('returns true if changed', () => {
-      assert.equal(
-        SelfUtils.isUpgradeToModeratorOrCohost({roles: ['ATTENDEE']}, {roles: ['ATTENDEE','MODERATOR']}),
-        true
-      );
-    });
-
-    it('returns true if changed', () => {
-      assert.equal(
-        SelfUtils.isUpgradeToModeratorOrCohost({roles: ['ATTENDEE']}, {roles: ['ATTENDEE','COHOST']}),
-        true
-      );
-    });
-
-    it('returns false if changed', () => {
-      assert.equal(
-        SelfUtils.isUpgradeToModeratorOrCohost({roles: ['ATTENDEE','MODERATOR']}, {roles: ['ATTENDEE']}),
-        false
-      );
-    });
-
-    it('returns false if changed', () => {
-      assert.equal(
-        SelfUtils.isUpgradeToModeratorOrCohost({roles: ['ATTENDEE','COHOST']}, {roles: ['ATTENDEE']}),
-        false
-      );
-    });
-
-    it('returns false if changed', () => {
-      assert.equal(
-        SelfUtils.isUpgradeToModeratorOrCohost({roles: ['ATTENDEE','HOST','MODERATOR']}, {roles: ['ATTENDEE']}),
-        false
-      );
-    });
-  });
-
   describe('getReplacedBreakoutMoveId', () => {
     const deviceId = 'https://wdm-a.wbx2.com/wdm/api/v1/devices/20eabde3-4254-48da-9a24';
     const breakoutMoveId = 'e5caeb2c-ffcc-4e06-a08a-1122e7710398';
@@ -395,6 +358,12 @@ describe('plugin-meetings', () => {
   });
 
   describe('isRolesChanged', () => {
+    it('should return false if new self is null', () => {
+      const parsedSelf = SelfUtils.parse(self);
+
+      assert.deepEqual(SelfUtils.isRolesChanged(parsedSelf, null), false);
+    });
+
     it('should return true if self roles has changed', () => {
       const parsedSelf = SelfUtils.parse(self);
       const clonedSelf = cloneDeep(parsedSelf);

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

@@ -4867,6 +4867,7 @@ describe('plugin-meetings', () => {
 
         it('listens to the self roles changed event', () => {
           const payload = {oldRoles: [], newRoles: ['COHOST']};
+          meeting.breakouts.updateCanManageBreakouts = sinon.stub();
 
           meeting.locusInfo.emit(
             {function: 'test', file: 'test'},
@@ -4874,6 +4875,7 @@ describe('plugin-meetings', () => {
             payload
           );
 
+          assert.calledOnceWithExactly(meeting.breakouts.updateCanManageBreakouts, true);
           assert.calledWith(
             TriggerProxy.trigger,
             meeting,
@@ -4884,19 +4886,6 @@ describe('plugin-meetings', () => {
         });
       });
 
-      describe('#setUpBreakoutsPreAssignmentsListener', () => {
-        it('listens to the self moderator or cohost upgrade event', () => {
-          meeting.breakouts.queryPreAssignments = sinon.stub();
-          const payload = 'payload';
-          meeting.locusInfo.emit(
-            {function: 'test', file: 'test'},
-            'SELF_MODERATOR_OR_COHOST_UPGRADE',
-            payload,
-          );
-          assert.calledOnceWithExactly(meeting.breakouts.queryPreAssignments, payload);
-        });
-      });
-
       describe('#setUpBreakoutsListener', () => {
         it('listens to the closing event from breakouts and triggers the closing event', () => {
           TriggerProxy.trigger.reset();
@@ -4972,6 +4961,18 @@ describe('plugin-meetings', () => {
             helpEvent
           );
         });
+
+        it('listens to the preAssignments update event from breakouts and triggers the update event', () => {
+          TriggerProxy.trigger.reset();
+          meeting.breakouts.trigger('PRE_ASSIGNMENTS_UPDATE');
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setUpBreakoutsListener'},
+            EVENT_TRIGGERS.MEETING_BREAKOUTS_PRE_ASSIGNMENTS_UPDATE
+          );
+        });
       });
 
       describe('#setupLocusControlsListener', () => {
@@ -5881,7 +5882,7 @@ describe('plugin-meetings', () => {
         it('connects if not already connected', async () => {
           meeting.joinedWith = {state: 'JOINED'};
           meeting.locusInfo = {url: 'a url', info: {datachannelUrl: 'a datachannel url'}};
-          
+
 
           const result = await meeting.updateLLMConnection();