@webex/plugin-meetings 3.12.0-next.8 → 3.12.0-task-refactor.1

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

@@ -425,10 +425,7 @@ describe('plugin-meetings', () => {
 
     describe('#_toggleStopIceGatheringAfterFirstRelayCandidate', () => {
       it('should have _toggleStopIceGatheringAfterFirstRelayCandidate', () => {
-        assert.equal(
-          typeof webex.meetings._toggleStopIceGatheringAfterFirstRelayCandidate,
-          'function'
-        );
+        assert.equal(typeof webex.meetings._toggleStopIceGatheringAfterFirstRelayCandidate, 'function');
       });
 
       describe('success', () => {
@@ -605,196 +602,6 @@ describe('plugin-meetings', () => {
 
           clock.restore();
         });
-
-        it('returns the same promise when register is called multiple times concurrently', async () => {
-          webex.canAuthorize = true;
-          webex.meetings.registered = false;
-
-          // Make registration take some time
-          let resolveRegistration;
-          const registrationDelay = new Promise((resolve) => {
-            resolveRegistration = resolve;
-          });
-
-          webex.internal.device.register.returns(registrationDelay);
-          webex.internal.mercury.connect.returns(Promise.resolve());
-
-          // Start first registration
-          const firstRegisterPromise = webex.meetings.register();
-
-          // Immediately start second registration while first is in progress
-          const secondRegisterPromise = webex.meetings.register();
-
-          // Start third registration
-          const thirdRegisterPromise = webex.meetings.register();
-
-          // All should return the same promise
-          assert.strictEqual(firstRegisterPromise, secondRegisterPromise);
-          assert.strictEqual(secondRegisterPromise, thirdRegisterPromise);
-
-          // Complete the registration
-          resolveRegistration();
-
-          await firstRegisterPromise;
-          await secondRegisterPromise;
-          await thirdRegisterPromise;
-
-          // Device registration and mercury connect should only be called once
-          assert.calledOnce(webex.internal.device.register);
-          assert.calledOnce(webex.internal.mercury.connect);
-          assert.isTrue(webex.meetings.registered);
-        });
-
-        it('prevents duplicate registrations when register is called during in-flight registration', async () => {
-          webex.canAuthorize = true;
-          webex.meetings.registered = false;
-
-          let deviceRegisterCallCount = 0;
-          let mercuryConnectCallCount = 0;
-
-          // Track actual calls
-          webex.internal.device.register = sinon.stub().callsFake(() => {
-            deviceRegisterCallCount++;
-            return Promise.resolve();
-          });
-          webex.internal.mercury.connect = sinon.stub().callsFake(() => {
-            mercuryConnectCallCount++;
-            return Promise.resolve();
-          });
-
-          // Start registration without awaiting
-          const promise1 = webex.meetings.register();
-
-          // Call register again while first is in progress
-          const promise2 = webex.meetings.register();
-
-          // Wait for both
-          await Promise.all([promise1, promise2]);
-
-          // Should only register once
-          assert.equal(deviceRegisterCallCount, 1, 'device.register should only be called once');
-          assert.equal(mercuryConnectCallCount, 1, 'mercury.connect should only be called once');
-          assert.isTrue(webex.meetings.registered);
-        });
-
-        it('handles concurrent register calls when first registration fails', async () => {
-          webex.canAuthorize = true;
-          webex.meetings.registered = false;
-
-          const registrationError = new Error('registration failed');
-          webex.internal.device.register.rejects(registrationError);
-
-          // Start first registration
-          const firstRegisterPromise = webex.meetings.register();
-
-          // Start second registration while first is in progress
-          const secondRegisterPromise = webex.meetings.register();
-
-          // Both should reject with the same error
-          await assert.isRejected(firstRegisterPromise, 'registration failed');
-          await assert.isRejected(secondRegisterPromise, 'registration failed');
-
-          // Should still only attempt registration once
-          assert.calledOnce(webex.internal.device.register);
-          assert.isFalse(webex.meetings.registered);
-        });
-
-        it('allows new registration after previous registration completes', async () => {
-          webex.canAuthorize = true;
-          webex.meetings.registered = false;
-
-          // First registration
-          await webex.meetings.register();
-          assert.isTrue(webex.meetings.registered);
-
-          // Reset for second registration
-          webex.meetings.registered = false;
-          webex.internal.device.register.resetHistory();
-          webex.internal.mercury.connect.resetHistory();
-
-          // Second registration should work normally
-          await webex.meetings.register();
-          assert.calledOnce(webex.internal.device.register);
-          assert.calledOnce(webex.internal.mercury.connect);
-          assert.isTrue(webex.meetings.registered);
-        });
-
-        it('clears registrationPromise after successful registration', async () => {
-          webex.canAuthorize = true;
-          webex.meetings.registered = false;
-
-          await webex.meetings.register();
-
-          assert.isTrue(webex.meetings.registered);
-          assert.isNull(webex.meetings.registrationPromise);
-        });
-
-        it('clears registrationPromise after failed registration', async () => {
-          webex.canAuthorize = true;
-          webex.meetings.registered = false;
-
-          webex.internal.device.register.rejects(new Error('registration failed'));
-
-          await assert.isRejected(webex.meetings.register());
-
-          assert.isFalse(webex.meetings.registered);
-          assert.isNull(webex.meetings.registrationPromise);
-        });
-
-        it('waits for unregistration to complete before registering', async () => {
-          webex.canAuthorize = true;
-
-          assert.isFalse(webex.meetings.registered);
-
-          // First, register successfully
-          await webex.meetings.register();
-          assert.isTrue(webex.meetings.registered);
-
-          // Start unregistration (but don't await it)
-          const unregisterPromise = webex.meetings.unregister();
-          assert.isDefined(webex.meetings.unregistrationPromise);
-
-          // Immediately try to register while unregister is in progress
-          const registerPromise = webex.meetings.register();
-
-          // Wait for register to complete
-          await registerPromise;
-
-          // Should have completed registration
-          assert.isTrue(webex.meetings.registered);
-
-          // Now await the original unregister promise - this should have already completed
-          // and should NOT affect the registered state since register() took over
-          await unregisterPromise;
-
-          // Should STILL be registered because register() took over
-          assert.isTrue(webex.meetings.registered);
-        });
-
-        it('handles multiple register calls during unregistration', async () => {
-          webex.canAuthorize = true;
-
-          // First, register successfully
-          await webex.meetings.register();
-          assert.isTrue(webex.meetings.registered);
-
-          // Start unregistration
-          const unregistrationPromise = webex.meetings.unregister();
-
-          // Try to register once while unregister is in progress
-          await webex.meetings.register();
-
-          // Should be registered again
-          assert.isTrue(
-            webex.meetings.registered,
-            'Expected meetings to be registered after unregister and register cycle'
-          );
-
-          await unregistrationPromise;
-
-          // Should STILL be registered because register() took over
-          assert.isTrue(webex.meetings.registered);
-        });
       });
 
       describe('#unregister', () => {
@@ -815,18 +622,6 @@ describe('plugin-meetings', () => {
           });
         });
 
-        it('calls mercury.disconnect with code 3050 and reason to prevent auto-reconnect', (done) => {
-          webex.meetings.registered = true;
-          webex.meetings.unregister().then(() => {
-            assert.calledOnce(webex.internal.mercury.disconnect);
-            assert.calledWith(webex.internal.mercury.disconnect, {
-              code: 3050,
-              reason: 'meetings unregister',
-            });
-            done();
-          });
-        });
-
         it('rejects when device.unregister fails', async () => {
           webex.meetings.registered = true;
           webex.internal.device.unregister = sinon.stub().returns(Promise.reject());
@@ -875,335 +670,6 @@ describe('plugin-meetings', () => {
             done();
           });
         });
-
-        it('waits for registration to complete before unregistering when called during registration', async () => {
-          webex.canAuthorize = true;
-          webex.meetings.registered = false;
-
-          let resolveRegistration;
-          const registrationDelay = new Promise((resolve) => {
-            resolveRegistration = resolve;
-          });
-
-          webex.internal.device.register.returns(registrationDelay);
-          webex.internal.mercury.connect.returns(Promise.resolve());
-
-          // Start registration (don't await)
-          const registerPromise = webex.meetings.register();
-
-          // Verify registration is in progress
-          assert.exists(webex.meetings.registrationPromise);
-          assert.isFalse(webex.meetings.registered);
-
-          // Call unregister while registration is in progress
-          const unregisterPromise = webex.meetings.unregister();
-
-          // Registration should still be in progress
-          assert.exists(webex.meetings.registrationPromise);
-
-          // Complete the registration
-          resolveRegistration();
-          await registerPromise;
-
-          // Now unregister should proceed
-          await unregisterPromise;
-
-          // Verify final state
-          assert.isFalse(webex.meetings.registered);
-          assert.isNull(webex.meetings.registrationPromise);
-          assert.calledOnce(webex.internal.device.unregister);
-          assert.calledOnce(webex.internal.mercury.disconnect);
-        });
-
-        it('handles unregister called during registration that fails', async () => {
-          webex.canAuthorize = true;
-          webex.meetings.registered = false;
-
-          const registrationError = new Error('registration failed');
-          let rejectRegistration;
-          const registrationDelay = new Promise((resolve, reject) => {
-            rejectRegistration = reject;
-          });
-
-          webex.internal.device.register.returns(registrationDelay);
-
-          // Start registration (don't await)
-          const registerPromise = webex.meetings.register();
-
-          // Call unregister while registration is in progress
-          const unregisterPromise = webex.meetings.unregister();
-
-          // Fail the registration
-          rejectRegistration(registrationError);
-
-          // Registration should fail
-          await assert.isRejected(registerPromise, 'registration failed');
-
-          // // Unregister should resolve immediately since registration failed
-          await unregisterPromise;
-
-          // Verify final state - not registered
-          assert.isFalse(webex.meetings.registered);
-          assert.isNull(webex.meetings.registrationPromise);
-          // Device unregister should not be called because registration never completed
-          assert.notCalled(webex.internal.device.unregister);
-        });
-
-        it('handles multiple unregister calls during registration', async () => {
-          webex.canAuthorize = true;
-          webex.meetings.registered = false;
-
-          let resolveRegistration;
-          const registrationDelay = new Promise((resolve) => {
-            resolveRegistration = resolve;
-          });
-
-          webex.internal.device.register.returns(registrationDelay);
-          webex.internal.mercury.connect.returns(Promise.resolve());
-
-          // Start registration
-          const registerPromise = webex.meetings.register();
-
-          // Call unregister multiple times while registration is in progress
-          const unregisterPromise1 = webex.meetings.unregister();
-          const unregisterPromise2 = webex.meetings.unregister();
-          const unregisterPromise3 = webex.meetings.unregister();
-
-          // Complete registration
-          resolveRegistration();
-          await registerPromise;
-
-          // All unregister calls should complete
-          await Promise.all([unregisterPromise1, unregisterPromise2, unregisterPromise3]);
-
-          // Verify final state
-          assert.isFalse(webex.meetings.registered);
-          // Disconnect and unregister should be called, but not multiple times
-          assert.calledOnce(webex.internal.mercury.disconnect);
-          assert.calledOnce(webex.internal.device.unregister);
-        });
-
-        it('completes unregister correctly after waiting for registration', async () => {
-          webex.canAuthorize = true;
-          webex.meetings.registered = false;
-
-          const stopListeningForEventsSpy = sinon.spy(webex.meetings, 'stopListeningForEvents');
-
-          let resolveRegistration;
-          const registrationDelay = new Promise((resolve) => {
-            resolveRegistration = resolve;
-          });
-
-          webex.internal.device.register.returns(registrationDelay);
-          webex.internal.mercury.connect.returns(Promise.resolve());
-
-          // Start registration
-          const registerPromise = webex.meetings.register();
-
-          // Call unregister during registration
-          const unregisterPromise = webex.meetings.unregister();
-
-          // stopListeningForEvents should not be called yet
-          assert.notCalled(stopListeningForEventsSpy);
-
-          // Complete registration
-          resolveRegistration();
-          await registerPromise;
-
-          // After registration completes, the meetings plugin should be registered
-          assert.isTrue(webex.meetings.registered);
-
-          // Now unregister should proceed
-          await unregisterPromise;
-
-          // Verify unregister completed properly
-          assert.calledOnce(stopListeningForEventsSpy);
-          assert.calledOnce(webex.internal.mercury.disconnect);
-          assert.calledOnce(webex.internal.device.unregister);
-          assert.isFalse(webex.meetings.registered);
-          assert.deepEqual(webex.meetings.registrationStatus, INITIAL_REGISTRATION_STATUS);
-        });
-
-        it('logs appropriate message when unregister is called during registration', async () => {
-          webex.canAuthorize = true;
-          webex.meetings.registered = false;
-
-          const loggerSpy = sinon.spy(LoggerProxy.logger, 'info');
-
-          let resolveRegistration;
-          const registrationDelay = new Promise((resolve) => {
-            resolveRegistration = resolve;
-          });
-
-          webex.internal.device.register.returns(registrationDelay);
-          webex.internal.mercury.connect.returns(Promise.resolve());
-
-          // Start registration
-          const registerPromise = webex.meetings.register();
-
-          // Call unregister during registration
-          const unregisterPromise = webex.meetings.unregister();
-
-          // Should log that it's waiting
-          assert.calledWith(
-            loggerSpy,
-            'Meetings:index#unregister --> INFO, Meetings plugin registration in progress, waiting to unregister'
-          );
-
-          // Complete registration and unregistration
-          resolveRegistration();
-          await registerPromise;
-          await unregisterPromise;
-
-          loggerSpy.restore();
-        });
-
-        it('returns the same promise when unregister is called multiple times concurrently', async () => {
-          webex.meetings.registered = true;
-
-          // Make unregistration take some time
-          let resolveUnregistration;
-          const unregistrationDelay = new Promise((resolve) => {
-            resolveUnregistration = resolve;
-          });
-
-          webex.internal.mercury.disconnect.returns(unregistrationDelay);
-          webex.internal.device.unregister.returns(Promise.resolve());
-
-          // Start first unregistration
-          const firstUnregisterPromise = webex.meetings.unregister();
-
-          // Immediately start second unregistration while first is in progress
-          const secondUnregisterPromise = webex.meetings.unregister();
-
-          // Start third unregistration
-          const thirdUnregisterPromise = webex.meetings.unregister();
-
-          // All should return the same promise
-          assert.strictEqual(firstUnregisterPromise, secondUnregisterPromise);
-          assert.strictEqual(secondUnregisterPromise, thirdUnregisterPromise);
-
-          // Complete the unregistration
-          resolveUnregistration();
-
-          await firstUnregisterPromise;
-          await secondUnregisterPromise;
-          await thirdUnregisterPromise;
-
-          // Mercury disconnect and device unregister should only be called once
-          assert.calledOnce(webex.internal.mercury.disconnect);
-          assert.calledOnce(webex.internal.device.unregister);
-          assert.isFalse(webex.meetings.registered);
-        });
-
-        it('clears unregistrationPromise after successful unregistration', async () => {
-          webex.meetings.registered = true;
-
-          await webex.meetings.unregister();
-
-          assert.isFalse(webex.meetings.registered);
-          assert.isNull(webex.meetings.unregistrationPromise);
-        });
-
-        it('clears unregistrationPromise after failed unregistration', async () => {
-          webex.meetings.registered = true;
-
-          webex.internal.mercury.disconnect.rejects(new Error('disconnect failed'));
-
-          await assert.isRejected(webex.meetings.unregister());
-
-          assert.isTrue(webex.meetings.registered);
-          assert.isNull(webex.meetings.unregistrationPromise);
-        });
-
-        it('allows new unregistration after previous unregistration completes', async () => {
-          webex.meetings.registered = true;
-
-          // First unregistration
-          await webex.meetings.unregister();
-          assert.isFalse(webex.meetings.registered);
-
-          // Register again
-          webex.canAuthorize = true;
-          await webex.meetings.register();
-          assert.isTrue(webex.meetings.registered);
-
-          // Reset history
-          webex.internal.mercury.disconnect.resetHistory();
-          webex.internal.device.unregister.resetHistory();
-
-          // Second unregistration should work normally
-          await webex.meetings.unregister();
-          assert.calledOnce(webex.internal.mercury.disconnect);
-          assert.calledOnce(webex.internal.device.unregister);
-          assert.isFalse(webex.meetings.registered);
-        });
-
-        it('handles register called during unregistration that fails', async () => {
-          webex.canAuthorize = true;
-          webex.meetings.registered = true;
-
-          const unregistrationError = new Error('unregistration failed');
-          let rejectUnregistration;
-          const unregistrationDelay = new Promise((resolve, reject) => {
-            rejectUnregistration = reject;
-          });
-
-          webex.internal.mercury.disconnect.returns(unregistrationDelay);
-
-          // Start unregistration (don't await)
-          const unregisterPromise = webex.meetings.unregister();
-
-          // Call register while unregistration is in progress
-          const registerPromise = webex.meetings.register();
-
-          // Fail the unregistration
-          rejectUnregistration(unregistrationError);
-
-          // Unregistration should fail
-          await assert.isRejected(unregisterPromise, 'unregistration failed');
-
-          // Register should still succeed (retry after unregister failure)
-          await registerPromise;
-
-          // Verify final state - should be registered
-          assert.isTrue(webex.meetings.registered);
-          assert.isNull(webex.meetings.unregistrationPromise);
-        });
-
-        it('logs appropriate message when register is called during unregistration', async () => {
-          webex.canAuthorize = true;
-          webex.meetings.registered = true;
-
-          const loggerSpy = sinon.spy(LoggerProxy.logger, 'info');
-
-          let resolveUnregistration;
-          const unregistrationDelay = new Promise((resolve) => {
-            resolveUnregistration = resolve;
-          });
-
-          webex.internal.mercury.disconnect.returns(unregistrationDelay);
-          webex.internal.device.unregister.returns(Promise.resolve());
-
-          // Start unregistration
-          const unregisterPromise = webex.meetings.unregister();
-
-          // Call register during unregistration
-          const registerPromise = webex.meetings.register();
-
-          // Should log that it's waiting
-          assert.calledWith(
-            loggerSpy,
-            'Meetings:index#register --> INFO, Meetings plugin unregistration in progress, waiting to register'
-          );
-
-          // Complete unregistration and registration
-          resolveUnregistration();
-          await unregisterPromise;
-          await registerPromise;
-
-          loggerSpy.restore();
-        });
       });
 
       describe('virtual background effect', () => {
@@ -1266,7 +732,7 @@ describe('plugin-meetings', () => {
           };
         });
 
-        it('creates noise reduction effect with BNR model', async () => {
+        it('creates noise reduction effect', async () => {
           const result = await webex.meetings.createNoiseReductionEffect({audioContext: {}});
 
           assert.exists(result);
@@ -1278,51 +744,30 @@ describe('plugin-meetings', () => {
             authToken: 'fake_token',
             mode: 'WORKLET',
             avoidSimd: false,
-            model: 'bnr',
           });
           assert.exists(result.enable);
           assert.exists(result.disable);
           assert.exists(result.dispose);
         });
 
-        it('creates noise reduction effect with OFMV model', async () => {
-          const result = await webex.meetings.createNoiseReductionEffect({
+        it('creates noise reduction effect with custom options passed', async () => {
+          const effectOptions = {
             audioContext: {},
-            model: 'ofmv',
-          });
+            mode: 'LEGACY',
+            env: 'int',
+            avoidSimd: true,
+          };
+
+          const result = await webex.meetings.createNoiseReductionEffect(effectOptions);
 
           assert.exists(result);
           assert.instanceOf(result, NoiseReductionEffect);
           assert.containsAllKeys(result, ['audioContext', 'isEnabled', 'isReady', 'options']);
-          assert.equal(result.options.authToken, 'fake_token');
-          assert.deepEqual(result.options, {
-            audioContext: {},
-            authToken: 'fake_token',
-            mode: 'WORKLET',
-            avoidSimd: false,
-            model: 'ofmv',
-          });
+          assert.deepEqual(result.options, {...effectOptions, authToken: 'fake_token'});
           assert.exists(result.enable);
           assert.exists(result.disable);
           assert.exists(result.dispose);
         });
-
-        it('passes custom options to noise reduction effect', async () => {
-          const result = await webex.meetings.createNoiseReductionEffect({
-            audioContext: {},
-            mode: 'LEGACY',
-            env: 'int',
-            avoidSimd: true,
-          });
-
-          assert.exists(result);
-          assert.instanceOf(result, NoiseReductionEffect);
-          assert.equal(result.options.mode, 'LEGACY');
-          assert.equal(result.options.env, 'int');
-          assert.equal(result.options.avoidSimd, true);
-          assert.equal(result.options.authToken, 'fake_token');
-          assert.equal(result.options.model, 'bnr');
-        });
       });
 
       describe('gets', () => {
@@ -1473,7 +918,7 @@ describe('plugin-meetings', () => {
                 locus: {
                   url: url1,
                 },
-                hashTreeMessage: undefined,
+                hashTreeMessage: undefined
               });
             });
           });
@@ -1758,30 +1203,8 @@ describe('plugin-meetings', () => {
 
         it('calls createMeeting with classificationId and returns its promise', async () => {
           await checkCallCreateMeeting(
-            [
-              test1,
-              test2,
-              FAKE_USE_RANDOM_DELAY,
-              {},
-              undefined,
-              true,
-              callStateForMetrics,
-              undefined,
-              undefined,
-              undefined,
-              classificationId,
-            ],
-            [
-              test1,
-              test2,
-              FAKE_USE_RANDOM_DELAY,
-              {},
-              callStateForMetrics,
-              true,
-              undefined,
-              undefined,
-              classificationId,
-            ]
+            [test1, test2, FAKE_USE_RANDOM_DELAY, {}, undefined, true, callStateForMetrics, undefined, undefined, undefined, classificationId],
+            [test1, test2, FAKE_USE_RANDOM_DELAY, {}, callStateForMetrics, true, undefined, undefined, classificationId],
           );
         });
 
@@ -2014,81 +1437,37 @@ describe('plugin-meetings', () => {
                   webExMeetingId,
                 },
               },
-              hashTreeMessage: undefined,
+              hashTreeMessage: undefined
             });
           });
           it('should setup the meeting from a hash tree event', async () => {
-            const selfData = {};
-            const infoData = {webExMeetingId};
-            const hashTreeMessage = {
-              locusUrl: url1,
-              locusStateElements: [
-                {
-                  htMeta: {elementId: {type: 'Self', id: 1, version: 1}},
-                  data: selfData,
-                },
-                {
-                  htMeta: {elementId: {type: 'Info', id: 2, version: 1}},
-                  data: infoData,
-                },
-              ],
+            const locus = {
+              id: uuid1,
+              self: {},
+              info: {
+                webExMeetingId,
+              },
             };
+            const hashTreeMessage = {something: 'hashTreeData'};
             await webex.meetings.handleLocusEvent({
+              locus,
               eventType: 'locus.state_message',
               locusUrl: url1,
               stateElementsMessage: hashTreeMessage,
             });
             assert.calledWith(webex.meetings.meetingCollection.getByKey, 'locusUrl', url1);
+            assert.calledWith(
+              webex.meetings.meetingCollection.getByKey,
+              'meetingNumber',
+              webExMeetingId
+            );
             assert.calledOnce(initialSetup);
             assert.calledWith(initialSetup, {
               trigger: 'locus-message',
-              locus: {
-                participants: [],
-                url: url1,
-                self: selfData,
-                info: infoData,
-              },
+              locus,
               hashTreeMessage,
             });
           });
-
-          it('should ignore hash tree event when created locus has INACTIVE fullState', async () => {
-            const hashTreeMessage = {
-              locusUrl: url1,
-              locusStateElements: [
-                {
-                  htMeta: {elementId: {type: 'FullState', id: 1, version: 1}},
-                  data: {state: 'INACTIVE'},
-                },
-              ],
-            };
-            await webex.meetings.handleLocusEvent({
-              eventType: 'locus.state_message',
-              locusUrl: url1,
-              stateElementsMessage: hashTreeMessage,
-            });
-            assert.notCalled(webex.meetings.create);
-            assert.notCalled(initialSetup);
-          });
-
-          it('should ignore hash tree event when created locus has self LEFT and removed', async () => {
-            const hashTreeMessage = {
-              locusUrl: url1,
-              locusStateElements: [
-                {
-                  htMeta: {elementId: {type: 'Self', id: 1, version: 1}},
-                  data: {state: 'LEFT', removed: true},
-                },
-              ],
-            };
-            await webex.meetings.handleLocusEvent({
-              eventType: 'locus.state_message',
-              locusUrl: url1,
-              stateElementsMessage: hashTreeMessage,
-            });
-            assert.notCalled(webex.meetings.create);
-            assert.notCalled(initialSetup);
-          });
           it('should setup the meeting by difference event without replaces', async () => {
             await webex.meetings.handleLocusEvent({
               locus: {
@@ -2128,7 +1507,7 @@ describe('plugin-meetings', () => {
                   webExMeetingId,
                 },
               },
-              hashTreeMessage: undefined,
+              hashTreeMessage: undefined
             });
           });
 
@@ -2204,7 +1583,7 @@ describe('plugin-meetings', () => {
                   webExMeetingId,
                 },
               },
-              hashTreeMessage: undefined,
+              hashTreeMessage: undefined
             });
           });
 
