@webex/plugin-meetings 3.12.0-next.21 → 3.12.0-next.23

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

@@ -3175,7 +3175,7 @@ describe('plugin-meetings', () => {
       const createMockParser = (state = 'active') => ({
         state,
         stop: sinon.stub(),
-        resume: sinon.stub(),
+        resumeFromMessage: sinon.stub(),
         handleMessage: sinon.stub(),
       });
 
@@ -3258,7 +3258,7 @@ describe('plugin-meetings', () => {
           stateElementsMessage: message,
         });
 
-        assert.calledOnce(parserA.resume);
+        assert.calledOnce(parserA.resumeFromMessage);
         assert.calledOnce(parserB.stop);
       });
 
@@ -3281,7 +3281,7 @@ describe('plugin-meetings', () => {
           stateElementsMessage: message,
         });
 
-        assert.notCalled(parserA.resume);
+        assert.notCalled(parserA.resumeFromMessage);
         assert.notCalled(parserB.stop);
       });
 
@@ -3300,7 +3300,7 @@ describe('plugin-meetings', () => {
           stateElementsMessage: message,
         });
 
-        assert.notCalled(parserA.resume);
+        assert.notCalled(parserA.resumeFromMessage);
         assert.notCalled(parserA.handleMessage);
       });
 
@@ -3453,6 +3453,156 @@ describe('plugin-meetings', () => {
         assert.calledOnce(locusInfo.sendClassicVsHashTreeMismatchMetric);
         assert.calledOnce(mockHashTreeParser.handleLocusUpdate);
       });
