@webex/plugin-meetings 3.0.0-beta.16 → 3.0.0-beta.161

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

@@ -18,7 +18,8 @@ import {
   DISPLAY_HINTS,
 } from '../../../../src/constants';
 
-import {self, selfWithInactivity} from './selfConstant';
+import { self, selfWithInactivity } from "./selfConstant";
+import uuid from "uuid";
 
 describe('plugin-meetings', () => {
   describe('LocusInfo index', () => {
@@ -66,8 +67,12 @@ describe('plugin-meetings', () => {
 
       beforeEach('setup new controls', () => {
         newControls = {
+          disallowUnmute: {enabled: true},
           lock: {},
           meetingFull: {},
+          muteOnEntry: {enabled: true},
+          raiseHand: {enabled: true},
+          reactions: {enabled: true, showDisplayNameWithReactions: true},
           record: {
             recording: false,
             paused: false,
@@ -76,12 +81,14 @@ describe('plugin-meetings', () => {
               modifiedBy: 'George Kittle',
             },
           },
-          shareControl: {},
+          shareControl: {control: 'example-value'},
           transcribe: {},
+          viewTheParticipantList: {enabled: true},
           meetingContainer: {
             meetingContainerUrl: 'http://new-url.com',
           },
           entryExitTone: {enabled: true, mode: 'foo'},
+          video: {enabled: true},
         };
       });
 
@@ -95,6 +102,97 @@ describe('plugin-meetings', () => {
         assert.equal(locusInfo.controls, newControls);
       });
 
+      it('should trigger the CONTROLS_MUTE_ON_ENTRY_CHANGED event when necessary', () => {
+        locusInfo.controls = {};
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateControls(newControls);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {file: 'locus-info', function: 'updateControls'},
+          LOCUSINFO.EVENTS.CONTROLS_MUTE_ON_ENTRY_CHANGED,
+          {state: newControls.muteOnEntry},
+        );
+      });
+
+      it('should trigger the CONTROLS_SHARE_CONTROL_CHANGED event when necessary', () => {
+        locusInfo.controls = {};
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateControls(newControls);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {file: 'locus-info', function: 'updateControls'},
+          LOCUSINFO.EVENTS.CONTROLS_SHARE_CONTROL_CHANGED,
+          {state: newControls.shareControl},
+        );
+      });
+
+      it('should trigger the CONTROLS_DISALLOW_UNMUTE_CHANGED event when necessary', () => {
+        locusInfo.controls = {};
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateControls(newControls);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {file: 'locus-info', function: 'updateControls'},
+          LOCUSINFO.EVENTS.CONTROLS_DISALLOW_UNMUTE_CHANGED,
+          {state: newControls.disallowUnmute},
+        );
+      });
+
+      it('should trigger the CONTROLS_REACTIONS_CHANGED event when necessary', () => {
+        locusInfo.controls = {};
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateControls(newControls);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {file: 'locus-info', function: 'updateControls'},
+          LOCUSINFO.EVENTS.CONTROLS_REACTIONS_CHANGED,
+          {state: newControls.reactions},
+        );
+      });
+
+      it('should trigger the CONTROLS_VIEW_THE_PARTICIPANTS_LIST_CHANGED event when necessary', () => {
+        locusInfo.controls = {};
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateControls(newControls);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {file: 'locus-info', function: 'updateControls'},
+          LOCUSINFO.EVENTS.CONTROLS_VIEW_THE_PARTICIPANTS_LIST_CHANGED,
+          {state: newControls.viewTheParticipantList},
+        );
+      });
+
+      it('should trigger the CONTROLS_RAISE_HAND_CHANGED event when necessary', () => {
+        locusInfo.controls = {};
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateControls(newControls);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {file: 'locus-info', function: 'updateControls'},
+          LOCUSINFO.EVENTS.CONTROLS_RAISE_HAND_CHANGED,
+          {state: newControls.raiseHand},
+        );
+      });
+
+      it('should trigger the CONTROLS_VIDEO_CHANGED event when necessary', () => {
+        locusInfo.controls = {};
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateControls(newControls);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {file: 'locus-info', function: 'updateControls'},
+          LOCUSINFO.EVENTS.CONTROLS_VIDEO_CHANGED,
+          {state: newControls.video},
+        );
+      });
+
       it('should not trigger the CONTROLS_RECORDING_UPDATED event', () => {
         locusInfo.controls = {};
         locusInfo.emitScoped = sinon.stub();
@@ -277,6 +375,48 @@ describe('plugin-meetings', () => {
         );
       });
 
+      it('should update the breakout state', () => {
+        locusInfo.emitScoped = sinon.stub();
+        let tmpStub = sinon.stub(SelfUtils, 'getReplacedBreakoutMoveId').returns('breakoutMoveId');
+        newControls.breakout = { 'breakout': {} };
+        let selfInfo = {};
+
+        locusInfo.updateControls(newControls, selfInfo);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateControls',
+          },
+          LOCUSINFO.EVENTS.CONTROLS_MEETING_BREAKOUT_UPDATED,
+          {
+            breakout: newControls.breakout,
+          }
+        );
+        tmpStub.restore();
+      });
+
+      it('should update the interpretation state', () => {
+        locusInfo.emitScoped = sinon.stub();
+        newControls.interpretation = {siLanguages: [{languageCode: 20, languageName: 'en'}]};
+        let selfInfo = {};
+
+        locusInfo.updateControls(newControls, selfInfo);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateControls',
+          },
+          LOCUSINFO.EVENTS.CONTROLS_MEETING_INTERPRETATION_UPDATED,
+          {
+            interpretation: newControls.interpretation,
+          }
+        );
+      });
+
       it('should update the transcript state', () => {
         locusInfo.emitScoped = sinon.stub();
         locusInfo.controls = {
@@ -398,6 +538,39 @@ describe('plugin-meetings', () => {
           assert.notEqual(x.args[1], LOCUSINFO.EVENTS.CONTROLS_ENTRY_EXIT_TONE_UPDATED);
         });
       });
+
+      it('should update videoEnabled when changed', () => {
+        locusInfo.controls = {};
+
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateControls(newControls);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateControls',
+          },
+          LOCUSINFO.EVENTS.SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED,
+          {unmuteAllowed: true}
+        );
+
+        assert.equal(mockMeeting.unmuteVideoAllowed, true);
+      });
+
+      it('should not update videoEnabled when unchanged', () => {
+        locusInfo.controls = {videoEnabled: true};
+
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateControls(newControls);
+
+        locusInfo.emitScoped.getCalls().forEach((x) => {
+          // check that no calls in emitScoped are for SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED
+          assert.notEqual(x.args[1], LOCUSINFO.EVENTS.SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED);
+        });
+
+        assert.equal(mockMeeting.unmuteVideoAllowed, undefined);
+      });
     });
 
     describe('#updateParticipants()', () => {
@@ -451,6 +624,7 @@ describe('plugin-meetings', () => {
             selfIdentity: '123',
             selfId: '2',
             hostId: '3',
+            isReplace: undefined,
           }
         );
         // note: in a real use case, recordingId, selfId, and hostId would all be the same
@@ -458,6 +632,43 @@ describe('plugin-meetings', () => {
         // are being correctly grabbed from locusInfo.parsedLocus within updateParticipants
       });
 
+      it('should call with breakout control info', () => {
+        locusInfo.parsedLocus = {
+          controls: {
+            record: {
+              modifiedBy: '1',
+            },
+          },
+          self: {
+            selfIdentity: '123',
+            selfId: '2',
+          },
+          host: {
+            hostId: '3',
+          },
+        };
+
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateParticipants({}, true);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateParticipants',
+          },
+          EVENTS.LOCUS_INFO_UPDATE_PARTICIPANTS,
+          {
+            participants: {},
+            recordingId: '1',
+            selfIdentity: '123',
+            selfId: '2',
+            hostId: '3',
+            isReplace: true,
+          }
+        );
+      });
+
       it('should update the deltaParticipants object', () => {
         const prev = locusInfo.deltaParticipants;
 
@@ -664,6 +875,122 @@ describe('plugin-meetings', () => {
         );
       });
 
+      describe('SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED', () => {
+        it('should emit event when video muted on entry', () => {
+          // usually "previous self" is just undefined when we get first self from locus
+          locusInfo.self = undefined;
+          const selfWithMutedByOthers = cloneDeep(self);
+
+          // remoteVideoMuted
+          selfWithMutedByOthers.controls.video.muted = true;
+
+          locusInfo.webex.internal.device.url = self.deviceUrl;
+          locusInfo.emitScoped = sinon.stub();
+          locusInfo.updateSelf(selfWithMutedByOthers, []);
+
+          assert.calledWith(
+            locusInfo.emitScoped,
+            {
+              file: 'locus-info',
+              function: 'updateSelf',
+            },
+            LOCUSINFO.EVENTS.SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED,
+            {muted: true}
+          );
+
+          // but sometimes "previous self" is defined, but without controls.audio.muted, so we test this here:
+          locusInfo.self = cloneDeep(self);
+          locusInfo.self.controls.video = {};
+
+          locusInfo.updateSelf(selfWithMutedByOthers, []);
+          assert.calledWith(
+            locusInfo.emitScoped,
+            {
+              file: 'locus-info',
+              function: 'updateSelf',
+            },
+            LOCUSINFO.EVENTS.SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED,
+            {muted: true}
+          );
+        });
+
+        it('should not emit event when not muted on entry', () => {
+          locusInfo.self = undefined;
+          const selfWithMutedByOthersFalse = cloneDeep(self);
+
+          selfWithMutedByOthersFalse.controls.video.muted = false;
+
+          locusInfo.webex.internal.device.url = self.deviceUrl;
+          locusInfo.emitScoped = sinon.stub();
+          locusInfo.updateSelf(selfWithMutedByOthersFalse, []);
+
+          // we might get some calls to emitScoped, but we need to check that none of them are for SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED
+          locusInfo.emitScoped.getCalls().forEach((x) => {
+            assert.notEqual(x.args[1], LOCUSINFO.EVENTS.SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED);
+          });
+        });
+
+        it('should emit event when remoteVideoMuted changed', () => {
+          locusInfo.self = self;
+          const selfWithMutedByOthers = cloneDeep(self);
+
+          selfWithMutedByOthers.controls.video.muted = true;
+
+          locusInfo.webex.internal.device.url = self.deviceUrl;
+          locusInfo.emitScoped = sinon.stub();
+          locusInfo.updateSelf(selfWithMutedByOthers, []);
+
+          assert.calledWith(
+            locusInfo.emitScoped,
+            {
+              file: 'locus-info',
+              function: 'updateSelf',
+            },
+            LOCUSINFO.EVENTS.SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED,
+            {muted: true}
+          );
+        });
+      });
+
+      it('should trigger SELF_MEETING_BREAKOUTS_CHANGED when breakouts changed', () => {
+        locusInfo.self = self;
+        const selfWithBreakoutsChanged = cloneDeep(self);
+
+        selfWithBreakoutsChanged.controls.breakout.sessions.active[0].name = 'new name';
+
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateSelf(selfWithBreakoutsChanged, []);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateSelf',
+          },
+          LOCUSINFO.EVENTS.SELF_MEETING_BREAKOUTS_CHANGED,
+          {
+            breakoutSessions: {
+              active: [
+                {
+                  name: 'new name',
+                  groupId: '0e73abb8-5584-49d8-be8d-806d2a8247ca',
+                  sessionId: '1cf41ab1-2e57-4d95-b7e9-5613acddfb0f',
+                  sessionType: 'BREAKOUT',
+                },
+              ],
+              allowed: [
+                {
+                  name: 'Breakout session 2',
+                  groupId: '0e73abb8-5584-49d8-be8d-806d2a8247ca',
+                  sessionId: '1cf41ab1-2e57-4d95-b7e9-5613acddfb0f',
+                  sessionType: 'BREAKOUT',
+                },
+              ],
+            },
+          }
+        );
+      });
+
       it('should trigger SELF_REMOTE_MUTE_STATUS_UPDATED if muted and disallowUnmute changed', () => {
         locusInfo.self = self;
         const selfWithMutedByOthersAndDissalowUnmute = cloneDeep(self);
@@ -735,6 +1062,7 @@ describe('plugin-meetings', () => {
         const selfWithRequestedToUnmute = cloneDeep(self);
 
         selfWithRequestedToUnmute.controls.audio.requestedToUnmute = true;
+        selfWithRequestedToUnmute.controls.audio.lastModifiedRequestedToUnmute = '2023-06-16T19:25:04.369Z';
 
         locusInfo.webex.internal.device.url = self.deviceUrl;
         locusInfo.emitScoped = sinon.stub();
@@ -889,6 +1217,88 @@ describe('plugin-meetings', () => {
           {isSharingBlocked: true}
         );
       });
+
+      it('should trigger SELF_ROLES_CHANGED if self roles changed', () => {
+        locusInfo.self = self;
+        locusInfo.emitScoped = sinon.stub();
+        const sampleNewSelf = cloneDeep(self);
+        sampleNewSelf.controls.role.roles = [{type: 'COHOST', hasRole: true}];
+
+        locusInfo.updateSelf(sampleNewSelf, []);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateSelf',
+          },
+          LOCUSINFO.EVENTS.SELF_ROLES_CHANGED,
+          {oldRoles: ['PRESENTER'], newRoles: ['COHOST']}
+        );
+      });
+
+      it('should not trigger SELF_ROLES_CHANGED if self roles not changed', () => {
+        locusInfo.self = self;
+        locusInfo.emitScoped = sinon.stub();
+        const sampleNewSelf = cloneDeep(self);
+        sampleNewSelf.controls.role.roles = [{type: 'PRESENTER', hasRole: true}];
+
+        locusInfo.updateSelf(sampleNewSelf, []);
+
+        assert.neverCalledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateSelf',
+          },
+          LOCUSINFO.EVENTS.SELF_ROLES_CHANGED,
+          {oldRoles: ['PRESENTER'], newRoles: ['PRESENTER']}
+        );
+      });
+
+      it('should trigger SELF_MEETING_INTERPRETATION_CHANGED if self interpretation info changed', () => {
+        locusInfo.self = self;
+        locusInfo.emitScoped = sinon.stub();
+        const sampleNewSelf = cloneDeep(self);
+        sampleNewSelf.controls.interpretation.targetLanguage = 'it';
+
+        locusInfo.updateSelf(sampleNewSelf, []);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateSelf',
+          },
+          LOCUSINFO.EVENTS.SELF_MEETING_INTERPRETATION_CHANGED,
+          {
+            interpretation: sampleNewSelf.controls.interpretation,
+            selfParticipantId: self.id,
+          }
+        );
+      });
+
+      it('should not trigger SELF_MEETING_INTERPRETATION_CHANGED if self interpretation info not changed', () => {
+        locusInfo.self = self;
+        locusInfo.emitScoped = sinon.stub();
+        const sampleNewSelf = cloneDeep(self);
+        sampleNewSelf.controls.interpretation.targetLanguage = 'cn'; // same with previous one
+
+        locusInfo.updateSelf(sampleNewSelf, []);
+
+        assert.neverCalledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateSelf',
+          },
+          LOCUSINFO.EVENTS.SELF_MEETING_INTERPRETATION_CHANGED,
+          {
+            interpretation: sampleNewSelf.controls.interpretation,
+            selfParticipantId: self.id,
+          }
+        );
+      });
     });
 
     describe('#updateMeetingInfo', () => {
@@ -962,7 +1372,7 @@ describe('plugin-meetings', () => {
             function: 'updateMeetingInfo',
           },
           LOCUSINFO.EVENTS.MEETING_INFO_UPDATED,
-          {info: locusInfo.parsedLocus.info, self},
+         {info: locusInfo.parsedLocus.info, self},
         ];
 
         if (expected) {
@@ -973,6 +1383,25 @@ describe('plugin-meetings', () => {
         locusInfo.emitScoped.resetHistory();
       };
 
+      const checkMeetingInfoUpdatedCalledForRoles = (expected) => {
+        const expectedArgs = [
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateMeetingInfo',
+          },
+          LOCUSINFO.EVENTS.MEETING_INFO_UPDATED,
+        ];
+
+        if (expected) {
+          assert.calledWith(...expectedArgs);
+        } else {
+          assert.neverCalledWith(...expectedArgs);
+        }
+        locusInfo.emitScoped.resetHistory();
+      };
+
+
       it('emits MEETING_INFO_UPDATED if the info changes', () => {
         const initialInfo = cloneDeep(meetingInfo);
 
@@ -998,6 +1427,16 @@ describe('plugin-meetings', () => {
 
         // since the info is the same it should not call trigger the event
         checkMeetingInfoUpdatedCalled(false);
+
+        // update it with the same info, but roles changed
+        const updateSelf = cloneDeep(self);
+        updateSelf?.controls?.role?.roles.push({
+          type: 'COHOST',
+          hasRole: true,
+        });
+        locusInfo.updateMeetingInfo(newInfo, updateSelf);
+        // since the info is the same but roles changed, it should call trigger the event
+        checkMeetingInfoUpdatedCalledForRoles(true);
       });
 
       it('gets roles from self if available', () => {
@@ -1103,6 +1542,7 @@ describe('plugin-meetings', () => {
         fakeLocus = {
           meeting: true,
           participants: true,
+          url: 'newLocusUrl',
         };
       });
 
@@ -1147,6 +1587,55 @@ describe('plugin-meetings', () => {
         assert.isFunction(locusParser.onDeltaAction);
       });
 
+      it('#updateLocusInfo ignores breakout LEFT message', () => {
+        const newLocus = {
+          self: {
+            reason: 'MOVED',
+            state: 'LEFT',
+          },
+        };
+
+        locusInfo.updateControls = sinon.stub();
+        locusInfo.updateConversationUrl = sinon.stub();
+        locusInfo.updateCreated = sinon.stub();
+        locusInfo.updateFullState = sinon.stub();
+        locusInfo.updateHostInfo = sinon.stub();
+        locusInfo.updateMeetingInfo = sinon.stub();
+        locusInfo.updateMediaShares = sinon.stub();
+        locusInfo.updateParticipantsUrl = sinon.stub();
+        locusInfo.updateReplace = sinon.stub();
+        locusInfo.updateSelf = sinon.stub();
+        locusInfo.updateLocusUrl = sinon.stub();
+        locusInfo.updateAclUrl = sinon.stub();
+        locusInfo.updateBasequence = sinon.stub();
+        locusInfo.updateSequence = sinon.stub();
+        locusInfo.updateMemberShip = sinon.stub();
+        locusInfo.updateIdentifiers = sinon.stub();
+        locusInfo.updateEmbeddedApps = sinon.stub();
+        locusInfo.compareAndUpdate = sinon.stub();
+
+        locusInfo.updateLocusInfo(newLocus);
+
+        assert.notCalled(locusInfo.updateControls);
+        assert.notCalled(locusInfo.updateConversationUrl);
+        assert.notCalled(locusInfo.updateCreated);
+        assert.notCalled(locusInfo.updateFullState);
+        assert.notCalled(locusInfo.updateHostInfo);
+        assert.notCalled(locusInfo.updateMeetingInfo);
+        assert.notCalled(locusInfo.updateMediaShares);
+        assert.notCalled(locusInfo.updateParticipantsUrl);
+        assert.notCalled(locusInfo.updateReplace);
+        assert.notCalled(locusInfo.updateSelf);
+        assert.notCalled(locusInfo.updateLocusUrl);
+        assert.notCalled(locusInfo.updateAclUrl);
+        assert.notCalled(locusInfo.updateBasequence);
+        assert.notCalled(locusInfo.updateSequence);
+        assert.notCalled(locusInfo.updateMemberShip);
+        assert.notCalled(locusInfo.updateIdentifiers);
+        assert.notCalled(locusInfo.updateEmbeddedApps);
+        assert.notCalled(locusInfo.compareAndUpdate);
+      });
+
       it('onFullLocus() updates the working-copy of locus parser', () => {
         const eventType = 'fakeEvent';
 
@@ -1196,12 +1685,18 @@ describe('plugin-meetings', () => {
           locusInfo: {
             onFullLocus: sandbox.stub(),
           },
+          locusUrl: 'oldLocusUrl',
         };
 
         locusInfo.locusParser.resume = sandbox.stub();
         locusInfo.applyLocusDeltaData(DESYNC, fakeLocus, meeting);
 
-        assert.calledOnce(meeting.meetingRequest.getFullLocus);
+        assert.calledOnceWithExactly(meeting.meetingRequest.getFullLocus,
+          {
+            desync: true,
+            locusUrl: 'newLocusUrl',
+          }
+          );
       });
 
       it('getFullLocus handles DESYNC action correctly', () => {
@@ -1226,6 +1721,187 @@ describe('plugin-meetings', () => {
           assert.calledOnce(locusInfo.locusParser.resume);
         });
       });
+
+      it('onDeltaLocus handle delta data', () => {
+        fakeLocus.participants = {};
+        const fakeBreakout = {
+          sessionId: 'sessionId',
+          groupId: 'groupId',
+        };
+
+        fakeLocus.controls = {
+          breakout: fakeBreakout
+        };
+        locusInfo.controls = {
+          breakout: {
+            sessionId: 'sessionId',
+            groupId: 'groupId',
+          }
+        }
+        locusInfo.updateParticipants = sinon.stub();
+        locusInfo.onDeltaLocus(fakeLocus);
+        assert.calledWith(locusInfo.updateParticipants, {}, false);
+
+        fakeLocus.controls.breakout.sessionId = 'sessionId2';
+        locusInfo.onDeltaLocus(fakeLocus);
+        assert.calledWith(locusInfo.updateParticipants, {}, true);
+      });
+    });
+
+    describe('#updateLocusCache', () => {
+      it('cache it if income locus is main session locus', () => {
+        const locus = {url: 'url'};
+        locusInfo.mainSessionLocusCache = null;
+        locusInfo.updateLocusCache(locus);
+
+        assert.deepEqual(locusInfo.mainSessionLocusCache, locus);
+      });
+
+      it('not cache it if income locus is breakout session locus', () => {
+        const locus = {url: 'url', controls: {breakout: {sessionType: 'BREAKOUT'}}};
+        locusInfo.mainSessionLocusCache = null;
+        locusInfo.updateLocusCache(locus);
+
+        assert.isNull(locusInfo.mainSessionLocusCache);
+      });
+    });
+
+    describe('#getTheLocusToUpdate', () => {
+      it('return the cache locus if return to main session', () => {
+        locusInfo.mainSessionLocusCache = {url: 'url'};
+        locusInfo.controls = {
+          breakout: {
+            sessionType: 'BREAKOUT'
+          }
+        }
+        const newLocus = {
+          controls: {
+            breakout: {
+              sessionType: 'MAIN',
+            },
+          },
+        };
+
+        assert.deepEqual(locusInfo.getTheLocusToUpdate(newLocus), {url: 'url'});
+      });
+
+      it('return the new locus if return to main session but no cache', () => {
+        locusInfo.mainSessionLocusCache = null;
+        locusInfo.controls = {
+          breakout: {
+            sessionType: 'BREAKOUT'
+          }
+        }
+        const newLocus = {
+          controls: {
+            breakout: {
+              sessionType: 'MAIN',
+            },
+          },
+        };
+
+        assert.deepEqual(locusInfo.getTheLocusToUpdate(newLocus), newLocus);
+      });
+
+      it('return the new locus if not return to main session', () => {
+        locusInfo.mainSessionLocusCache = {url: 'url'};
+        locusInfo.controls = {
+          breakout: {
+            sessionType: 'MAIN'
+          }
+        }
+        const newLocus = {
+          controls: {
+            breakout: {
+              sessionType: 'BREAKOUT',
+            },
+          },
+        };
+
+        assert.deepEqual(locusInfo.getTheLocusToUpdate(newLocus), newLocus);
+      });
+    });
+
+    describe('#mergeParticipants', () => {
+      let participants;
+      let sourceParticipants;
+      beforeEach(() => {
+        participants = [{id: '111', status: 'JOINED'}, {id: '222'}];
+        sourceParticipants = [{id: '111', status: 'LEFT'}, {id: '333'}];
+      });
+
+      it('merge the participants, replace it by id if exist in old array', () => {
+        const result = locusInfo.mergeParticipants(participants, sourceParticipants);
+        assert.deepEqual(result, [{id: '111', status: 'LEFT'}, {id: '222'}, {id: '333'}]);
+      });
+
+      it('return new participants if previous participants is empty', () => {
+        const result = locusInfo.mergeParticipants([], sourceParticipants);
+        assert.deepEqual(result, sourceParticipants);
+      });
+
+      it('return new participants if previous participants is null/undefined', () => {
+        let result = locusInfo.mergeParticipants(null, sourceParticipants);
+        assert.deepEqual(result, sourceParticipants);
+
+        result = locusInfo.mergeParticipants(undefined, sourceParticipants);
+        assert.deepEqual(result, sourceParticipants);
+      });
+
+      it('return previous participants if new participants is empty', () => {
+        const result = locusInfo.mergeParticipants(participants, []);
+        assert.deepEqual(result, participants);
+      });
+
+      it('return previous participants if new participants is null/undefined', () => {
+        let result = locusInfo.mergeParticipants(participants, null);
+        assert.deepEqual(result, participants);
+
+        result = locusInfo.mergeParticipants(participants, undefined);
+        assert.deepEqual(result, participants);
+      });
+    });
+
+    describe('#updateMainSessionLocusCache', () => {
+      let cachedLocus;
+      let newLocus;
+      beforeEach(() => {
+        cachedLocus = {controls: {}, participants: [], info: {webExMeetingId: 'testId1', topic: 'test'}};
+        newLocus = {self: {}, participants: [{id: '111'}], info: {testId: 'testId2', webExMeetingName: 'hello'}};
+      });
+      it('shallow merge new locus into cache', () => {
+        locusInfo.mainSessionLocusCache = cachedLocus;
+        locusInfo.updateMainSessionLocusCache(newLocus);
+
+        assert.deepEqual(locusInfo.mainSessionLocusCache, {
+          controls: {},
+          participants: [{id: '111'}],
+          info: {testId: 'testId2', webExMeetingName: 'hello'},
+          self: {},
+        });
+      });
+
+      it('cache new locus if no cache before', () => {
+        locusInfo.mainSessionLocusCache = null;
+        locusInfo.updateMainSessionLocusCache(newLocus);
+
+        assert.deepEqual(locusInfo.mainSessionLocusCache, newLocus);
+      });
+
+      it('do nothing if new locus is null', () => {
+        locusInfo.mainSessionLocusCache = cachedLocus;
+        locusInfo.updateMainSessionLocusCache(null);
+
+        assert.deepEqual(locusInfo.mainSessionLocusCache, cachedLocus);
+      });
+    });
+
+    describe('#clearMainSessionLocusCache', () => {
+      it('clear main session locus cache', () => {
+        locusInfo.mainSessionLocusCache = {controls: {}};
+        locusInfo.clearMainSessionLocusCache();
+        assert.isNull(locusInfo.mainSessionLocusCache);
+      })
     });
 
     describe('#handleOneonOneEvent', () => {