@webex/plugin-meetings 3.12.0-next.4 → 3.12.0-next.40

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: {
@@ -1285,10 +1286,10 @@ describe('plugin-meetings', () => {
           assert.exists(result.dispose);
         });
 
-        it('creates noise reduction effect with ST model', async () => {
+        it('creates noise reduction effect with OFMV model', async () => {
           const result = await webex.meetings.createNoiseReductionEffect({
             audioContext: {},
-            model: 'st',
+            model: 'ofmv',
           });
 
           assert.exists(result);
@@ -1300,7 +1301,7 @@ describe('plugin-meetings', () => {
             authToken: 'fake_token',
             mode: 'WORKLET',
             avoidSimd: false,
-            model: 'st',
+            model: 'ofmv',
           });
           assert.exists(result.enable);
           assert.exists(result.disable);
@@ -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', () => {
@@ -1474,7 +1489,7 @@ describe('plugin-meetings', () => {
                   url: url1,
                 },
                 hashTreeMessage: undefined,
-              });
+              }, sinon.match.func);
             });
           });
           describe('when destroying meeting is needed', () => {
@@ -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';
@@ -2015,7 +2137,7 @@ describe('plugin-meetings', () => {
                 },
               },
               hashTreeMessage: undefined,
-            });
+            }, sinon.match.func);
           });
           it('should setup the meeting from a hash tree event', async () => {
             const selfData = {};
@@ -2049,7 +2171,7 @@ describe('plugin-meetings', () => {
                 info: infoData,
               },
               hashTreeMessage,
-            });
+            }, sinon.match.func);
           });
 
           it('should ignore hash tree event when created locus has INACTIVE fullState', async () => {
@@ -2129,7 +2251,7 @@ describe('plugin-meetings', () => {
                 },
               },
               hashTreeMessage: undefined,
-            });
+            }, sinon.match.func);
           });
 
           it('sends client event correctly on finally', async () => {
@@ -2205,7 +2327,7 @@ describe('plugin-meetings', () => {
                 },
               },
               hashTreeMessage: undefined,
-            });
+            }, sinon.match.func);
           });
 
           const generateFakeLocusData = (isUnifiedSpaceMeeting) => ({
@@ -2833,6 +2955,39 @@ describe('plugin-meetings', () => {
             checkCreateMeetingWithNoMeetingInfo(true, true);
           });
 
+          it('does not emit meeting:added when meeting is destroyed due to missing meeting info', async () => {
+            // Make destroy actually remove the meeting from the collection
+            // so that getMeetingByType returns null in the finally block
+            webex.meetings.destroy = sinon.stub().callsFake((meeting) => {
+              webex.meetings.meetingCollection.delete(meeting.id);
+            });
+
+            try {
+              await webex.meetings.createMeeting(
+                'test destination',
+                'test type',
+                undefined,
+                undefined,
+                undefined,
+                true
+              );
+              assert.fail('should have thrown NoMeetingInfoError');
+            } catch (err) {
+              assert.instanceOf(err, NoMeetingInfoError);
+            }
+
+            assert.calledOnce(webex.meetings.destroy);
+
+            // meeting:added should NOT have been triggered since the meeting was destroyed
+            assert.neverCalledWith(
+              TriggerProxy.trigger,
+              sinon.match.any,
+              sinon.match({function: 'createMeeting'}),
+              'meeting:added',
+              sinon.match.any
+            );
+          });
+
           it('creates the meeting avoiding meeting info fetch by passing type as DESTINATION_TYPE.ONE_ON_ONE_CALL', async () => {
             const meeting = await webex.meetings.createMeeting(
               'test destination',
@@ -3426,6 +3581,21 @@ describe('plugin-meetings', () => {
           'Meetings:index#isNeedHandleMainLocus --> self device left&moved in main locus with self joined status, not need to handle'
         );
       });
+
+      it('check breakout ended with self removed, return false', () => {
+        webex.meetings.meetingCollection.getActiveBreakoutLocus = sinon.stub().returns(null);
+        newLocus.self.state = 'LEFT';
+        newLocus.self.reason = 'OTHER';
+        newLocus.self.removed = true;
+        newLocus.fullState = {state: 'INACTIVE', endMeetingReason: 'BREAKOUT_ENDED'};
+        LoggerProxy.logger.log = sinon.stub();
+        const result = webex.meetings.isNeedHandleMainLocus(meeting, newLocus);
+        assert.equal(result, false);
+        assert.calledWith(
+          LoggerProxy.logger.log,
+          'Meetings:index#isNeedHandleMainLocus --> self moved main locus with self removed status or with device resource moved, not need to handle'
+        );
+      });
     });
 
     describe('#isNeedHandleLocusDTO', () => {
@@ -3486,6 +3656,18 @@ describe('plugin-meetings', () => {
         const result = webex.meetings.isNeedHandleLocusDTO(meeting, newLocus);
         assert.equal(result, false);
       });
+      it('breakout session with breakout ended, return false', () => {
+        newLocus.controls.breakout = {
+          sessionType: 'BREAKOUT',
+        };
+        newLocus.self.state = 'LEFT';
+        newLocus.self.reason = 'OTHER';
+        newLocus.self.devices = [];
+        newLocus.fullState = {state: 'INACTIVE', endMeetingReason: 'BREAKOUT_ENDED'};
+        LoggerProxy.logger.log = sinon.stub();
+        const result = webex.meetings.isNeedHandleLocusDTO(meeting, newLocus);
+        assert.equal(result, false);
+      });
       it('moved to lobby, return true', () => {
         newLocus.controls.breakout = {
           sessionType: 'MAIN',

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

@@ -128,6 +128,143 @@ describe('plugin-meetings', () => {
         };
         assert.equal(MeetingsUtil.isBreakoutLocusDTO(newLocus), false);
       });
+
+      it('returns true if newLocus.info.isBreakout is true', () => {
+        const newLocus = {
+          info: {
+            isBreakout: true,
+          },
+        };
+        assert.equal(MeetingsUtil.isBreakoutLocusDTO(newLocus), true);
+      });
+
+      it('returns false if newLocus.info.isBreakout is false', () => {
+        const newLocus = {
+          info: {
+            isBreakout: false,
+          },
+        };
+        assert.equal(MeetingsUtil.isBreakoutLocusDTO(newLocus), false);
+      });
+
+      it('returns true if both sessionType is BREAKOUT and info.isBreakout is true', () => {
+        const newLocus = {
+          controls: {
+            breakout: {
+              sessionType: 'BREAKOUT',
+            },
+          },
+          info: {
+            isBreakout: true,
+          },
+        };
+        assert.equal(MeetingsUtil.isBreakoutLocusDTO(newLocus), true);
+      });
+    });
+
+    describe('#isMainAssociatedWithBreakout', () => {
+      it('returns true when breakout control url matches main locus breakout url', () => {
+        const mainLocus = {
+          url: 'main-locus-url',
+          controls: {
+            breakout: {
+              url: 'breakout-control-url',
+            },
+          },
+        };
+        const breakoutLocus = {
+          controls: {
+            breakout: {
+              url: 'breakout-control-url',
+            },
+          },
+        };
+
+        assert.equal(MeetingsUtil.isMainAssociatedWithBreakout(mainLocus, breakoutLocus), true);
+      });
+
+      it('returns true when breakout self device replaces the main locus url', () => {
+        const mainLocus = {
+          url: 'main-locus-url',
+          controls: {},
+        };
+        const breakoutLocus = {
+          controls: {
+            breakout: {
+              url: 'other-breakout-url',
+            },
+          },
+          self: {
+            deviceUrl: 'device-url-1',
+            devices: [
+              {
+                url: 'device-url-1',
+                replaces: [{locusUrl: 'main-locus-url'}],
+              },
+            ],
+          },
+        };
+
+        assert.equal(MeetingsUtil.isMainAssociatedWithBreakout(mainLocus, breakoutLocus), true);
+      });
+
+      it('returns false when breakout locus is not associated with the main locus', () => {
+        const mainLocus = {
+          url: 'main-locus-url',
+          controls: {
+            breakout: {
+              url: 'breakout-control-url',
+            },
+          },
+        };
+        const breakoutLocus = {
+          controls: {
+            breakout: {
+              url: 'different-breakout-url',
+            },
+          },
+          self: {
+            deviceUrl: 'device-url-1',
+            devices: [
+              {
+                url: 'device-url-1',
+                replaces: [{locusUrl: 'another-main-locus-url'}],
+              },
+            ],
+          },
+        };
+
+        assert.equal(MeetingsUtil.isMainAssociatedWithBreakout(mainLocus, breakoutLocus), false);
+      });
+    });
+
+    describe('#isWholeMeetingEnded', () => {
+      [
+        {description: 'state is INACTIVE with no endMeetingReason', fullState: {state: 'INACTIVE'}, expected: true},
+        {description: 'state is INACTIVE with endMeetingReason OTHER', fullState: {state: 'INACTIVE', endMeetingReason: 'SOME_OTHER_REASON'}, expected: true},
+        {description: 'state is INACTIVE with endMeetingReason BREAKOUT_ENDED', fullState: {state: 'INACTIVE', endMeetingReason: 'BREAKOUT_ENDED'}, expected: false},
+        {description: 'state is not INACTIVE', fullState: {state: 'ACTIVE', endMeetingReason: 'SOME_OTHER_REASON'}, expected: false},
+      ].forEach(({description, fullState, expected}) => {
+        it(`returns ${expected} when ${description}`, () => {
+          assert.equal(MeetingsUtil.isWholeMeetingEnded(fullState), expected);
+        });
+      });
+    });
+
+    describe('#isSelfMovedOrBreakoutEnded', () => {
+      [
+        {description: 'locus is undefined', locus: undefined, expected: false},
+        {description: 'self state is JOINED', locus: {self: {state: 'JOINED', reason: 'OTHER'}}, expected: false},
+        {description: 'self state is LEFT with reason MOVED', locus: {self: {state: 'LEFT', reason: 'MOVED'}}, expected: true},
+        {description: 'fullState is INACTIVE with BREAKOUT_ENDED', locus: {self: {state: 'LEFT', reason: 'OTHER'}, fullState: {state: 'INACTIVE', endMeetingReason: 'BREAKOUT_ENDED'}}, expected: true},
+        {description: 'fullState is INACTIVE with different endMeetingReason', locus: {self: {state: 'LEFT', reason: 'OTHER'}, fullState: {state: 'INACTIVE', endMeetingReason: 'SOME_OTHER_REASON'}}, expected: false},
+        {description: 'fullState is missing', locus: {self: {state: 'LEFT', reason: 'OTHER'}}, expected: false},
+        {description: 'endMeetingReason is missing', locus: {self: {state: 'LEFT', reason: 'OTHER'}, fullState: {state: 'INACTIVE'}}, expected: false},
+      ].forEach(({description, locus, expected}) => {
+        it(`returns ${expected} when ${description}`, () => {
+          assert.equal(MeetingsUtil.isSelfMovedOrBreakoutEnded(locus), expected);
+        });
+      });
     });
 
     describe('#joinedOnThisDevice', () => {

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

@@ -59,6 +59,13 @@ describe('member', () => {
       assert.calledOnceWithExactly(MemberUtil.isPresenterAssignmentProhibited, participant);
     });
 
+    it('checks that processParticipant calls isAttendeeAssignmentProhibited', () => {
+      sinon.spy(MemberUtil, 'isAttendeeAssignmentProhibited');
+      member.processParticipant(participant);
+
+      assert.calledOnceWithExactly(MemberUtil.isAttendeeAssignmentProhibited, participant);
+    });
+
     it('checks that processParticipant calls canApproveAIEnablement', () => {
       sinon.spy(MemberUtil, 'canApproveAIEnablement');
       member.processParticipant(participant);

package/test/unit/spec/member/util.js

@@ -643,6 +643,30 @@ describe('plugin-meetings', () => {
       assert.isUndefined(MemberUtil.isPresenterAssignmentProhibited(participant));
     });
   });
+
+  describe('MemberUtil.isAttendeeAssignmentProhibited', () => {
+    it('returns true when attendeeAssignmentNotAllowed is true', () => {
+      const participant = {
+        attendeeAssignmentNotAllowed: true,
+      };
+
+      assert.isTrue(MemberUtil.isAttendeeAssignmentProhibited(participant));
+    });
+
+    it('returns false when attendeeAssignmentNotAllowed is false', () => {
+      const participant = {
+        attendeeAssignmentNotAllowed: false,
+      };
+
+      assert.isFalse(MemberUtil.isAttendeeAssignmentProhibited(participant));
+    });
+
+    it('returns false when attendeeAssignmentNotAllowed is undefined', () => {
+      const participant = {};
+
+      assert.isFalse(MemberUtil.isAttendeeAssignmentProhibited(participant));
+    });
+  });
 });
 
 describe('extractMediaStatus', () => {

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

@@ -33,6 +33,7 @@ describe('plugin-meetings', () => {
       webex.internal.llm = {
         getDatachannelToken: sinon.stub().returns(undefined),
         setDatachannelToken: sinon.stub(),
+        isDataChannelTokenEnabled: sinon.stub().resolves(false),
         isConnected: sinon.stub().returns(false),
         disconnectLLM: sinon.stub().resolves(),
         off: sinon.stub(),
@@ -267,6 +268,65 @@ describe('plugin-meetings', () => {
         webex.internal.voicea.updateSubchannelSubscriptions = sinon.stub();
       });
 
+      it('refreshes practice-session token before register when cached token is missing', async () => {
+        webex.internal.llm.isDataChannelTokenEnabled.resolves(true);
+        webex.internal.llm.getDatachannelToken = sinon.stub().callsFake((tokenType) => {
+          if (tokenType === DataChannelTokenType.PracticeSession) return undefined;
+
+          return undefined;
+        });
+        meeting.refreshDataChannelToken = sinon.stub().resolves({
+          body: {
+            datachannelToken: 'ps-token-from-refresh',
+            dataChannelTokenType: DataChannelTokenType.PracticeSession,
+          },
+        });
+
+        await webinar.updatePSDataChannel();
+
+        assert.calledOnceWithExactly(meeting.refreshDataChannelToken);
+        assert.calledWithExactly(
+          webex.internal.llm.setDatachannelToken,
+          'ps-token-from-refresh',
+          DataChannelTokenType.PracticeSession
+        );
+        assert.calledWith(
+          webex.internal.llm.registerAndConnect,
+          'locus-url',
+          'dc-url',
+          'ps-token-from-refresh',
+          LLM_PRACTICE_SESSION
+        );
+      });
+
+      it('does not reconnect if practice-session eligibility changes during async token refresh', async () => {
+        webex.internal.llm.isDataChannelTokenEnabled.resolves(true);
+        webex.internal.llm.getDatachannelToken = sinon.stub().returns(undefined);
+
+        let resolveRefresh;
+        meeting.refreshDataChannelToken = sinon.stub().returns(
+          new Promise((resolve) => {
+            resolveRefresh = resolve;
+          })
+        );
+
+        const updatePromise = webinar.updatePSDataChannel();
+
+        webinar.practiceSessionEnabled = false;
+
+        resolveRefresh({
+          body: {
+            datachannelToken: 'stale-ps-token',
+            dataChannelTokenType: DataChannelTokenType.PracticeSession,
+          },
+        });
+
+        const result = await updatePromise;
+
+        assert.isUndefined(result);
+        assert.notCalled(webex.internal.llm.registerAndConnect);
+      });
+
       it('no-ops when practice session join eligibility is false', async () => {
         webinar.practiceSessionEnabled = false;
         const cleanupPSDataChannelStub = sinon.stub(webinar, 'cleanupPSDataChannel').resolves();