+
+      describe('parser switch via API response', () => {
+        const deviceUrl = 'http://device-url.com';
+        const locusUrlA = 'http://locus-url-A.com';
+        const locusUrlB = 'http://locus-url-B.com';
+
+        let HashTreeParserStub;
+
+        const createMockApiParser = (state = 'active') => ({
+          state,
+          stop: sinon.stub(),
+          resumeFromApiResponse: sinon.stub(),
+          handleLocusUpdate: sinon.stub(),
+          initializeFromGetLociResponse: sinon.stub(),
+        });
+
+        const createLocusWithReplaces = (url, replacedLocusUrl, replacedAt) => ({
+          url,
+          self: {
+            devices: [{url: deviceUrl, replaces: [{locusUrl: replacedLocusUrl, replacedAt}]}],
+          },
+        });
+
+        const createLocusWithoutReplaces = (url) => ({
+          url,
+          self: {devices: [{url: deviceUrl}]},
+        });
+
+        beforeEach(() => {
+          locusInfo.webex.internal.device.url = deviceUrl;
+          HashTreeParserStub = sinon
+            .stub(HashTreeParserModule, 'default')
+            .returns(createMockApiParser());
+        });
+
+        it('should create a new parser and initialize it when no entry exists for the locusUrl', () => {
+          // existing parser for a different url so hashTreeParsers.size > 0
+          locusInfo.hashTreeParsers.set(locusUrlA, {parser: createMockApiParser(), initializedFromHashTree: true});
+
+          const locus = createLocusWithReplaces(locusUrlB, locusUrlA, '2026-01-01T00:00:00Z');
+          sinon.stub(locusInfo, 'handleLocusDelta');
+
+          locusInfo.handleLocusAPIResponse(mockMeeting, {locus});
+
+          assert.isTrue(locusInfo.hashTreeParsers.has(locusUrlB));
+          const newEntry = locusInfo.hashTreeParsers.get(locusUrlB);
+          assert.isFalse(newEntry.initializedFromHashTree);
+
+          // the stub returns the mock, so initializeFromGetLociResponse should be called on it
+          const createdParser = HashTreeParserStub.returnValues[0];
+          assert.calledOnceWithExactly(createdParser.initializeFromGetLociResponse, locus);
+          assert.notCalled(locusInfo.handleLocusDelta);
+        });
+
+        it('should reactivate a stopped parser when replaces info is newer', () => {
+          const parserA = createMockApiParser('stopped');
+          const parserB = createMockApiParser('active');
+          locusInfo.hashTreeParsers.set(locusUrlA, {parser: parserA, replacedAt: '2026-01-01T00:00:00Z', initializedFromHashTree: true});
+          locusInfo.hashTreeParsers.set(locusUrlB, {parser: parserB, initializedFromHashTree: true});
+
+          const locus = createLocusWithReplaces(locusUrlA, locusUrlB, '2026-02-01T00:00:00Z');
+
+          locusInfo.handleLocusAPIResponse(mockMeeting, {locus});
+
+          assert.calledOnce(parserA.resumeFromApiResponse);
+          assert.calledWithExactly(parserA.resumeFromApiResponse, locus);
+          assert.calledOnce(parserB.stop);
+          assert.equal(locusInfo.hashTreeParsers.get(locusUrlB).replacedAt, '2026-02-01T00:00:00Z');
+          assert.isFalse(locusInfo.hashTreeParsers.get(locusUrlA).initializedFromHashTree);
+        });
+
+        it('should not reactivate a stopped parser when replaces info is not newer', () => {
+          const parserA = createMockApiParser('stopped');
+          const parserB = createMockApiParser('active');
+          locusInfo.hashTreeParsers.set(locusUrlA, {parser: parserA, replacedAt: '2026-03-01T00:00:00Z', initializedFromHashTree: true});
+          locusInfo.hashTreeParsers.set(locusUrlB, {parser: parserB, initializedFromHashTree: true});
+
+          const locus = createLocusWithReplaces(locusUrlA, locusUrlB, '2026-01-01T00:00:00Z');
+
+          locusInfo.handleLocusAPIResponse(mockMeeting, {locus});
+
+          assert.notCalled(parserA.resumeFromApiResponse);
+          assert.notCalled(parserB.stop);
+        });
+
+        it('should not reactivate a stopped parser when no replaces info is available', () => {
+          const parserA = createMockApiParser('stopped');
+          locusInfo.hashTreeParsers.set(locusUrlA, {parser: parserA, initializedFromHashTree: true});
+
+          const locus = createLocusWithoutReplaces(locusUrlA);
+
+          locusInfo.handleLocusAPIResponse(mockMeeting, {locus});
+
+          assert.notCalled(parserA.resumeFromApiResponse);
+        });
+      });
+    });
+
+    describe('#syncAllHashTreeDatasets', () => {
+      it('should call syncAllDatasets on each parser that has an entry', async () => {
+        const parser1 = {syncAllDatasets: sinon.stub().resolves()};
+        const parser2 = {syncAllDatasets: sinon.stub().resolves()};
+        locusInfo.hashTreeParsers.set('url1', {parser: parser1});
+        locusInfo.hashTreeParsers.set('url2', {parser: parser2});
+
+        await locusInfo.syncAllHashTreeDatasets();
+
+        assert.calledOnce(parser1.syncAllDatasets);
+        assert.calledOnce(parser2.syncAllDatasets);
+      });
+
+      it('should skip parser entries without a parser object', async () => {
+        const parser1 = {syncAllDatasets: sinon.stub().resolves()};
+        locusInfo.hashTreeParsers.set('url1', {parser: parser1});
+        locusInfo.hashTreeParsers.set('url2', {parser: undefined});
+
+        await locusInfo.syncAllHashTreeDatasets();
+
+        assert.calledOnce(parser1.syncAllDatasets);
+      });
+
+      it('should await each parsers syncAllDatasets sequentially', async () => {
+        const callOrder = [];
+        const parser1 = {syncAllDatasets: sinon.stub().callsFake(() => {
+          callOrder.push('start1');
+          return new Promise((resolve) => {
+            setTimeout(() => {
+              callOrder.push('end1');
+              resolve();
+            }, 100);
+          });
+        })};
+        const parser2 = {syncAllDatasets: sinon.stub().callsFake(() => {
+          callOrder.push('start2');
+          return Promise.resolve();
+        })};
+        locusInfo.hashTreeParsers.set('url1', {parser: parser1});
+        locusInfo.hashTreeParsers.set('url2', {parser: parser2});
+
+        const clock = sinon.useFakeTimers();
+        const promise = locusInfo.syncAllHashTreeDatasets();
+        // parser1 started but parser2 not yet
+        assert.deepEqual(callOrder, ['start1']);
+
+        await clock.tickAsync(100);
+        await promise;
+        // parser1 finished, then parser2 started and finished
+        assert.deepEqual(callOrder, ['start1', 'end1', 'start2']);
+        clock.restore();
+      });
     });
 
     describe('#LocusDeltaEvents', () => {
@@ -5001,6 +5151,31 @@ describe('plugin-meetings', () => {
         );
         assert.notCalled(getTheLocusToUpdateStub);
       });
+
+      it('should call handleLocusAPIResponse for SDK_LOCUS_FROM_SYNC_MEETINGS when hash tree parsers exist', () => {
+        const fakeLocusUrl = 'http://locus-url.com';
+        const fakeLocus = {url: fakeLocusUrl, fullState: {state: 'ACTIVE'}};
+        const mockHashTreeParser = {
+          handleMessage: sinon.stub(),
+          handleLocusUpdate: sinon.stub(),
+        };
+        locusInfo.hashTreeParsers.set(fakeLocusUrl, {
+          parser: mockHashTreeParser,
+          initializedFromHashTree: true,
+        });
+
+        sinon.stub(locusInfo, 'handleLocusDelta');
+
+        locusInfo.parse(mockMeeting, {
+          eventType: LOCUSEVENT.SDK_LOCUS_FROM_SYNC_MEETINGS,
+          locus: fakeLocus,
+        });
+
+        // should route through handleLocusAPIResponse which passes unwrapped LocusDTO to parser
+        assert.calledOnce(mockHashTreeParser.handleLocusUpdate);
+        assert.notCalled(mockHashTreeParser.handleMessage);
+        assert.notCalled(locusInfo.handleLocusDelta);
+      });
     });
   });
 

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

