@webex/plugin-meetings 3.0.0-bnr.5 → 3.0.0-stream-classes.2

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

@@ -6,6 +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';
 
 const getBOResponse = (status: string) => {
   return {
@@ -53,7 +54,12 @@ const getBOResponseWithEditLockInfo = (status: string, withOutToken?: boolean) =
     locusUrl: 'locusUrl',
     mainGroupId: 'mainGroupId',
     mainSessionId: 'mainSessionId',
-    editlock: {state: "LOCKED", ttl: 30, userId: "cc5d452f-04b6-4876-a4c3-28ca21982c6a", token: withOutToken ? '' : 'token1'},
+    editlock: {
+      state: 'LOCKED',
+      ttl: 30,
+      userId: 'cc5d452f-04b6-4876-a4c3-28ca21982c6a',
+      token: withOutToken ? '' : 'token1',
+    },
     groups: [
       {
         sessions: [
@@ -89,6 +95,8 @@ describe('plugin-meetings', () => {
       breakouts.locusUrl = 'locusUrl';
       breakouts.breakoutServiceUrl = 'breakoutServiceUrl';
       webex.request = sinon.stub().returns(Promise.resolve('REQUEST_RETURN_VALUE'));
+      webex.meetings = {};
+      webex.meetings.getMeetingByType = sinon.stub();
     });
 
     describe('#initialize', () => {
@@ -96,19 +104,59 @@ describe('plugin-meetings', () => {
         assert.equal(breakouts.namespace, 'Meetings');
       });
 
-      it('emits BREAKOUTS_CLOSING event when the status is CLOSING', () => {
-        let called = false;
-        breakouts.listenTo(breakouts, BREAKOUTS.EVENTS.BREAKOUTS_CLOSING, () => {
-          called = true;
+      it('emits BREAKOUTS_CLOSING event when the breakoutStatus is CLOSING', () => {
+        const checkIsCalled = (prev, deps) => {
+          breakouts.set(prev);
+          const breakoutClosingHandler = sinon.stub();
+          breakouts.listenTo(breakouts, BREAKOUTS.EVENTS.BREAKOUTS_CLOSING, breakoutClosingHandler);
+          assert.notCalled(breakoutClosingHandler);
+          breakouts.set(deps);
+          assert.calledOnce(breakoutClosingHandler);
+        }
+
+        checkIsCalled({sessionType: BREAKOUTS.SESSION_TYPES.MAIN, groups: undefined, status: undefined}, {
+          sessionType: BREAKOUTS.SESSION_TYPES.MAIN,
+          groups: [{status: BREAKOUTS.STATUS.CLOSING}],
+          status: undefined
+        });
+
+        checkIsCalled({sessionType: BREAKOUTS.SESSION_TYPES.MAIN, groups: [{status: BREAKOUTS.STATUS.OPEN}], status: undefined}, {
+          sessionType: BREAKOUTS.SESSION_TYPES.MAIN,
+          groups: [{status: BREAKOUTS.STATUS.CLOSING}],
+          status: undefined
+        });
+
+        checkIsCalled({sessionType: BREAKOUTS.SESSION_TYPES.BREAKOUT, groups: undefined, status: undefined}, {
+          sessionType: BREAKOUTS.SESSION_TYPES.BREAKOUT,
+          groups: undefined,
+          status: BREAKOUTS.STATUS.CLOSING
         });
 
-        breakouts.set('status', 'something');
+        checkIsCalled({sessionType: BREAKOUTS.SESSION_TYPES.BREAKOUT, groups: undefined, status: BREAKOUTS.STATUS.OPEN}, {
+          sessionType: BREAKOUTS.SESSION_TYPES.BREAKOUT,
+          groups: undefined,
+          status: BREAKOUTS.STATUS.CLOSING
+        });
 
-        assert.isFalse(called);
+      });
 
-        breakouts.set({status: BREAKOUTS.STATUS.CLOSING});
+      it('should not emits BREAKOUTS_CLOSING event when just sessionType changed from BREAKOUT to MAIN', () => {
+        breakouts.set({
+          sessionType: BREAKOUTS.SESSION_TYPES.BREAKOUT,
+          groups: undefined,
+          status: BREAKOUTS.STATUS.CLOSING
+        });
 
-        assert.isTrue(called);
+        const breakoutClosingHandler = sinon.stub();
+        breakouts.listenTo(breakouts, BREAKOUTS.EVENTS.BREAKOUTS_CLOSING, breakoutClosingHandler);
+
+        breakouts.set({
+          sessionType: BREAKOUTS.SESSION_TYPES.MAIN,
+          groups: [{status: BREAKOUTS.STATUS.CLOSING}],
+          status: undefined
+        });
+
+        assert.notCalled(breakoutClosingHandler);
       });
 
       it('debounces querying rosters on add', () => {
@@ -117,6 +165,64 @@ describe('plugin-meetings', () => {
 
         assert.calledOnceWithExactly(breakouts.debouncedQueryRosters);
       });
+
+      it('call triggerReturnToMainEvent correctly when requested breakout add', () => {
+        breakouts.triggerReturnToMainEvent = sinon.stub();
+        breakouts.breakouts.add({sessionId: 'session1', sessionType: 'MAIN'});
+        assert.calledOnceWithExactly(breakouts.triggerReturnToMainEvent, breakouts.breakouts.get('session1'));
+      });
+
+      it('call triggerReturnToMainEvent correctly when breakout requestedLastModifiedTime change', () => {
+        breakouts.breakouts.add({sessionId: 'session1', sessionType: 'MAIN'});
+        breakouts.triggerReturnToMainEvent = sinon.stub();
+        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', () => {
+      it('triggers leave breakout event when sessionType changed from SESSION to MAIN', () => {
+        const handler = sinon.stub();
+        breakouts.currentBreakoutSession.set({sessionType: BREAKOUTS.SESSION_TYPES.BREAKOUT})
+        breakouts.listenTo(breakouts, BREAKOUTS.EVENTS.LEAVE_BREAKOUT, handler);
+        breakouts.currentBreakoutSession.set({sessionType: BREAKOUTS.SESSION_TYPES.MAIN});
+
+        assert.calledOnceWithExactly(handler);
+
+        breakouts.stopListening(breakouts, BREAKOUTS.EVENTS.LEAVE_BREAKOUT, handler);
+      });
+
+      it('should not triggers leave breakout event when sessionType changed from undefined to MAIN', () => {
+        const handler = sinon.stub();
+        breakouts.currentBreakoutSession.set({sessionType: undefined})
+        breakouts.listenTo(breakouts, BREAKOUTS.EVENTS.LEAVE_BREAKOUT, handler);
+        breakouts.currentBreakoutSession.set({sessionType: BREAKOUTS.SESSION_TYPES.MAIN});
+
+        assert.notCalled(handler);
+
+        breakouts.stopListening(breakouts, BREAKOUTS.EVENTS.LEAVE_BREAKOUT, handler);
+      });
+
+      it('should not triggers leave breakout event when sessionType changed from MAIN to SESSION', () => {
+        const handler = sinon.stub();
+        breakouts.currentBreakoutSession.set({sessionType: BREAKOUTS.SESSION_TYPES.MAIN})
+        breakouts.listenTo(breakouts, BREAKOUTS.EVENTS.LEAVE_BREAKOUT, handler);
+        breakouts.currentBreakoutSession.set({sessionType: BREAKOUTS.SESSION_TYPES.BREAKOUT});
+
+        assert.notCalled(handler);
+
+        breakouts.stopListening(breakouts, BREAKOUTS.EVENTS.LEAVE_BREAKOUT, handler);
+      });
     });
 
     describe('#listenToBroadcastMessages', () => {
@@ -176,6 +282,33 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#listenToBreakoutHelp', () => {
+      it('triggers ask for help event when a help received', () => {
+        const call = webex.internal.mercury.on.getCall(1);
+        const callback = call.args[1];
+
+        assert.equal(call.args[0], 'event:breakout.help');
+
+        let data;
+
+        breakouts.listenTo(breakouts, BREAKOUTS.EVENTS.ASK_FOR_HELP, (eventData) => {
+          data = eventData;
+        });
+
+        callback({
+          data: {
+            participant: 'participant',
+            sessionId: 'sessionId'
+          },
+        });
+
+        assert.deepEqual(data, {
+          participant: 'participant',
+          sessionId: 'sessionId',
+        });
+      });
+    });
+
     describe('#updateBreakout', () => {
       it('updates the current breakout session', () => {
         breakouts.updateBreakout({
@@ -215,6 +348,87 @@ describe('plugin-meetings', () => {
         assert.equal(breakouts.currentBreakoutSession.assignedCurrent, false);
         assert.equal(breakouts.currentBreakoutSession.requested, false);
       });
+
+      it('update the startTime correctly when no attribute startTime exists on params', () => {
+        breakouts.updateBreakout({
+          startTime: "startTime"
+        })
+        assert.equal(breakouts.startTime, 'startTime');
+
+        breakouts.updateBreakout({})
+        assert.equal(breakouts.startTime, undefined);
+      });
+
+      it('update the status correctly when no attribute status exists on params', () => {
+        breakouts.updateBreakout({
+          status: 'CLOSING'
+        })
+        assert.equal(breakouts.status, 'CLOSING');
+
+        breakouts.updateBreakout({})
+        assert.equal(breakouts.status, undefined);
+      });
+
+      it('call clearBreakouts if current breakout is not in-progress', () => {
+        breakouts.clearBreakouts = sinon.stub();
+        breakouts.updateBreakout({status: 'CLOSED'})
+        assert.calledOnce(breakouts.clearBreakouts);
+      });
+
+      it('updates the current breakout session, call onBreakoutJoinResponse when session changed', () => {
+        breakouts.webex.meetings = {
+          getMeetingByType: sinon.stub().returns({
+            id: 'meeting-id'
+          })
+        };
+        breakoutEvent.onBreakoutJoinResponse = sinon.stub();
+        breakouts.currentBreakoutSession.sessionId = "sessionId-old";
+        breakouts.updateBreakout({
+          sessionId: 'sessionId-new',
+          groupId: 'groupId',
+          sessionType: 'sessionType',
+          url: 'url',
+          name: 'name',
+          allowBackToMain: true,
+          delayCloseTime: 10,
+          enableBreakoutSession: true,
+          startTime: 'startTime',
+          status: 'active',
+          locusUrl: 'locusUrl',
+          breakoutMoveId: 'breakoutMoveId',
+        });
+
+        assert.calledOnce(breakoutEvent.onBreakoutJoinResponse);
+
+      });
+
+      it('updates the current breakout session, not call onBreakoutJoinResponse when session no changed', () => {
+        breakouts.webex.meetings = {
+          getMeetingByType: sinon.stub().returns({
+            id: 'meeting-id'
+          })
+        };
+        breakoutEvent.onBreakoutJoinResponse = sinon.stub();
+        breakouts.currentBreakoutSession.sessionId = "sessionId";
+        breakouts.currentBreakoutSession.groupId = "groupId";
+        breakouts.updateBreakout({
+          sessionId: 'sessionId',
+          groupId: 'groupId',
+          sessionType: 'sessionType',
+          url: 'url',
+          name: 'name',
+          allowBackToMain: true,
+          delayCloseTime: 10,
+          enableBreakoutSession: true,
+          startTime: 'startTime',
+          status: 'active',
+          locusUrl: 'locusUrl',
+          breakoutMoveId: 'breakoutMoveId',
+        });
+
+        assert.notCalled(breakoutEvent.onBreakoutJoinResponse);
+
+      });
     });
 
     describe('#updateBreakoutSessions', () => {
@@ -235,7 +449,7 @@ describe('plugin-meetings', () => {
 
       it('works', () => {
         breakouts.set('url', 'url');
-
+        breakouts.set('sessionType', BREAKOUTS.SESSION_TYPES.MAIN);
         const payload = {
           breakoutSessions: {
             active: [{sessionId: 'sessionId1'}],
@@ -254,6 +468,26 @@ describe('plugin-meetings', () => {
         checkBreakout(breakouts.breakouts.get('sessionId4'), 'sessionId4', 'assignedCurrent');
         checkBreakout(breakouts.breakouts.get('sessionId5'), 'sessionId5', 'requested');
       });
+
+      it('set requestedLastModifiedTime correctly', () => {
+        const payload = {
+          breakoutSessions: {
+            assigned: [{sessionId: 'sessionId1'}],
+            requested: [{sessionId: 'sessionId2', modifiedAt: "2023-05-09T17:16:01.000Z"}],
+          },
+        };
+
+        breakouts.updateBreakoutSessions(payload);
+        assert.equal(breakouts.breakouts.get('sessionId1').requestedLastModifiedTime, undefined)
+        assert.equal(breakouts.breakouts.get('sessionId2').requestedLastModifiedTime, "2023-05-09T17:16:01.000Z")
+      });
+
+      it('not update breakout sessions when breakouts is closing', () => {
+        breakouts.set('status', 'CLOSING');
+        breakouts.breakouts.set = sinon.stub();
+        breakouts.updateBreakoutSessions({breakoutSessions: {}});
+        assert.notCalled(breakouts.breakouts.set);
+      });
     });
 
     describe('#locusUrlUpdate', () => {
@@ -264,6 +498,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();
@@ -302,6 +548,112 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#breakoutGroupId', () => {
+      it('return empty breakout group id for managing breakouts if no data', () => {
+        assert.equal(breakouts.breakoutGroupId, '');
+        breakouts.set('manageGroups', []);
+        assert.equal(breakouts.breakoutGroupId, '');
+        breakouts.set('manageGroups', [{name: 'test'}]);
+        assert.equal(breakouts.breakoutGroupId, undefined);
+      });
+      it('return the group id if has id in manageGroups', () => {
+        breakouts.set('manageGroups', [{id: 'groupId1'}]);
+        assert.equal(breakouts.breakoutGroupId, 'groupId1');
+      });
+      it('return empty group id if group status is CLOSED', () => {
+        breakouts.set('manageGroups', [{id: 'groupId1', status: 'CLOSED'}]);
+        assert.equal(breakouts.breakoutGroupId, '');
+      });
+    });
+
+    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"}]);
+        breakouts.set('status', "CLOSED");
+        breakouts.set('sessionType', BREAKOUTS.SESSION_TYPES.MAIN);
+
+        assert.equal(breakouts.breakoutStatus, "OPEN")
+
+        breakouts.set('sessionType', BREAKOUTS.SESSION_TYPES.BREAKOUT);
+
+        assert.equal(breakouts.breakoutStatus, "CLOSED")
+      });
+    });
+
+    describe('#_setManageGroups', () => {
+      it('do nothing if breakout info is empty', () => {
+        breakouts._setManageGroups();
+        assert.equal(breakouts.manageGroups, undefined);
+        breakouts._setManageGroups({body: null});
+        assert.equal(breakouts.manageGroups, undefined);
+        breakouts._setManageGroups({body: {groups: null}});
+        assert.equal(breakouts.manageGroups, undefined);
+      });
+      it('set the groups into manageGroups if has groups in side breakout info', () => {
+        breakouts._setManageGroups({body: {groups: [{id: 'groupId1'}]}});
+        assert.deepEqual(breakouts.manageGroups, [{id: 'groupId1'}]);
+      });
+    });
+
+    describe('#isBreakoutInProgress', () => {
+      it('return breakout is in progress depends on the status(groups/breakouts)', () => {
+        breakouts.set('groups', [{status: 'CLOSING'}]);
+
+        assert.equal(breakouts.isBreakoutInProgress(), true)
+
+        breakouts.set('groups', undefined);
+        breakouts.set('status', 'OPEN');
+
+        assert.equal(breakouts.isBreakoutInProgress(), true);
+
+        breakouts.set('groups', [{status: 'CLOSED'}]);
+
+        assert.equal(breakouts.isBreakoutInProgress(), false);
+
+        breakouts.set('groups', undefined);
+        breakouts.set('status', 'CLOSED');
+
+        assert.equal(breakouts.isBreakoutInProgress(), false);
+
+        breakouts.set('status', undefined);
+
+        assert.equal(breakouts.isBreakoutInProgress(), false);
+      });
+    });
+
+    describe('#isBreakoutIClosing', () => {
+      it('return breakout is closing depends the status(groups/breakouts)', () => {
+        breakouts.set('groups', [{status: 'CLOSING'}]);
+
+        assert.equal(breakouts.isBreakoutIClosing(), true);
+
+        breakouts.set('groups', undefined);
+        breakouts.set('status', 'CLOSING');
+
+        assert.equal(breakouts.isBreakoutIClosing(), true);
+
+        breakouts.set('status', undefined);
+
+        assert.equal(breakouts.isBreakoutIClosing(), false);
+
+        breakouts.set('groups', [{status: 'OPEN'}]);
+
+        assert.equal(breakouts.isBreakoutIClosing(), false);
+      });
+    });
+
     describe('#queryRosters', () => {
       it('makes the expected query', async () => {
         webex.request.returns(
@@ -369,6 +721,22 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#clearBreakouts', () => {
+      it('call reset to clear breakouts', () => {
+        breakouts.set('breakouts', [{id: 'session1'}]);
+        breakouts.breakouts.reset = sinon.stub();
+        breakouts.clearBreakouts();
+        assert.calledWith(breakouts.breakouts.reset);
+      });
+
+      it('do nothing if breakouts already is empty', () => {
+        breakouts.set('breakouts', []);
+        breakouts.breakouts.reset = sinon.stub();
+        breakouts.clearBreakouts();
+        assert.notCalled(breakouts.breakouts.reset);
+      });
+    });
+
     describe('#getMainSession', () => {
       it('returns main session as expect', () => {
         breakouts.updateBreakout({
@@ -389,9 +757,9 @@ describe('plugin-meetings', () => {
             active: [{sessionId: 'sessionId1'}],
           },
         };
-        breakouts.updateBreakoutSessions(payload);
 
         breakouts.set('sessionType', BREAKOUTS.SESSION_TYPES.MAIN);
+        breakouts.updateBreakoutSessions(payload);
         let result = breakouts.getMainSession();
         assert.equal(result.sessionId, 'sessionId');
 
@@ -438,18 +806,19 @@ describe('plugin-meetings', () => {
     });
 
     describe('#toggleBreakout', () => {
+      const mockEnableResponse = {
+        body: {
+          sessionId: 'sessionId',
+          groupId: 'groupId',
+          name: 'name',
+          current: true,
+          sessionType: 'sessionType',
+          url: 'url',
+        },
+      };
       it('enableBreakoutSession is undefined, run enableBreakouts then toggleBreakout', async () => {
         breakouts.enableBreakoutSession = undefined;
-        breakouts.enableBreakouts = sinon.stub().resolves({
-          body: {
-            sessionId: 'sessionId',
-            groupId: 'groupId',
-            name: 'name',
-            current: true,
-            sessionType: 'sessionType',
-            url: 'url',
-          },
-        });
+        breakouts.enableBreakouts = sinon.stub().resolves(mockEnableResponse);
         breakouts.updateBreakout = sinon.stub().resolves();
         breakouts.doToggleBreakout = sinon.stub().resolves();
 
@@ -466,6 +835,25 @@ describe('plugin-meetings', () => {
         assert.calledOnceWithExactly(breakouts.doToggleBreakout, false);
       });
 
+      it('first time enable breakouts, call updateBreakout to set initial params', async () => {
+        breakouts.enableBreakoutSession = undefined;
+        breakouts.enableBreakouts = sinon.stub().resolves(mockEnableResponse);
+        breakouts.updateBreakout = sinon.stub().resolves();
+        breakouts.doToggleBreakout = sinon.stub();
+
+        await breakouts.toggleBreakout(true);
+        assert.calledOnceWithExactly(breakouts.updateBreakout, {
+          sessionId: 'sessionId',
+          groupId: 'groupId',
+          name: 'name',
+          current: true,
+          sessionType: 'sessionType',
+          url: 'url',
+        });
+
+        assert.notCalled(breakouts.doToggleBreakout);
+      });
+
       it('enableBreakoutSession is exist, run toggleBreakout', async () => {
         breakouts.enableBreakoutSession = true;
         breakouts.doToggleBreakout = sinon.stub().resolves();
@@ -532,6 +920,12 @@ describe('plugin-meetings', () => {
 
     describe('#update', () => {
       it('makes the request as expected', async () => {
+        const mockedReturnBody = getBOResponse('OPEN');
+        webex.request.returns(
+          Promise.resolve({
+            body: mockedReturnBody,
+          })
+        );
         breakouts.editLock = {
           token: 'token1',
         };
@@ -539,6 +933,7 @@ describe('plugin-meetings', () => {
           id: 'groupId',
           sessions: [{name: 'Session 1'}],
         };
+        breakouts._setManageGroups = sinon.stub();
         const result = await breakouts.update(params);
         assert.calledOnceWithExactly(webex.request, {
           method: 'PUT',
@@ -548,6 +943,29 @@ describe('plugin-meetings', () => {
             groups: [params],
           },
         });
+        assert.calledOnceWithExactly(breakouts._setManageGroups, {
+          body: mockedReturnBody,
+        });
+      });
+      it('makes the request as expected when unlockEdit is true', async () => {
+        breakouts.editLock = {
+          token: 'token1',
+        };
+        const params = {
+          id: 'groupId',
+          sessions: [{name: 'Session 1'}],
+        };
+        breakouts._clearEditLockInfo = sinon.stub();
+        const result = await breakouts.update(params, true);
+        assert.calledOnceWithExactly(webex.request, {
+          method: 'PUT',
+          uri: 'url',
+          body: {
+            editlock: {token: 'token1', refresh: false},
+            groups: [params],
+          },
+        });
+        assert.calledOnceWithExactly(breakouts._clearEditLockInfo);
       });
       it('throw error if missing id in params', async () => {
         const params = {
@@ -580,7 +998,7 @@ describe('plugin-meetings', () => {
         );
         assert.calledOnceWithExactly(
           LoggerProxy.logger.info,
-          'Breakouts#update --> Edit lock token mismatch',
+          'Breakouts#update --> Edit lock token mismatch'
         );
       });
 
@@ -607,15 +1025,13 @@ describe('plugin-meetings', () => {
 
         assert.calledOnceWithExactly(
           LoggerProxy.logger.info,
-          'Breakouts#update --> Not authorized to interact with edit lock',
+          'Breakouts#update --> Not authorized to interact with edit lock'
         );
       });
 
       it('rejects when other unknow error', async () => {
         const mockError = new Error('something wrong');
-        webex.request.returns(
-          Promise.reject(mockError)
-        );
+        webex.request.returns(Promise.reject(mockError));
         LoggerProxy.logger.info = sinon.stub();
 
         const params = {
@@ -623,24 +1039,21 @@ describe('plugin-meetings', () => {
           sessions: [{name: 'Session 1'}],
         };
 
-        await assert.isRejected(
-          breakouts.update(params),
-          mockError,
-          'something wrong'
-        );
+        await assert.isRejected(breakouts.update(params), mockError, 'something wrong');
 
         assert.calledOnceWithExactly(
           LoggerProxy.logger.info,
-          'Breakouts#update --> something wrong',
+          'Breakouts#update --> something wrong'
         );
       });
     });
 
     describe('#start', () => {
       it('should start breakout sessions', async () => {
+        const mockedReturnBody = getBOResponse('OPEN');
         webex.request.returns(
           Promise.resolve({
-            body: getBOResponse('OPEN'),
+            body: mockedReturnBody,
           })
         );
 
@@ -648,6 +1061,7 @@ describe('plugin-meetings', () => {
         await breakouts.getBreakout();
 
         const result = await breakouts.start();
+        breakouts._setManageGroups = sinon.stub();
         await breakouts.start({id: 'id', someOtherParam: 'someOtherParam'});
 
         const arg = webex.request.getCall(1).args[0];
@@ -661,7 +1075,6 @@ describe('plugin-meetings', () => {
           action: 'START',
           allowBackToMain: false,
           allowToJoinLater: false,
-          duration: BREAKOUTS.DEFAULT_DURATION,
         });
         assert.deepEqual(argObj2, {
           id: 'id',
@@ -669,9 +1082,9 @@ describe('plugin-meetings', () => {
           allowBackToMain: false,
           allowToJoinLater: false,
           someOtherParam: 'someOtherParam',
-          duration: BREAKOUTS.DEFAULT_DURATION,
         });
-        assert.deepEqual(result, {body: getBOResponse('OPEN')});
+        assert.deepEqual(result, {body: mockedReturnBody});
+        assert.calledWithExactly(breakouts._setManageGroups, {body: mockedReturnBody})
       });
 
       it('rejects when edit lock token mismatch', async () => {
@@ -705,6 +1118,8 @@ describe('plugin-meetings', () => {
         await breakouts.getBreakout();
 
         const result = await breakouts.end();
+
+        breakouts._setManageGroups = sinon.stub();
         await breakouts.end({id: 'id', someOtherParam: 'someOtherParam'});
         const arg = webex.request.getCall(1).args[0];
         const argObj1 = arg.body.groups[0];
@@ -720,6 +1135,7 @@ describe('plugin-meetings', () => {
           someOtherParam: 'someOtherParam',
         });
         assert.deepEqual(result, {body: getBOResponse('CLOSING')});
+        assert.calledOnceWithExactly(breakouts._setManageGroups, {body: getBOResponse('CLOSING')});
       });
 
       it('rejects when edit lock token mismatch', async () => {
@@ -750,6 +1166,8 @@ describe('plugin-meetings', () => {
 
         breakouts.set('url', 'url');
         const result = await breakouts.getBreakout();
+
+        breakouts._setManageGroups = sinon.stub();
         await breakouts.getBreakout(true);
         const arg1 = webex.request.getCall(0).args[0];
         const arg2 = webex.request.getCall(1).args[0];
@@ -758,8 +1176,22 @@ describe('plugin-meetings', () => {
         assert.equal(arg2.uri, 'url?editlock=true');
         assert.equal(arg1.method, 'GET');
         assert.deepEqual(result, {body: getBOResponse('PENDING')});
-        assert.deepEqual(breakouts.groups, result.body.groups);
+        assert.deepEqual(breakouts.manageGroups, result.body.groups);
         assert.equal(breakouts.breakoutGroupId, 'groupId');
+        assert.calledOnceWithExactly(breakouts._setManageGroups, {body: getBOResponse('PENDING')});
+      });
+
+      it('breakoutGroupId should be empty if it is CLOSED group', async () => {
+        webex.request.returns(
+          Promise.resolve({
+            body: getBOResponse('CLOSED'),
+          })
+        );
+
+        breakouts.set('url', 'url');
+        await breakouts.getBreakout();
+
+        assert.equal(breakouts.breakoutGroupId, '');
       });
 
       it('should call keep alive when response with edit lock info', async () => {
@@ -831,6 +1263,7 @@ describe('plugin-meetings', () => {
           })
         );
 
+        breakouts._setManageGroups = sinon.stub();
         const result = await breakouts.clearSessions();
         assert.calledOnceWithExactly(webex.request, {
           method: 'PUT',
@@ -844,7 +1277,17 @@ describe('plugin-meetings', () => {
           },
         });
 
-        assert.equal(breakouts.groups[0].status, 'CLOSE');
+        assert.calledOnceWithExactly(breakouts._setManageGroups, {
+          body: {
+            groups: [
+              {
+                id: '455556a4-37cd-4baa-89bc-8730581a1cc0',
+                status: 'CLOSE',
+                type: 'BREAKOUT',
+              },
+            ],
+          },
+        });
       });
 
       it('rejects when edit lock token mismatch', async () => {
@@ -868,7 +1311,7 @@ describe('plugin-meetings', () => {
     describe('create', () => {
       it('response not include groups info', async () => {
         const sessions = [{name: 'session1', anyoneCanJoin: true}];
-        const result = await breakouts.create(sessions);
+        const result = await breakouts.create({sessions});
 
         assert.equal(result, 'REQUEST_RETURN_VALUE');
       });
@@ -890,9 +1333,9 @@ describe('plugin-meetings', () => {
           })
         );
 
-        const result = await breakouts.create(sessions);
+        const result = await breakouts.create({sessions});
 
-        assert.equal(breakouts.groups[0].id, '455556a4-37cd-4baa-89bc-8730581a1cc0');
+        assert.equal(breakouts.manageGroups[0].id, '455556a4-37cd-4baa-89bc-8730581a1cc0');
       });
 
       it('rejects when edit lock token mismatch', async () => {
@@ -908,7 +1351,7 @@ describe('plugin-meetings', () => {
         );
 
         await assert.isRejected(
-          breakouts.create(sessions),
+          breakouts.create({sessions}),
           BreakoutEditLockedError,
           'Edit lock token mismatch'
         );
@@ -937,6 +1380,38 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('hasBreakoutLocked', () => {
+      it('has breakout locked is true', async () => {
+        breakouts.editLock = {
+          ttl: 30,
+          token: 'token',
+          state: 'LOCKED',
+        };
+
+        assert.equal(breakouts.hasBreakoutLocked(), true);
+      });
+
+      it('breakout locked by others', async () => {
+        breakouts.editLock = {
+          ttl: 30,
+          token: '',
+          state: 'LOCKED',
+        };
+
+        assert.equal(breakouts.hasBreakoutLocked(), false);
+      });
+
+      it('breakout not locked', async () => {
+        breakouts.editLock = {
+          ttl: 30,
+          token: '',
+          state: 'UNLOCKED',
+        };
+
+        assert.equal(breakouts.hasBreakoutLocked(), false);
+      });
+    });
+
     describe('lockBreakout', () => {
       it('lock breakout is true', async () => {
         breakouts.editLock = {
@@ -987,7 +1462,6 @@ describe('plugin-meetings', () => {
       });
 
       it('do not call unLock if edit lock info not exist ', async () => {
-
         breakouts.unLockEditBreakout();
         assert.notCalled(webex.request);
       });
@@ -1138,65 +1612,80 @@ describe('plugin-meetings', () => {
         assert.calledOnceWithExactly(breakouts.assign, params);
         assert.equal(result, 'ASSIGN_RETURN_VALUE');
       });
+
+      it('called with editlock', async () => {
+        breakouts.request = sinon.stub().returns(Promise.resolve('ASSIGN_RETURN_VALUE'));
+        breakouts.editLock = {
+          token: 'token1',
+        };
+        const params = [{id: 'sessionId', emails: ['111@cisco.com'], memberIds: []}];
+        await breakouts.assign(params);
+        const args = breakouts.request.getCall(0).args[0];
+        expect(args).to.be.an('object', {
+          method: 'PUT',
+          uri: 'url',
+          body: {
+            editlock: {token: 'token1', refresh: true},
+            groups: {
+              id: 'sessionId',
+              sessions: [
+                {
+                  id: 'sessionId',
+                  assigned: [],
+                  assignedEmails: ['111@cisco.com'],
+                  anyoneCanJoin: false,
+                },
+              ],
+            },
+          },
+        });
+      });
     });
 
-    describe('queryPreAssignments', () => {
+    describe('#queryPreAssignments', () => {
       it('makes the expected query', async () => {
+        const mockPreAssignments = [
+            {
+              sessions: [
+                {
+                  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": [
-                {
-                  "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"
-                }
-              ]
-            }
+              groups: mockPreAssignments,
+            },
           })
         );
-        breakouts.shouldFetchPreassignments = false;
-        const result = await breakouts.queryPreAssignments();
-        const arg = webex.request.getCall(0).args[0];
-        assert.equal(arg.uri, 'url/preassignments');
-        assert.equal(breakouts.groups[0].unassignedInvitees.emails[0],'d@d.com');
-        assert.equal(breakouts.groups[0].sessions[0].name,'Breakout session 1');
-        assert.equal(breakouts.groups[0].sessions[0].anyoneCanJoin,false);
-        assert.equal(breakouts.groups[0].sessions[0].assignedEmails.toString(), ["a@a.com", "b@b.com", "jial2@cisco.com"].toString());
-        assert.equal(breakouts.groups[0].sessions[1].name,'Breakout session 2');
-        assert.equal(breakouts.groups[0].sessions[1].anyoneCanJoin,false);
-        assert.equal(breakouts.groups[0].sessions[1].assignedEmails, undefined);
-        assert.equal(breakouts.groups[0].sessions[2].name,'Breakout session 3');
-        assert.equal(breakouts.groups[0].sessions[2].anyoneCanJoin,false);
-        assert.equal(breakouts.groups[0].sessions[2].assignedEmails[0], 'c@c.com');
-        assert.equal(breakouts.groups[0].unassignedInvitees.emails[0],'d@d.com');
-        assert.equal(breakouts.groups[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 () => {
@@ -1204,20 +1693,35 @@ describe('plugin-meetings', () => {
           statusCode: 404,
           body: {
             errorCode: 201404004,
-            message: 'No pre-assignments created for this meeting'
+            message: 'No pre-assignments created for this meeting',
           },
         };
         webex.request.rejects(response);
         LoggerProxy.logger.error = sinon.stub();
-        const result = await breakouts.queryPreAssignments();
+        const result = await breakouts.queryPreAssignments({enableBreakoutSession: true, hasBreakoutPreAssignments: true});
         await testUtils.flushPromises();
         assert.calledOnceWithExactly(
           LoggerProxy.logger.error,
           'Meeting:breakouts#queryPreAssignments failed',
           response
         );
-     });
-  });
+      });
+
+      it('fail when no correct params',  () => {
+
+        assert.deepEqual(breakouts.queryPreAssignments(undefined), undefined);
+
+        assert.deepEqual(breakouts.queryPreAssignments({}), undefined);
+
+        assert.deepEqual(breakouts.queryPreAssignments({ enableBreakoutSession: true, hasBreakoutPreAssignments: false }), undefined);
+
+        assert.deepEqual(breakouts.queryPreAssignments({ enableBreakoutSession: false, hasBreakoutPreAssignments: true }), undefined);
+
+        assert.deepEqual(breakouts.queryPreAssignments({ enableBreakoutSession: false, hasBreakoutPreAssignments: false }), undefined);
+
+      });
+
+    });
 
     describe('#dynamicAssign', () => {
       it('should make a PUT request with correct body and return the result', async () => {
@@ -1248,5 +1752,39 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#triggerReturnToMainEvent', () => {
+      const checkTrigger = ({breakout, shouldTrigger}) => {
+        breakouts.trigger = sinon.stub();
+        breakouts.triggerReturnToMainEvent(breakout);
+        if (shouldTrigger) {
+          assert.calledOnceWithExactly(breakouts.trigger, BREAKOUTS.EVENTS.ASK_RETURN_TO_MAIN);
+        } else {
+          assert.notCalled(breakouts.trigger);
+        }
+      }
+      it('should trigger ASK_RETURN_TO_MAIN event correctly', () => {
+        const breakout = {
+          isMain: true,
+          requested: true
+        };
+        checkTrigger({breakout, shouldTrigger: true})
+      });
+
+      it('should not trigger ASK_RETURN_TO_MAIN event when sessionType is not MAIN', () => {
+        const breakout = {
+          isMain: false,
+          requested: true
+        };
+        checkTrigger({breakout, shouldTrigger: false});
+      });
+
+      it('should not trigger ASK_RETURN_TO_MAIN event when session is not requested', () => {
+        const breakout = {
+          isMain: true,
+          requested: false
+        };
+        checkTrigger({breakout, shouldTrigger: false})
+      });
+    });
   });
 });