@webex/plugin-meetings 3.0.0-beta.20 → 3.0.0-beta.201

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

@@ -3,6 +3,7 @@ import sinon from 'sinon';
 import {cloneDeep} from 'lodash';
 import {assert} from '@webex/test-helper-chai';
 import MockWebex from '@webex/test-helper-mock-webex';
+import testUtils from '../../../utils/testUtils';
 import Meetings from '@webex/plugin-meetings';
 import LocusInfo from '@webex/plugin-meetings/src/locus-info';
 import SelfUtils from '@webex/plugin-meetings/src/locus-info/selfUtils';
@@ -16,9 +17,14 @@ import {
   LOCUSEVENT,
   EVENTS,
   DISPLAY_HINTS,
+  _CALL_,
+  LOCUS,
+  MEETING_STATE,
+  _MEETING_,
 } from '../../../../src/constants';
 
 import {self, selfWithInactivity} from './selfConstant';
+import uuid from 'uuid';
 
 describe('plugin-meetings', () => {
   describe('LocusInfo index', () => {
@@ -66,8 +72,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 +86,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 +107,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();
@@ -279,9 +382,11 @@ describe('plugin-meetings', () => {
 
       it('should update the breakout state', () => {
         locusInfo.emitScoped = sinon.stub();
-        newControls.breakout = 'new breakout';
+        let tmpStub = sinon.stub(SelfUtils, 'getReplacedBreakoutMoveId').returns('breakoutMoveId');
+        newControls.breakout = {breakout: {}};
+        let selfInfo = {};
 
-        locusInfo.updateControls(newControls);
+        locusInfo.updateControls(newControls, selfInfo);
 
         assert.calledWith(
           locusInfo.emitScoped,
@@ -291,7 +396,28 @@ describe('plugin-meetings', () => {
           },
           LOCUSINFO.EVENTS.CONTROLS_MEETING_BREAKOUT_UPDATED,
           {
-            breakout: 'new breakout'
+            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,
           }
         );
       });
@@ -417,6 +543,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()', () => {
@@ -470,6 +629,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
@@ -477,6 +637,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;
 
@@ -683,6 +880,83 @@ 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);
@@ -701,19 +975,23 @@ describe('plugin-meetings', () => {
           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'
-              }]
-            }
+              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',
+                },
+              ],
+            },
           }
         );
       });
@@ -789,6 +1067,8 @@ 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();
@@ -943,6 +1223,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', () => {
@@ -1027,6 +1389,24 @@ 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);
 
@@ -1052,6 +1432,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', () => {
@@ -1157,6 +1547,8 @@ describe('plugin-meetings', () => {
         fakeLocus = {
           meeting: true,
           participants: true,
+          url: 'newLocusUrl',
+          syncUrl: 'newSyncUrl',
         };
       });
 