@@ -91,6 +91,7 @@ describe('plugin-meetings', () => {
       locusInfo = {
         parse: sinon.stub().returns(true),
         updateMainSessionLocusCache: sinon.stub(),
+        syncAllHashTreeDatasets: sinon.stub(),
       };
       webex = new MockWebex({
         children: {
@@ -1391,7 +1392,7 @@ describe('plugin-meetings', () => {
         it('should have #syncMeetings', () => {
           assert.exists(webex.meetings.syncMeetings);
         });
-        it('should do nothing and return a resolved promise if unverified guest', async () => {
+        it('should skip getActiveMeetings but still call syncAllHashTreeDatasets if unverified guest', async () => {
           webex.meetings.request.getActiveMeetings = sinon.stub().returns(
             Promise.resolve({
               loci: [
@@ -1404,13 +1405,23 @@ describe('plugin-meetings', () => {
           webex.credentials.isUnverifiedGuest = true;
           LoggerProxy.logger.info = sinon.stub();
 
+          const mockLocusInfo = {
+            syncAllHashTreeDatasets: sinon.stub().resolves(),
+          };
+          webex.meetings.meetingCollection.getAll = sinon.stub().returns({
+            meeting1: {locusInfo: mockLocusInfo},
+            meeting2: {locusInfo: undefined},
+            meeting3: {},
+          });
+
           await webex.meetings.syncMeetings();
 
           assert.notCalled(webex.meetings.request.getActiveMeetings);
           assert.calledWith(
             LoggerProxy.logger.info,
-            'Meetings:index#syncMeetings --> skipping meeting sync as unverified guest'
+            'Meetings:index#syncMeetings --> user is unverified guest, skipping calling Locus for meeting sync'
           );
+          assert.calledOnce(mockLocusInfo.syncAllHashTreeDatasets);
         });
         describe('succesful requests', () => {
           beforeEach(() => {
@@ -1429,6 +1440,9 @@ describe('plugin-meetings', () => {
               webex.meetings.meetingCollection.getByKey = sinon.stub().returns({
                 locusInfo,
               });
+              webex.meetings.meetingCollection.getAll = sinon.stub().returns({
+                meeting1: {locusInfo, locusUrl: url1},
+              });
             });
             it('tests the sync meeting calls for existing meeting', async () => {
               await webex.meetings.syncMeetings();
@@ -1436,6 +1450,7 @@ describe('plugin-meetings', () => {
               assert.calledOnce(webex.meetings.meetingCollection.getByKey);
               assert.calledOnce(locusInfo.parse);
               assert.calledWith(webex.meetings.meetingCollection.getByKey, 'locusUrl', url1);
+              assert.calledOnce(locusInfo.syncAllHashTreeDatasets);
             });
           });
           describe('when meeting is not returned', () => {
@@ -1520,7 +1535,7 @@ describe('plugin-meetings', () => {
             it('destroy any meeting that has no active locus url if keepOnlyLocusMeetings is not defined', async () => {
               await webex.meetings.syncMeetings();
               assert.calledOnce(webex.meetings.request.getActiveMeetings);
-              assert.calledOnce(webex.meetings.meetingCollection.getAll);
+              assert.calledTwice(webex.meetings.meetingCollection.getAll);
               assert.calledWith(destroySpy, meetingCollectionMeetings.noLongerValidLocusMeeting);
               assert.calledWith(destroySpy, meetingCollectionMeetings.otherNonLocusMeeting1);
               assert.calledWith(destroySpy, meetingCollectionMeetings.otherNonLocusMeeting2);
@@ -1532,7 +1547,7 @@ describe('plugin-meetings', () => {
             it('destroy any meeting that has no active locus url if keepOnlyLocusMeetings === true', async () => {
               await webex.meetings.syncMeetings({keepOnlyLocusMeetings: true});
               assert.calledOnce(webex.meetings.request.getActiveMeetings);
-              assert.calledOnce(webex.meetings.meetingCollection.getAll);
+              assert.calledTwice(webex.meetings.meetingCollection.getAll);
               assert.calledWith(destroySpy, meetingCollectionMeetings.noLongerValidLocusMeeting);
               assert.calledWith(destroySpy, meetingCollectionMeetings.otherNonLocusMeeting1);
               assert.calledWith(destroySpy, meetingCollectionMeetings.otherNonLocusMeeting2);
@@ -1544,7 +1559,7 @@ describe('plugin-meetings', () => {
             it('destroy any LOCUS meetings that have no active locus url if keepOnlyLocusMeetings === false', async () => {
               await webex.meetings.syncMeetings({keepOnlyLocusMeetings: false});
               assert.calledOnce(webex.meetings.request.getActiveMeetings);
-              assert.calledOnce(webex.meetings.meetingCollection.getAll);
+              assert.calledTwice(webex.meetings.meetingCollection.getAll);
               assert.calledWith(destroySpy, meetingCollectionMeetings.noLongerValidLocusMeeting);
               assert.callCount(destroySpy, 1);
 
@@ -1552,6 +1567,113 @@ describe('plugin-meetings', () => {
             });
           });
         });
+
+        describe('when globalMeetingId preserves breakout meetings', () => {
+          let destroySpy;
+          let cleanUpSpy;
+
+          beforeEach(() => {
+            destroySpy = sinon.spy(webex.meetings, 'destroy');
+            cleanUpSpy = sinon.stub(MeetingUtil, 'cleanUp').returns(Promise.resolve());
+          });
+
+          afterEach(() => {
+            cleanUpSpy.restore();
+          });
+
+          it('should not destroy a meeting whose globalMeetingId matches an active locus', async () => {
+            const meetingCollectionMeetings = {
+              breakoutMeeting: {
+                locusUrl: 'breakout-url',
+                locusInfo: {
+                  info: {globalMeetingId: 'gmid-123'},
+                  syncAllHashTreeDatasets: sinon.stub().resolves(),
+                },
+                sendCallAnalyzerMetrics: sinon.stub(),
+              },
+            };
+
+            webex.meetings.meetingCollection.getAll = sinon
+              .stub()
+              .returns(meetingCollectionMeetings);
+            webex.meetings.request.getActiveMeetings = sinon.stub().resolves({
+              loci: [{url: 'main-url', info: {globalMeetingId: 'gmid-123'}}],
+            });
+
+            await webex.meetings.syncMeetings();
+
+            assert.notCalled(destroySpy);
+          });
+
+          it('should destroy a meeting whose globalMeetingId does NOT match any active locus', async () => {
+            const meetingCollectionMeetings = {
+              breakoutMeeting: {
+                locusUrl: 'breakout-url',
+                locusInfo: {
+                  info: {globalMeetingId: 'gmid-other'},
+                  syncAllHashTreeDatasets: sinon.stub().resolves(),
+                },
+                sendCallAnalyzerMetrics: sinon.stub(),
+              },
+            };
+
+            webex.meetings.meetingCollection.getAll = sinon
+              .stub()
+              .returns(meetingCollectionMeetings);
+            webex.meetings.request.getActiveMeetings = sinon.stub().resolves({
+              loci: [{url: 'main-url', info: {globalMeetingId: 'gmid-123'}}],
+            });
+
+            await webex.meetings.syncMeetings();
+
+            assert.calledOnce(destroySpy);
+            assert.calledWith(destroySpy, meetingCollectionMeetings.breakoutMeeting);
+          });
+        });
+
+        describe('syncAllHashTreeDatasets in syncMeetings', () => {
+          it('should call syncAllHashTreeDatasets for multiple meetings, skipping those without locusInfo', async () => {
+            const mockLocusInfo1 = {
+              syncAllHashTreeDatasets: sinon.stub().resolves(),
+            };
+            const mockLocusInfo2 = {
+              syncAllHashTreeDatasets: sinon.stub().resolves(),
+            };
+
+            webex.meetings.request.getActiveMeetings = sinon.stub().resolves({loci: []});
+            webex.meetings.meetingCollection.getAll = sinon.stub().returns({
+              meeting1: {locusInfo: mockLocusInfo1},
+              meeting2: {locusInfo: undefined},
+              meeting3: {locusInfo: mockLocusInfo2},
+              meeting4: {},
+            });
+
+            await webex.meetings.syncMeetings({keepOnlyLocusMeetings: false});
+
+            assert.calledOnce(mockLocusInfo1.syncAllHashTreeDatasets);
+            assert.calledOnce(mockLocusInfo2.syncAllHashTreeDatasets);
+          });
+
+          it('should not call syncAllHashTreeDatasets when getActiveMeetings throws an error', async () => {
+            const mockLocusInfo = {
+              syncAllHashTreeDatasets: sinon.stub().resolves(),
+            };
+
+            webex.meetings.request.getActiveMeetings = sinon.stub().rejects(new Error('network error'));
+            webex.meetings.meetingCollection.getAll = sinon.stub().returns({
+              meeting1: {locusInfo: mockLocusInfo},
+            });
+
+            try {
+              await webex.meetings.syncMeetings();
+              assert.fail('should have thrown');
+            } catch (err) {
+              assert.equal(err.message, 'network error');
+            }
+
+            assert.notCalled(mockLocusInfo.syncAllHashTreeDatasets);
+          });
+        });
       });
       describe('#fetchStaticMeetingLink', () => {
         const conversationUrl = 'conv.fakeconversationurl.com';