@webex/plugin-meetings 3.8.1-next.4 → 3.8.1-next.41

package/src/multistream/mediaRequestManager.ts

@@ -15,7 +15,7 @@ import {cloneDeepWith, debounce, isEmpty} from 'lodash';
 import LoggerProxy from '../common/logs/logger-proxy';
 
 import {ReceiveSlot, ReceiveSlotEvents} from './receiveSlot';
-import {getMaxFs} from './remoteMedia';
+import {MAX_FS_VALUES} from './remoteMedia';
 
 export interface ActiveSpeakerPolicyInfo {
   policy: 'active-speaker';
@@ -123,12 +123,12 @@ export class MediaRequestManager {
 
   private getDegradedClientRequests(clientRequests: ClientRequestsMap) {
     const maxFsLimits = [
-      getMaxFs('best'),
-      getMaxFs('large'),
-      getMaxFs('medium'),
-      getMaxFs('small'),
-      getMaxFs('very small'),
-      getMaxFs('thumbnail'),
+      MAX_FS_VALUES['1080p'],
+      MAX_FS_VALUES['720p'],
+      MAX_FS_VALUES['540p'],
+      MAX_FS_VALUES['360p'],
+      MAX_FS_VALUES['180p'],
+      MAX_FS_VALUES['90p'],
     ];
 
     // reduce max-fs until total macroblocks is below limit

package/src/multistream/remoteMedia.ts

@@ -19,17 +19,18 @@ export type RemoteVideoResolution =
   | 'large' // 1080p or less
   | 'best'; // highest possible resolution
 
-const MAX_FS_VALUES = {
+export const MAX_FS_VALUES = {
   '90p': 60,
   '180p': 240,
   '360p': 920,
+  '540p': 2040,
   '720p': 3600,
   '1080p': 8192,
 };
 
 /**
  * Converts pane size into h264 maxFs
- * @param {PaneSize} paneSize
+ * @param {RemoteVideoResolution} paneSize
  * @returns {number}
  */
 export function getMaxFs(paneSize: RemoteVideoResolution): number {
@@ -89,6 +90,13 @@ export class RemoteMedia extends EventsScope {
 
   public readonly id: RemoteMediaId;
 
+  /**
+   * The max frame size of the media request, used for logging and media requests.
+   * Set by setSizeHint() based on video element dimensions.
+   * When > 0, this value takes precedence over options.resolution in sendMediaRequest().
+   */
+  private maxFrameSize = 0;
+
   /**
    * Constructs RemoteMedia instance
    *
@@ -136,15 +144,34 @@ export class RemoteMedia extends EventsScope {
       fs = MAX_FS_VALUES['180p'];
     } else if (height < getThresholdHeight(360)) {
       fs = MAX_FS_VALUES['360p'];
+    } else if (height < getThresholdHeight(540)) {
+      fs = MAX_FS_VALUES['540p'];
     } else if (height <= 720) {
       fs = MAX_FS_VALUES['720p'];
     } else {
       fs = MAX_FS_VALUES['1080p'];
     }
 
+    this.maxFrameSize = fs;
     this.receiveSlot?.setMaxFs(fs);
   }
 
+  /**
+   * Get the current effective maxFs value that would be used in media requests
+   * @returns {number | undefined} The maxFs value, or undefined if no constraints
+   */
+  public getEffectiveMaxFs(): number | undefined {
+    if (this.maxFrameSize > 0) {
+      return this.maxFrameSize;
+    }
+
+    if (this.options.resolution) {
+      return getMaxFs(this.options.resolution);
+    }
+
+    return undefined;
+  }
+
   /**
    * Invalidates the remote media by clearing the reference to a receive slot and
    * cancelling the media request.
@@ -185,6 +212,9 @@ export class RemoteMedia extends EventsScope {
       throw new Error('sendMediaRequest() called on an invalidated RemoteMedia instance');
     }
 
+    // Use maxFrameSize from setSizeHint if available, otherwise fallback to options.resolution
+    const maxFs = this.getEffectiveMaxFs();
+
     this.mediaRequestId = this.mediaRequestManager.addRequest(
       {
         policyInfo: {
@@ -192,9 +222,9 @@ export class RemoteMedia extends EventsScope {
           csi,
         },
         receiveSlots: [this.receiveSlot],
-        codecInfo: this.options.resolution && {
+        codecInfo: maxFs && {
           codec: 'h264',
-          maxFs: getMaxFs(this.options.resolution),
+          maxFs,
         },
       },
       commit

package/src/multistream/remoteMediaGroup.ts

@@ -215,6 +215,9 @@ export class RemoteMediaGroup {
   private sendActiveSpeakerMediaRequest(commit: boolean) {
     this.cancelActiveSpeakerMediaRequest(false);
 
+    // Calculate the effective maxFs based on all unpinned RemoteMedia instances
+    const effectiveMaxFs = this.getEffectiveMaxFsForActiveSpeaker();
+
     this.mediaRequestId = this.mediaRequestManager.addRequest(
       {
         policyInfo: {
@@ -230,9 +233,9 @@ export class RemoteMediaGroup {
         receiveSlots: this.unpinnedRemoteMedia.map((remoteMedia) =>
           remoteMedia.getUnderlyingReceiveSlot()
         ) as ReceiveSlot[],
-        codecInfo: this.options.resolution && {
+        codecInfo: effectiveMaxFs && {
           codec: 'h264',
-          maxFs: getMaxFs(this.options.resolution),
+          maxFs: effectiveMaxFs,
         },
       },
       commit
@@ -300,4 +303,36 @@ export class RemoteMediaGroup {
       this.unpinnedRemoteMedia.includes(remoteMedia) || this.pinnedRemoteMedia.includes(remoteMedia)
     );
   }
+
+  /**
+   * Calculate the effective maxFs for the active speaker media request based on unpinned RemoteMedia instances
+   * @returns {number | undefined} The calculated maxFs value, or undefined if no constraints
+   * @private
+   */
+  private getEffectiveMaxFsForActiveSpeaker(): number | undefined {
+    // Get all effective maxFs values from unpinned RemoteMedia instances
+    const maxFsValues = this.unpinnedRemoteMedia
+      .map((remoteMedia) => remoteMedia.getEffectiveMaxFs())
+      .filter((maxFs) => maxFs !== undefined);
+
+    // Use the highest maxFs value to ensure we don't under-request resolution for any instance
+    if (maxFsValues.length > 0) {
+      return Math.max(...maxFsValues);
+    }
+
+    // Fall back to group's resolution option
+    if (this.options.resolution) {
+      return getMaxFs(this.options.resolution);
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Get the current effective maxFs that would be used for the active speaker media request
+   * @returns {number | undefined} The effective maxFs value
+   */
+  public getEffectiveMaxFs(): number | undefined {
+    return this.getEffectiveMaxFsForActiveSpeaker();
+  }
 }

package/src/multistream/sendSlotManager.ts

@@ -7,10 +7,20 @@ import {
   StreamState,
 } from '@webex/internal-media-core';
 
+/**
+ * This class is used to manage the sendSlots for the given media types.
+ */
 export default class SendSlotManager {
   private readonly slots: Map<MediaType, SendSlot> = new Map();
   private readonly LoggerProxy: any;
+  private readonly sourceStateOverrides: Map<MediaType, StreamState> = new Map();
 
+  /**
+   * Constructor for SendSlotManager
+   *
+   * @param {any} LoggerProxy is used to log the messages
+   * @constructor
+   */
   constructor(LoggerProxy: any) {
     this.LoggerProxy = LoggerProxy;
   }
@@ -93,7 +103,7 @@ export default class SendSlotManager {
   public setSourceStateOverride(mediaType: MediaType, state: StreamState | null) {
     if (mediaType !== MediaType.VideoMain) {
       throw new Error(
-        `sendSlotManager cannot set source state override which media type is ${mediaType}`
+        `Invalid media type '${mediaType}'. Source state overrides are only applicable to ${MediaType.VideoMain}.`
       );
     }
 
@@ -103,17 +113,39 @@ export default class SendSlotManager {
       throw new Error(`Slot for ${mediaType} does not exist`);
     }
 
+    const currentStateOverride = this.getSourceStateOverride(mediaType);
+    if (currentStateOverride === state) {
+      return;
+    }
+
     if (state) {
       slot.setSourceStateOverride(state);
+      this.sourceStateOverrides.set(mediaType, state);
     } else {
       slot.clearSourceStateOverride();
+      this.sourceStateOverrides.delete(mediaType);
     }
 
     this.LoggerProxy.logger.info(
-      `SendSlotsManager->setSourceStateOverride#set source state override for ${mediaType} to ${state}`
+      `SendSlotManager->setSourceStateOverride#set source state override for ${mediaType} to ${state}`
     );
   }
 
+  /**
+   * Gets the source state override for the given media type.
+   * @param {MediaType} mediaType - The type of media to get the source state override for.
+   * @returns {StreamState | null} - The current source state override or null if not set.
+   */
+  private getSourceStateOverride(mediaType: MediaType): StreamState | null {
+    if (mediaType !== MediaType.VideoMain) {
+      throw new Error(
+        `Invalid media type '${mediaType}'. Source state overrides are only applicable to ${MediaType.VideoMain}.`
+      );
+    }
+
+    return this.sourceStateOverrides.get(mediaType) || null;
+  }
+
   /**
    * This method publishes the given stream to the sendSlot for the given mediaType
    * @param {MediaType} mediaType MediaType of the sendSlot to which a stream needs to be published (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)

package/src/reachability/index.ts

@@ -140,22 +140,14 @@ export default class Reachability extends EventsScope {
 
   /**
    * Checks if the given subnet is reachable
-   * @param {string} mediaServerIp - media server ip
+   * @param {string} selectedSubnetFirstOctet - selected subnet first octet, e.g. "10" for "10.X.X.X"
    * @returns {boolean | null} true if reachable, false if not reachable, null if mediaServerIp is not provided
    * @public
    * @memberof Reachability
    */
-  public isSubnetReachable(mediaServerIp?: string): boolean | null {
-    if (!mediaServerIp) {
-      LoggerProxy.logger.error(`Reachability:index#isSubnetReachable --> mediaServerIp is null`);
-
-      return null;
-    }
-
-    const subnetFirstOctet = mediaServerIp.split('.')[0];
-
+  public isSubnetReachable(selectedSubnetFirstOctet: string): boolean | null {
     LoggerProxy.logger.info(
-      `Reachability:index#isSubnetReachable --> Looking for subnet: ${subnetFirstOctet}.X.X.X`
+      `Reachability:index#isSubnetReachable --> Looking for subnet: ${selectedSubnetFirstOctet}.X.X.X`
     );
 
     const matchingReachedClusters = Object.values(this.clusterReachability).reduce(
@@ -167,7 +159,7 @@ export default class Reachability extends EventsScope {
           const subnet = reachedSubnetsArray[i];
           const reachedSubnetFirstOctet = subnet.split('.')[0];
 
-          if (subnetFirstOctet === reachedSubnetFirstOctet) {
+          if (selectedSubnetFirstOctet === reachedSubnetFirstOctet) {
             acc.add(cluster.name);
           }
 
@@ -186,7 +178,7 @@ export default class Reachability extends EventsScope {
     );
 
     LoggerProxy.logger.info(
-      `Reachability:index#isSubnetReachable --> Found ${matchingReachedClusters.size} clusters that use the subnet ${subnetFirstOctet}.X.X.X`
+      `Reachability:index#isSubnetReachable --> Found ${matchingReachedClusters.size} clusters that use the subnet ${selectedSubnetFirstOctet}.X.X.X`
     );
 
     return matchingReachedClusters.size > 0;

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

@@ -305,7 +305,7 @@ describe('plugin-meetings', () => {
           {state: newControls.rdcControl}
         );
       });
-      
+
       it('should trigger the CONTROLS_POLLING_QA_CHANGED event when necessary', () => {
         locusInfo.controls = {};
         locusInfo.emitScoped = sinon.stub();
@@ -834,39 +834,6 @@ describe('plugin-meetings', () => {
         );
       });
 
-      it('should update the deltaParticipants object', () => {
-        const prev = locusInfo.deltaParticipants;
-
-        locusInfo.updateParticipantDeltas(newParticipants);
-
-        assert.notEqual(locusInfo.deltaParticipants, prev);
-      });
-
-      it('should update the delta property on all changed states', () => {
-        locusInfo.updateParticipantDeltas(newParticipants);
-
-        const [exampleParticipant] = locusInfo.deltaParticipants;
-
-        assert.isTrue(exampleParticipant.delta.audioStatus);
-        assert.isTrue(exampleParticipant.delta.videoSlidesStatus);
-        assert.isTrue(exampleParticipant.delta.videoStatus);
-      });
-
-      it('should include the person details of the changed participant', () => {
-        locusInfo.updateParticipantDeltas(newParticipants);
-
-        const [exampleParticipant] = locusInfo.deltaParticipants;
-
-        assert.equal(exampleParticipant.person, newParticipants[0].person);
-      });
-
-      it('should clear deltaParticipants when no changes occured', () => {
-        locusInfo.participants = [...newParticipants];
-
-        locusInfo.updateParticipantDeltas(locusInfo.participants);
-
-        assert.isTrue(locusInfo.deltaParticipants.length === 0);
-      });
 
       it('should call with participant display name', () => {
         const failureParticipant = [
@@ -2108,6 +2075,38 @@ describe('plugin-meetings', () => {
         assert.isFunction(locusParser.onDeltaAction);
       });
 
+      it("#updateLocusInfo invokes updateLocusUrl before updateMeetingInfo", () => {
+        const callOrder = [];
+        sinon.stub(locusInfo, "updateControls");
+        sinon.stub(locusInfo, "updateConversationUrl");
+        sinon.stub(locusInfo, "updateCreated");
+        sinon.stub(locusInfo, "updateFullState");
+        sinon.stub(locusInfo, "updateHostInfo");
+        sinon.stub(locusInfo, "updateMeetingInfo").callsFake(() => {
+          callOrder.push("updateMeetingInfo");
+        });
+        sinon.stub(locusInfo, "updateMediaShares");
+        sinon.stub(locusInfo, "updateParticipantsUrl");
+        sinon.stub(locusInfo, "updateReplace");
+        sinon.stub(locusInfo, "updateSelf");
+        sinon.stub(locusInfo, "updateLocusUrl").callsFake(() => {
+          callOrder.push("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, "updateResources");
+        sinon.stub(locusInfo, "compareAndUpdate");
+
+        locusInfo.updateLocusInfo(locus);
+
+        // Ensure updateLocusUrl is called before updateMeetingInfo if both are called
+        assert.deepEqual(callOrder, ['updateLocusUrl', 'updateMeetingInfo']);
+      });
+
       it('#updateLocusInfo ignores breakout LEFT message', () => {
         const newLocus = {
           self: {
@@ -2159,10 +2158,11 @@ describe('plugin-meetings', () => {
         assert.notCalled(locusInfo.compareAndUpdate);
       });
 
+
+
       it('onFullLocus() updates the working-copy of locus parser', () => {
         const eventType = 'fakeEvent';
 
-        sandbox.stub(locusInfo, 'updateParticipantDeltas');
         sandbox.stub(locusInfo, 'updateLocusInfo');
         sandbox.stub(locusInfo, 'updateParticipants');
         sandbox.stub(locusInfo, 'isMeetingActive');
@@ -2182,7 +2182,6 @@ describe('plugin-meetings', () => {
         const oldWorkingCopy = locusParser.workingCopy;
 
         const spies = [
-          sandbox.stub(locusInfo, 'updateParticipantDeltas'),
           sandbox.stub(locusInfo, 'updateLocusInfo'),
           sandbox.stub(locusInfo, 'updateParticipants'),
           sandbox.stub(locusInfo, 'isMeetingActive'),
@@ -2257,7 +2256,7 @@ describe('plugin-meetings', () => {
 
       it('applyLocusDeltaData gets delta locus on DESYNC action if we have a syncUrl', () => {
         const {DESYNC} = LocusDeltaParser.loci;
-        const fakeDeltaLocus = {id: 'fake delta locus'};
+        const fakeDeltaLocus = {baseSequence: {}, id: 'fake delta locus'};
         const meeting = {
           meetingRequest: {
             getLocusDTO: sandbox.stub().resolves({body: fakeDeltaLocus}),
@@ -2392,25 +2391,22 @@ describe('plugin-meetings', () => {
           };
         });
 
-        it('applyLocusDeltaData gets full locus on DESYNC action if we do not have a syncUrl and destroys the meeting if that fails', () => {
+        it('applyLocusDeltaData gets full locus on DESYNC action if we do not have a syncUrl and destroys the meeting if that fails', async () => {
           meeting.meetingRequest.getLocusDTO.rejects(new Error('fake error'));
 
           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.
-          return new Promise((resolve) => {
-            webex.meetings.destroy.callsFake(() => resolve());
-            locusInfo.applyLocusDeltaData(DESYNC, fakeLocus, meeting);
-          }).then(() => {
-            assert.calledOnceWithExactly(meeting.meetingRequest.getLocusDTO, {url: 'fullSyncUrl'});
+          locusInfo.applyLocusDeltaData(DESYNC, fakeLocus, meeting);
 
-            assert.notCalled(meeting.locusInfo.handleLocusDelta);
-            assert.notCalled(meeting.locusInfo.onFullLocus);
-            assert.notCalled(locusInfo.locusParser.resume);
+          await testUtils.flushPromises();
 
-            assert.calledOnceWithExactly(webex.meetings.destroy, meeting, 'LOCUS_DTO_SYNC_FAILED');
-          });
+          assert.calledOnceWithExactly(meeting.meetingRequest.getLocusDTO, {url: 'fullSyncUrl'});
+
+          assert.notCalled(meeting.locusInfo.handleLocusDelta);
+          assert.notCalled(meeting.locusInfo.onFullLocus);
+          assert.notCalled(locusInfo.locusParser.resume);
+
+          assert.calledOnceWithExactly(webex.meetings.destroy, meeting, 'LOCUS_DTO_SYNC_FAILED');
         });
 
         it('applyLocusDeltaData first tries a delta sync on DESYNC action and if that fails, does a full locus sync', () => {
@@ -2447,39 +2443,62 @@ describe('plugin-meetings', () => {
           });
         });
 
-        it('applyLocusDeltaData destroys the meeting if both delta sync and full sync fail', () => {
+        it('applyLocusDeltaData first tries a delta sync on DESYNC action and if that fails with 403, it does not do a full locus sync', async () => {
+          const fake403Error = new Error('fake error');
+          fake403Error.statusCode = 403;
+
+          meeting.meetingRequest.getLocusDTO.onCall(0).rejects(fake403Error);
+
+          locusInfo.applyLocusDeltaData(DESYNC, fakeLocus, meeting);
+
+          await testUtils.flushPromises();
+
+          assert.calledOnceWithExactly(meeting.meetingRequest.getLocusDTO, {url: 'deltaSyncUrl'});
+
+          assert.calledWith(sendBehavioralMetricStub, 'js_sdk_locus_delta_sync_failed', {
+            correlationId: meeting.correlationId,
+            url: 'deltaSyncUrl',
+            reason: 'fake error',
+            errorName: 'Error',
+            stack: sinon.match.any,
+            code: sinon.match.any,
+          });
+
+          assert.notCalled(meeting.locusInfo.handleLocusDelta);
+          assert.notCalled(meeting.locusInfo.onFullLocus);
+          assert.notCalled(locusInfo.locusParser.resume);
+        });
+
+        it('applyLocusDeltaData destroys the meeting if both delta sync and full sync fail', async () => {
           meeting.meetingRequest.getLocusDTO.rejects(new Error('fake error'));
 
-          // 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) => {
-            webex.meetings.destroy.callsFake(() => resolve());
-            locusInfo.applyLocusDeltaData(DESYNC, fakeLocus, meeting);
-          }).then(() => {
-            assert.calledTwice(meeting.meetingRequest.getLocusDTO);
+          locusInfo.applyLocusDeltaData(DESYNC, fakeLocus, meeting);
 
-            assert.deepEqual(meeting.meetingRequest.getLocusDTO.getCalls()[0].args, [
-              {url: 'deltaSyncUrl'},
-            ]);
-            assert.deepEqual(meeting.meetingRequest.getLocusDTO.getCalls()[1].args, [
-              {url: 'fullSyncUrl'},
-            ]);
+          await testUtils.flushPromises();
 
-            assert.calledWith(sendBehavioralMetricStub, 'js_sdk_locus_delta_sync_failed', {
-              correlationId: meeting.correlationId,
-              url: 'deltaSyncUrl',
-              reason: 'fake error',
-              errorName: 'Error',
-              stack: sinon.match.any,
-              code: sinon.match.any,
-            });
+          assert.calledTwice(meeting.meetingRequest.getLocusDTO);
 
-            assert.notCalled(meeting.locusInfo.handleLocusDelta);
-            assert.notCalled(meeting.locusInfo.onFullLocus);
-            assert.notCalled(locusInfo.locusParser.resume);
+          assert.deepEqual(meeting.meetingRequest.getLocusDTO.getCalls()[0].args, [
+            {url: 'deltaSyncUrl'},
+          ]);
+          assert.deepEqual(meeting.meetingRequest.getLocusDTO.getCalls()[1].args, [
+            {url: 'fullSyncUrl'},
+          ]);
 
-            assert.calledOnceWithExactly(webex.meetings.destroy, meeting, 'LOCUS_DTO_SYNC_FAILED');
+          assert.calledWith(sendBehavioralMetricStub, 'js_sdk_locus_delta_sync_failed', {
+            correlationId: meeting.correlationId,
+            url: 'deltaSyncUrl',
+            reason: 'fake error',
+            errorName: 'Error',
+            stack: sinon.match.any,
+            code: sinon.match.any,
           });
+
+          assert.notCalled(meeting.locusInfo.handleLocusDelta);
+          assert.notCalled(meeting.locusInfo.onFullLocus);
+          assert.notCalled(locusInfo.locusParser.resume);
+
+          assert.calledOnceWithExactly(webex.meetings.destroy, meeting, 'LOCUS_DTO_SYNC_FAILED');
         });
       });
 
@@ -2509,9 +2528,7 @@ describe('plugin-meetings', () => {
       });
 
       it('onDeltaLocus merges delta participants with existing participants', () => {
-        const FAKE_DELTA_PARTICIPANTS = [
-          {id: '1111'}, {id: '2222'}
-        ]
+        const FAKE_DELTA_PARTICIPANTS = [{id: '1111'}, {id: '2222'}];
         fakeLocus.participants = FAKE_DELTA_PARTICIPANTS;
 
         sinon.spy(locusInfo, 'mergeParticipants');
@@ -2519,9 +2536,87 @@ describe('plugin-meetings', () => {
         const existingParticipants = locusInfo.participants;
 
         locusInfo.onDeltaLocus(fakeLocus);
-        assert.calledOnceWithExactly(locusInfo.mergeParticipants, existingParticipants, FAKE_DELTA_PARTICIPANTS);
+        assert.calledOnceWithExactly(
+          locusInfo.mergeParticipants,
+          existingParticipants,
+          FAKE_DELTA_PARTICIPANTS
+        );
         assert.calledWith(locusInfo.updateParticipants, FAKE_DELTA_PARTICIPANTS, false);
       });
+
+      [true, false].forEach((isDelta) =>
+        it(`applyLocusDeltaData - handles empty ${
+          isDelta ? 'delta' : 'full'
+        } DTO in response`, async () => {
+          const {DESYNC} = LocusDeltaParser.loci;
+          const fakeFullLocusDto = {};
+          const meeting = {
+            meetingRequest: {
+              getLocusDTO: sandbox.stub().resolves({body: fakeFullLocusDto}),
+            },
+            locusInfo: {
+              onFullLocus: sandbox.stub(),
+              handleLocusDelta: sandbox.stub(),
+            },
+            locusUrl: 'fake locus FULL url',
+          };
+
+          sinon.stub(locusInfo.locusParser, 'resume').resolves();
+
+          if (isDelta) {
+            locusInfo.locusParser.workingCopy = {syncUrl: 'fake locus DELTA url'};
+          } else {
+            locusInfo.locusParser.workingCopy = {}; // no syncUrl (to trigger FULL DTO request)
+          }
+
+          await locusInfo.applyLocusDeltaData(DESYNC, fakeLocus, meeting);
+
+          await testUtils.flushPromises();
+
+          if (isDelta) {
+            assert.calledOnceWithExactly(meeting.meetingRequest.getLocusDTO, {
+              url: 'fake locus DELTA url',
+            });
+          } else {
+            assert.calledOnceWithExactly(meeting.meetingRequest.getLocusDTO, {
+              url: 'fake locus FULL url',
+            });
+          }
+          assert.notCalled(meeting.locusInfo.handleLocusDelta);
+          assert.notCalled(meeting.locusInfo.onFullLocus);
+          assert.calledOnce(locusInfo.locusParser.resume);
+        })
+      );
+
+      it(`applyLocusDeltaData - handles the case when we get FULL DTO when we asked for DELTA DTO`, async () => {
+        const {DESYNC} = LocusDeltaParser.loci;
+        const fakeFullLocusDto = {someStuff: 'data'}; // non-empty DTO, without baseSequence
+        const meeting = {
+          meetingRequest: {
+            getLocusDTO: sandbox.stub().resolves({body: fakeFullLocusDto}),
+          },
+          locusInfo: {
+            onFullLocus: sandbox.stub(),
+            handleLocusDelta: sandbox.stub(),
+          },
+          locusUrl: 'fake locus FULL url',
+        };
+
+        sinon.stub(locusInfo.locusParser, 'resume').resolves();
+
+        locusInfo.locusParser.workingCopy = {syncUrl: 'fake locus DELTA url'};
+
+        await locusInfo.applyLocusDeltaData(DESYNC, fakeLocus, meeting);
+
+        await testUtils.flushPromises();
+
+        assert.calledOnceWithExactly(meeting.meetingRequest.getLocusDTO, {
+          url: 'fake locus DELTA url',
+        });
+        assert.notCalled(meeting.locusInfo.handleLocusDelta);
+        assert.calledOnceWithExactly(meeting.locusInfo.onFullLocus, fakeFullLocusDto);
+        assert.calledOnce(locusInfo.locusParser.resume);
+      });
     });
 
     describe('#updateLocusCache', () => {
@@ -2934,10 +3029,9 @@ describe('plugin-meetings', () => {
       beforeEach(() => {
         clock = sinon.useFakeTimers();
 
-        sinon.stub(locusInfo, 'updateParticipantDeltas');
         sinon.stub(locusInfo, 'updateParticipants');
-        sinon.stub(locusInfo, 'isMeetingActive'),
-          sinon.stub(locusInfo, 'handleOneOnOneEvent'),
+        sinon.stub(locusInfo, 'isMeetingActive');
+          sinon.stub(locusInfo, 'handleOneOnOneEvent');
           (updateLocusInfoStub = sinon.stub(locusInfo, 'updateLocusInfo'));
         syncRequestStub = sinon.stub().resolves({body: {}});