@@ -1205,8 +1597,8 @@ describe('plugin-meetings', () => {
         const newLocus = {
           self: {
             reason: 'MOVED',
-            state: 'LEFT'
-          }
+            state: 'LEFT',
+          },
         };
 
         locusInfo.updateControls = sinon.stub();
@@ -1258,12 +1650,39 @@ describe('plugin-meetings', () => {
         sandbox.stub(locusInfo, 'updateParticipants');
         sandbox.stub(locusInfo, 'isMeetingActive');
         sandbox.stub(locusInfo, 'handleOneOnOneEvent');
+        sandbox.stub(locusParser, 'isNewFullLocus').returns(true);
 
         locusInfo.onFullLocus(fakeLocus, eventType);
 
         assert.equal(fakeLocus, locusParser.workingCopy);
       });
 
+      it('onFullLocus() does not do anything if the incoming full locus DTO is old', () => {
+        const eventType = 'fakeEvent';
+
+        locusParser.workingCopy = {};
+
+        const oldWorkingCopy = locusParser.workingCopy;
+
+        const spies = [
+          sandbox.stub(locusInfo, 'updateParticipantDeltas'),
+          sandbox.stub(locusInfo, 'updateLocusInfo'),
+          sandbox.stub(locusInfo, 'updateParticipants'),
+          sandbox.stub(locusInfo, 'isMeetingActive'),
+          sandbox.stub(locusInfo, 'handleOneOnOneEvent'),
+        ];
+
+        sandbox.stub(locusParser, 'isNewFullLocus').returns(false);
+
+        locusInfo.onFullLocus(fakeLocus, eventType);
+
+        spies.forEach((spy) => {
+          assert.notCalled(spy);
+        });
+
+        assert.equal(oldWorkingCopy, locusParser.workingCopy);
+      });
+
       it('onDeltaAction applies locus delta data to meeting', () => {
         const action = 'fake action';
         const parsedLoci = 'fake loci';
@@ -1290,34 +1709,83 @@ describe('plugin-meetings', () => {
         assert.calledWith(meeting.locusInfo.onDeltaLocus, fakeLocus);
       });
 
-      it('applyLocusDeltaData gets full locus on DESYNC action', () => {
+      it('applyLocusDeltaData gets delta locus on DESYNC action if we have a syncUrl', () => {
         const {DESYNC} = LocusDeltaParser.loci;
+        const fakeDeltaLocus = {id: 'fake delta locus'};
         const meeting = {
           meetingRequest: {
-            getFullLocus: sandbox.stub().resolves(true),
+            getLocusDTO: sandbox.stub().resolves({body: fakeDeltaLocus}),
           },
           locusInfo: {
-            onFullLocus: sandbox.stub(),
+            handleLocusDelta: sandbox.stub(),
           },
+          locusUrl: 'oldLocusUrl',
         };
 
-        locusInfo.locusParser.resume = sandbox.stub();
-        locusInfo.applyLocusDeltaData(DESYNC, fakeLocus, meeting);
-
-        assert.calledOnce(meeting.meetingRequest.getFullLocus);
-      });
-
-      it('getFullLocus handles DESYNC action correctly', () => {
-        const {DESYNC} = LocusDeltaParser.loci;
-        const meeting = {
-          meetingRequest: {
-            getFullLocus: sandbox.stub().resolves({body: true}),
-          },
-          locusInfo,
+        locusInfo.locusParser.workingCopy = {
+          syncUrl: 'oldSyncUrl',
         };
 
-        locusInfo.onFullLocus = sandbox.stub();
-
+        // Since we have a promise inside a function we want to test that's not returned,
+        // we will wait and stub it's last function to resolve this waiting promise.
+        // Also ensures .handleLocusDelta() is called before .resume()
+        return new Promise((resolve) => {
+          locusInfo.locusParser.resume = sandbox.stub().callsFake(() => resolve());
+          locusInfo.applyLocusDeltaData(DESYNC, fakeLocus, meeting);
+        }).then(() => {
+          assert.calledOnceWithExactly(meeting.meetingRequest.getLocusDTO, {url: 'oldSyncUrl'});
+
+          assert.calledOnceWithExactly(meeting.locusInfo.handleLocusDelta, fakeDeltaLocus, meeting);
+          assert.calledOnce(locusInfo.locusParser.resume);
+        });
+      });
+
+      it('applyLocusDeltaData gets delta locus on DESYNC action if we have a syncUrl (empty response body)', () => {
+        const {DESYNC} = LocusDeltaParser.loci;
+        const meeting = {
+          meetingRequest: {
+            getLocusDTO: sandbox.stub().resolves({body: {}}),
+          },
+          locusInfo: {
+            handleLocusDelta: sandbox.stub(),
+            onFullLocus: sandbox.stub(),
+          },
+          locusUrl: 'oldLocusUrl',
+        };
+
+        locusInfo.locusParser.workingCopy = {
+          syncUrl: 'oldSyncUrl',
+        };
+
+        // Since we have a promise inside a function we want to test that's not returned,
+        // we will wait and stub it's last function to resolve this waiting promise.
+        return new Promise((resolve) => {
+          locusInfo.locusParser.resume = sandbox.stub().callsFake(() => resolve());
+          locusInfo.applyLocusDeltaData(DESYNC, fakeLocus, meeting);
+        }).then(() => {
+          assert.calledOnceWithExactly(meeting.meetingRequest.getLocusDTO, {url: 'oldSyncUrl'});
+
+          assert.notCalled(meeting.locusInfo.handleLocusDelta);
+          assert.notCalled(meeting.locusInfo.onFullLocus);
+          assert.calledOnce(locusInfo.locusParser.resume);
+        });
+      });
+
+      it('applyLocusDeltaData gets full locus on DESYNC action if we do not have a syncUrl', () => {
+        const {DESYNC} = LocusDeltaParser.loci;
+        const fakeFullLocusDto = {id: 'fake full locus dto'};
+        const meeting = {
+          meetingRequest: {
+            getLocusDTO: sandbox.stub().resolves({body: fakeFullLocusDto}),
+          },
+          locusInfo: {
+            onFullLocus: sandbox.stub(),
+          },
+          locusUrl: 'oldLocusUrl',
+        };
+
+        locusInfo.locusParser.workingCopy = {}; // no syncUrl
+
         // Since we have a promise inside a function we want to test that's not returned,
         // we will wait and stub it's last function to resolve this waiting promise.
         // Also ensures .onFullLocus() is called before .resume()
@@ -1325,10 +1793,201 @@ describe('plugin-meetings', () => {
           locusInfo.locusParser.resume = sandbox.stub().callsFake(() => resolve());
           locusInfo.applyLocusDeltaData(DESYNC, fakeLocus, meeting);
         }).then(() => {
-          assert.calledOnce(meeting.locusInfo.onFullLocus);
+          assert.calledOnceWithExactly(meeting.meetingRequest.getLocusDTO, {url: 'oldLocusUrl'});
+
+          assert.calledOnceWithExactly(meeting.locusInfo.onFullLocus, fakeFullLocusDto);
           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', () => {
@@ -1371,5 +2030,402 @@ describe('plugin-meetings', () => {
         );
       });
     });
+
+    describe('#isMeetingActive', () => {
+      it('sends client event correctly for state = inactive', () => {
+        locusInfo.parsedLocus = {
+          fullState: {
+            type: _CALL_,
+          },
+        };
+
+        locusInfo.fullState = {
+          state: LOCUS.STATE.INACTIVE,
+        };
+
+        locusInfo.isMeetingActive();
+
+        assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+          name: 'client.call.remote-ended',
+          options: {
+            meetingId: locusInfo.meetingId,
+          },
+        });
+      });
+
+      it('sends client event correctly for state = PARTNER_LEFT', () => {
+        locusInfo.getLocusPartner = sinon.stub().returns({state: MEETING_STATE.STATES.LEFT});
+        locusInfo.parsedLocus = {
+          fullState: {
+            type: _CALL_,
+          },
+          self: {
+            state: MEETING_STATE.STATES.DECLINED,
+          },
+        };
+        locusInfo.isMeetingActive();
+
+        assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+          name: 'client.call.remote-ended',
+          options: {
+            meetingId: locusInfo.meetingId,
+          },
+        });
+      });
+
+      it('sends client event correctly for state = SELF_LEFT', () => {
+        locusInfo.getLocusPartner = sinon.stub().returns({state: MEETING_STATE.STATES.LEFT});
+        locusInfo.parsedLocus = {
+          fullState: {
+            type: _CALL_,
+          },
+          self: {
+            state: MEETING_STATE.STATES.LEFT,
+          },
+        };
+
+        locusInfo.isMeetingActive();
+
+        assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+          name: 'client.call.remote-ended',
+          options: {
+            meetingId: locusInfo.meetingId,
+          },
+        });
+      });
+
+      it('sends client event correctly for state = MEETING_INACTIVE_TERMINATING', () => {
+        locusInfo.getLocusPartner = sinon.stub().returns({state: MEETING_STATE.STATES.LEFT});
+        locusInfo.parsedLocus = {
+          fullState: {
+            type: _MEETING_,
+          },
+        };
+
+        locusInfo.fullState = {
+          state: LOCUS.STATE.INACTIVE,
+        };
+
+        locusInfo.isMeetingActive();
+
+        assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+          name: 'client.call.remote-ended',
+          options: {
+            meetingId: locusInfo.meetingId,
+          },
+        });
+      });
+
+      it('sends client event correctly for state = FULLSTATE_REMOVED', () => {
+        locusInfo.getLocusPartner = sinon.stub().returns({state: MEETING_STATE.STATES.LEFT});
+        locusInfo.parsedLocus = {
+          fullState: {
+            type: _MEETING_,
+          },
+        };
+
+        locusInfo.fullState = {
+          removed: true,
+        };
+
+        locusInfo.isMeetingActive();
+
+        assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+          name: 'client.call.remote-ended',
+          options: {
+            meetingId: locusInfo.meetingId,
+          },
+        });
+      });
+    });
+
+    // semi-integration tests that use real LocusInfo with real Parser
+    // and test various scenarios related to handling out-of-order Locus delta events
+    describe('handling of out-of-order Locus delta events', () => {
+      let clock;
+
+      const generateDeltaEvent = (base, sequence) => {
+        return {
+          baseSequence: {
+            rangeStart: 0,
+            rangeEnd: 0,
+            entries: [base],
+          },
+          sequence: {
+            rangeStart: 0,
+            rangeEnd: 0,
+            entries: [sequence],
+          },
+          syncUrl: `fake sync url for sequence ${sequence}`,
+          self: {
+            person: {
+              id: 'test person id',
+            },
+          },
+        };
+      };
+
+      // a list of example delta events, sorted by time and each event is based on the previous one
+      const deltaEvents = [
+        generateDeltaEvent(10, 20), // 0
+        generateDeltaEvent(20, 30), // 1
+        generateDeltaEvent(30, 40), // 2
+        generateDeltaEvent(40, 50), // 3
+        generateDeltaEvent(50, 60), // 4
+        generateDeltaEvent(60, 70), // 5
+        generateDeltaEvent(70, 80), // 6
+        generateDeltaEvent(80, 90), // 7
+        generateDeltaEvent(90, 100), // 8
+      ];
+
+      let updateLocusInfoStub; // we use this stub to verify that an event has been fully processed
+      let syncRequestStub;
+
+      beforeEach(() => {
+        clock = sinon.useFakeTimers();
+
+        sinon.stub(locusInfo, 'updateParticipantDeltas');
+        sinon.stub(locusInfo, 'updateParticipants');
+        sinon.stub(locusInfo, 'isMeetingActive'),
+          sinon.stub(locusInfo, 'handleOneOnOneEvent'),
+          (updateLocusInfoStub = sinon.stub(locusInfo, 'updateLocusInfo'));
+        syncRequestStub = sinon.stub().resolves({body: {}});
+
+        mockMeeting.locusInfo = locusInfo;
+        mockMeeting.locusUrl = 'fake locus url';
+        mockMeeting.meetingRequest = {
+          getLocusDTO: syncRequestStub,
+        };
+
+        locusInfo.onFullLocus({
+          sequence: {
+            rangeStart: 0,
+            rangeEnd: 0,
+            entries: [10],
+          },
+          self: {
+            person: {
+              id: 'test person id',
+            },
+          },
+        });
+
+        updateLocusInfoStub.resetHistory();
+      });
+
+      afterEach(() => {
+        clock.restore();
+      });
+
+      it('queues out-of-order deltas until it receives a correct delta', () => {
+        // send some out-of-order deltas
+        locusInfo.handleLocusDelta(deltaEvents[1], mockMeeting);
+        locusInfo.handleLocusDelta(deltaEvents[4], mockMeeting);
+
+        // they should be queued and not processed
+        assert.notCalled(updateLocusInfoStub);
+
+        // now one of the missing ones, but not the one SDK is really waiting for
+        locusInfo.handleLocusDelta(deltaEvents[2], mockMeeting);
+
+        // still nothing should be processed
+        assert.notCalled(updateLocusInfoStub);
+
+        // now send the one SDK is waiting for
+        locusInfo.handleLocusDelta(deltaEvents[0], mockMeeting);
+
+        // so deltaEvents with indexes 1,2,3 can be processed, but 5 still not, because 4 is missing
+        assert.callCount(updateLocusInfoStub, 3);
+        assert.calledWith(updateLocusInfoStub.getCall(0), deltaEvents[0]);
+        assert.calledWith(updateLocusInfoStub.getCall(1), deltaEvents[1]);
+        assert.calledWith(updateLocusInfoStub.getCall(2), deltaEvents[2]);
+
+        updateLocusInfoStub.resetHistory();
+
+        // now send deltaEvents[4]
+        locusInfo.handleLocusDelta(deltaEvents[3], mockMeeting);
+
+        // and verify deltaEvents[4] and deltaEvents[5] have been processed
+        assert.callCount(updateLocusInfoStub, 2);
+        assert.calledWith(updateLocusInfoStub.getCall(0), deltaEvents[3]);
+        assert.calledWith(updateLocusInfoStub.getCall(1), deltaEvents[4]);
+      });
+
+      it('handles out-of-order deltas correctly even if all arrive in reverse order', () => {
+        // send a bunch deltas in reverse order
+        for (let i = 4; i >= 0; i--) {
+          locusInfo.handleLocusDelta(deltaEvents[i], mockMeeting);
+        }
+
+        // they should be queued and then processed in correct order
+        assert.callCount(updateLocusInfoStub, 5);
+        assert.calledWith(updateLocusInfoStub.getCall(0), deltaEvents[0]);
+        assert.calledWith(updateLocusInfoStub.getCall(1), deltaEvents[1]);
+        assert.calledWith(updateLocusInfoStub.getCall(2), deltaEvents[2]);
+        assert.calledWith(updateLocusInfoStub.getCall(3), deltaEvents[3]);
+        assert.calledWith(updateLocusInfoStub.getCall(4), deltaEvents[4]);
+      });
+
+      it('sends a sync request using syncUrl if it receives at least 1 delta event and processes later deltas after sync correctly', async () => {
+        // the test first sends an initial "good" delta
+        const initialDeltaIdx = 0;
+        const initialDelta = deltaEvents[initialDeltaIdx];
+
+        // then it sends a bunch of out-of-order deltas (at least 6 to trigger a sync), last one being lastOooDelta
+        const firstOooDeltaIdx = 2;
+        const lastOooDeltaIdx = 7;
+        const lastOooDelta = deltaEvents[lastOooDeltaIdx];
+
+        // and finally, after the sync it sends another "good" delta
+        const goodDeltaAfterSync = deltaEvents[8];
+
+        const deltaLocusFromSyncResponse = {
+          baseSequence: {
+            rangeStart: 0,
+            rangeEnd: 0,
+            entries: [initialDelta.sequence.entries[0]],
+          },
+          sequence: {
+            rangeStart: 0,
+            rangeEnd: 0,
+            entries: [lastOooDelta.sequence.entries[0]],
+          },
+          syncUrl: `fake sync url for sequence ${lastOooDelta.sequence.entries[0]}`,
+          self: {
+            person: {
+              id: 'test person id',
+            },
+          },
+        };
+
+        syncRequestStub.resolves({
+          body: deltaLocusFromSyncResponse,
+        });
+
+        // send one correct delta so that SDK has the syncUrl
+        locusInfo.handleLocusDelta(initialDelta, mockMeeting);
+
+        updateLocusInfoStub.resetHistory();
+
+        // send 6 out-of-order deltas to trigger a sync (we're skipping deltaEvents[1])
+        for (let i = firstOooDeltaIdx; i <= lastOooDeltaIdx; i++) {
+          locusInfo.handleLocusDelta(deltaEvents[i], mockMeeting);
+        }
+
+        await testUtils.flushPromises();
+
+        // check that sync was done using the correct syncUrl
+        assert.calledOnceWithExactly(syncRequestStub, {url: initialDelta.syncUrl});
+        assert.calledOnceWithExactly(updateLocusInfoStub, deltaLocusFromSyncResponse);
+
+        updateLocusInfoStub.resetHistory();
+
+        // now send another delta - a good one, it should be processed as normal
+        locusInfo.handleLocusDelta(goodDeltaAfterSync, mockMeeting);
+
+        assert.calledOnceWithExactly(updateLocusInfoStub, goodDeltaAfterSync);
+      });
+
+      it('does a sync if blocked on out-of-order deltas for too long', async () => {
+        // stub random so that the timer fires after 12500 ms
+        sinon.stub(Math, 'random').returns(0.5);
+
+        const oooDelta = deltaEvents[3];
+
+        // setup the stubs so that the sync request receives a full DTO with the sequence equal to the out-of-order delta we simulate
+        const fullLocus = {
+          sequence: oooDelta.sequence,
+        };
+        syncRequestStub.resolves({
+          body: fullLocus,
+        });
+
+        // send an out-of-order delta
+        locusInfo.handleLocusDelta(oooDelta, mockMeeting);
+
+        await clock.tickAsync(12499);
+        await testUtils.flushPromises();
+        assert.notCalled(syncRequestStub);
+        assert.notCalled(updateLocusInfoStub);
+
+        await clock.tickAsync(1);
+        await testUtils.flushPromises();
+
+        assert.calledOnceWithExactly(syncRequestStub, {url: mockMeeting.locusUrl});
+        assert.calledOnceWithExactly(updateLocusInfoStub, fullLocus);
+      });
+
+      it('does a sync if out-of-order deltas queue becomes too big', async () => {
+        // setup the stubs so that the sync request receives a full DTO with the sequence equal to the out-of-order delta we simulate
+        const fullLocus = {
+          sequence: deltaEvents[6].sequence,
+        };
+        syncRequestStub.resolves({
+          body: fullLocus,
+        });
+
+        // send 5 deltas, starting from deltaEvents[1] so that SDK is blocked waiting for deltaEvents[0]
+        for (let i = 0; i < 5; i++) {
+          locusInfo.handleLocusDelta(deltaEvents[i + 1], mockMeeting);
+        }
+
+        // nothing should happen, SDK should still be waiting for deltaEvents[0]
+        assert.notCalled(syncRequestStub);
+        assert.notCalled(updateLocusInfoStub);
+
+        // now send one more out-of-order delta to trigger a sync request
+        locusInfo.handleLocusDelta(deltaEvents[6], mockMeeting);
+
+        await testUtils.flushPromises();
+
+        // check sync was done
+        assert.calledOnceWithExactly(syncRequestStub, {url: mockMeeting.locusUrl});
+        assert.calledOnceWithExactly(updateLocusInfoStub, fullLocus);
+      });
+
+      it('processes delta events that are not included in sync response', async () => {
+        // this test sends a bunch of out-of-order deltas, this triggers a sync
+        // but the full locus response doesn't include the last 2 deltas received, so
+        // we check that these 2 deltas are also processed after sync response
+        const fullLocusFromSyncResponse = {
+          baseSequence: {
+            rangeStart: 0,
+            rangeEnd: 0,
+            entries: [deltaEvents[0].sequence.entries[0]],
+          },
+          sequence: {
+            rangeStart: 0,
+            rangeEnd: 0,
+            entries: [deltaEvents[5].sequence.entries[0]],
+          },
+          syncUrl: `fake sync url for sequence ${deltaEvents[5].sequence.entries[0]}`,
+          self: {
+            person: {
+              id: 'test person id',
+            },
+          },
+        };
+
+        syncRequestStub.resolves({
+          body: fullLocusFromSyncResponse,
+        });
+
+        // send at least 6 out-of-order deltas to trigger a sync (we're skipping deltaEvents[0])
+        for (let i = 1; i <= 7; i++) {
+          locusInfo.handleLocusDelta(deltaEvents[i], mockMeeting);
+        }
+
+        await testUtils.flushPromises();
+
+        // check that sync was done
+        assert.calledOnceWithExactly(syncRequestStub, {url: mockMeeting.locusUrl});
+
+        // and that remaining deltas from the queue that were not included in full Locus were also processed
+        assert.callCount(updateLocusInfoStub, 3);
+        assert.calledWith(updateLocusInfoStub.getCall(0), fullLocusFromSyncResponse);
+        assert.calledWith(updateLocusInfoStub.getCall(1), deltaEvents[6]);
+        assert.calledWith(updateLocusInfoStub.getCall(2), deltaEvents[7]);
+      });
+    });
   });
 });