@@ -3532,7 +2911,7 @@ describe('plugin-meetings', () => {
           conversationUrl: 'conversationUrl1',
         };
 
-        sinon.stub(MeetingsUtil, 'getCorrelationIdForDevice').returns('correlationId1');
+        sinon.stub(MeetingsUtil, 'checkForCorrelationId').returns('correlationId1');
       });
       afterEach(() => {
         sinon.restore();
@@ -3638,197 +3017,6 @@ describe('plugin-meetings', () => {
         );
         assert.calledWith(webex.meetings.meetingCollection.getByKey, 'meetingNumber', '123456');
       });
-
-      describe('when receiving hash tree events', () => {
-        let hashTreeEvent;
-
-        beforeEach(() => {
-          MeetingsUtil.getCorrelationIdForDevice.restore();
-          sinon.spy(MeetingsUtil, 'getCorrelationIdForDevice');
-
-          hashTreeEvent = {
-            eventType: 'locus.state_message',
-            stateElementsMessage: {
-              locusUrl: url1,
-              locusStateElements: [
-                {
-                  htMeta: {
-                    elementId: {
-                      type: 'participant',
-                      id: 2,
-                      version: 1,
-                    },
-                    dataSetNames: ['main'],
-                  },
-                  data: {
-                    id: 'participant1',
-                  },
-                },
-                {
-                  htMeta: {
-                    elementId: {
-                      type: 'Self',
-                      id: 1,
-                      version: 1,
-                    },
-                    dataSetNames: ['self'],
-                  },
-                  data: {
-                    callbackInfo: {
-                      callbackAddress: 'address1',
-                    },
-                    devices: [
-                      {
-                        url: 'deviceUrl',
-                        correlationId: 'correlationId1',
-                      },
-                    ],
-                  },
-                },
-              ],
-            },
-          };
-
-          webex.internal.device.url = 'deviceUrl';
-        });
-
-        it('should find meeting by locusUrl from stateElementsMessage', () => {
-          mockGetByKey('locusUrl');
-          const result = webex.meetings.getCorrespondingMeetingByLocus(hashTreeEvent);
-          assert.deepEqual(result, mockReturnMeeting);
-          assert.calledOnceWithExactly(webex.meetings.meetingCollection.getByKey, 'locusUrl', url1);
-        });
-
-        it('should extract self data from locusStateElements and try correlationId when locusUrl not found', () => {
-          mockGetByKey('correlationId');
-          const result = webex.meetings.getCorrespondingMeetingByLocus(hashTreeEvent);
-          assert.deepEqual(result, mockReturnMeeting);
-          assert.callCount(webex.meetings.meetingCollection.getByKey, 2);
-          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'locusUrl', url1);
-          assert.calledWith(
-            webex.meetings.meetingCollection.getByKey,
-            'correlationId',
-            'correlationId1'
-          );
-          assert.calledOnceWithExactly(
-            MeetingsUtil.getCorrelationIdForDevice,
-            'deviceUrl',
-            hashTreeEvent.stateElementsMessage.locusStateElements[1].data
-          );
-        });
-
-        it('should extract self data from locusStateElements and try sipUri when locusUrl and correlationId not found', () => {
-          mockGetByKey('sipUri');
-          const result = webex.meetings.getCorrespondingMeetingByLocus(hashTreeEvent);
-          assert.deepEqual(result, mockReturnMeeting);
-          assert.callCount(webex.meetings.meetingCollection.getByKey, 3);
-          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'locusUrl', url1);
-          assert.calledWith(
-            webex.meetings.meetingCollection.getByKey,
-            'correlationId',
-            'correlationId1'
-          );
-          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'sipUri', 'address1');
-        });
-
-        it('should try all keys when no meeting found', () => {
-          mockGetByKey();
-          const result = webex.meetings.getCorrespondingMeetingByLocus(hashTreeEvent);
-          assert.isNull(result);
-          assert.callCount(webex.meetings.meetingCollection.getByKey, 5);
-          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'locusUrl', url1);
-          assert.calledWith(
-            webex.meetings.meetingCollection.getByKey,
-            'correlationId',
-            'correlationId1'
-          );
-          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'sipUri', 'address1');
-          // these remaining 2 will never work for hash trees, but just checking that
-          // the calls are made and we don't crash
-          assert.calledWith(
-            webex.meetings.meetingCollection.getByKey,
-            'conversationUrl',
-            undefined
-          );
-          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'meetingNumber', undefined);
-        });
-
-        it('should handle hash tree event with no self object', () => {
-          mockGetByKey();
-          hashTreeEvent.stateElementsMessage.locusStateElements = [
-            {
-              htMeta: {
-                elementId: {
-                  type: 'participant',
-                  id: 2,
-                  version: 1,
-                },
-                dataSetNames: ['dataset1'],
-              },
-              data: {
-                id: 'participant1',
-              },
-            },
-          ];
-
-          const result = webex.meetings.getCorrespondingMeetingByLocus(hashTreeEvent);
-          assert.isNull(result);
-          assert.callCount(webex.meetings.meetingCollection.getByKey, 5);
-          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'locusUrl', url1);
-          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'correlationId', false);
-          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'sipUri', undefined);
-          // these remaining 2 will never work for hash trees, but just checking that
-          // the calls are made and we don't crash
-          assert.calledWith(
-            webex.meetings.meetingCollection.getByKey,
-            'conversationUrl',
-            undefined
-          );
-          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'meetingNumber', undefined);
-        });
-
-        it('should handle hash tree event with empty locusStateElements', () => {
-          mockGetByKey();
-          hashTreeEvent.stateElementsMessage.locusStateElements = [];
-          const result = webex.meetings.getCorrespondingMeetingByLocus(hashTreeEvent);
-          assert.isNull(result);
-          assert.callCount(webex.meetings.meetingCollection.getByKey, 5);
-          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'locusUrl', url1);
-          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'correlationId', false);
-          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'sipUri', undefined);
-          // these remaining 2 will never work for hash trees, but just checking that
-          // the calls are made and we don't crash
-          assert.calledWith(
-            webex.meetings.meetingCollection.getByKey,
-            'conversationUrl',
-            undefined
-          );
-          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'meetingNumber', undefined);
-        });
-
-        it('should handle hash tree event with self object but no callbackAddress', () => {
-          mockGetByKey('meetingNumber');
-          delete hashTreeEvent.stateElementsMessage.locusStateElements[1].data.callbackInfo;
-          const result = webex.meetings.getCorrespondingMeetingByLocus(hashTreeEvent);
-          assert.deepEqual(result, mockReturnMeeting);
-          assert.callCount(webex.meetings.meetingCollection.getByKey, 5);
-          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'locusUrl', url1);
-          assert.calledWith(
-            webex.meetings.meetingCollection.getByKey,
-            'correlationId',
-            'correlationId1'
-          );
-          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'sipUri', undefined);
-          // these remaining 2 will never work for hash trees, but just checking that
-          // the calls are made and we don't crash
-          assert.calledWith(
-            webex.meetings.meetingCollection.getByKey,
-            'conversationUrl',
-            undefined
-          );
-          assert.calledWith(webex.meetings.meetingCollection.getByKey, 'meetingNumber', undefined);
-        });
-      });
     });
 
     describe('#sortLocusArrayToUpdate', () => {
@@ -3943,7 +3131,7 @@ describe('plugin-meetings', () => {
           },
         });
         assert.calledWith(webex.meetings.handleLocusEvent, {
-          eventType: LOCUSEVENT.SDK_LOCUS_FROM_SYNC_MEETINGS,
+          eventType: LOCUSEVENT.SDK_NO_EVENT,
           locus: breakoutLocus,
           locusUrl: breakoutLocus.url,
         });