@webex/webex-core 3.11.0-webex-services-ready.1 → 3.12.0-llmrefactor.1

package/test/unit/spec/services/services.js

@@ -34,53 +34,6 @@ describe('webex-core', () => {
     });
 
     describe('#initialize', () => {
-      it('listens for "loaded" event instead of "ready" to avoid deadlock', () => {
-        services.listenToOnce = sinon.stub();
-        services.initialize();
-
-        // Second listenToOnce call should be for 'loaded' event
-        assert.equal(services.listenToOnce.getCall(1).args[1], 'loaded');
-      });
-
-      it('services.ready starts as false', () => {
-        assert.isFalse(services.ready);
-      });
-
-      it('sets ready to true and triggers services:initialized when initialization succeeds with credentials', async () => {
-        services.listenToOnce = sinon.stub();
-        services.initServiceCatalogs = sinon.stub().returns(Promise.resolve());
-        services.trigger = sinon.stub();
-        services.webex.credentials = {
-          supertoken: {
-            access_token: 'token',
-          },
-        };
-
-        services.initialize();
-
-        // call the onLoaded callback
-        services.listenToOnce.getCall(1).args[2]();
-        await waitForAsync();
-
-        assert.isTrue(services.ready);
-        sinon.assert.calledWith(services.trigger, 'services:initialized');
-      });
-
-      it('sets ready to true and triggers services:initialized when initialization succeeds without credentials', async () => {
-        services.listenToOnce = sinon.stub();
-        services.collectPreauthCatalog = sinon.stub().returns(Promise.resolve());
-        services.trigger = sinon.stub();
-
-        services.initialize();
-
-        // call the onLoaded callback
-        services.listenToOnce.getCall(1).args[2]();
-        await waitForAsync();
-
-        assert.isTrue(services.ready);
-        sinon.assert.calledWith(services.trigger, 'services:initialized');
-      });
-
       it('initFailed is false when initialization succeeds and credentials are available', async () => {
         services.listenToOnce = sinon.stub();
         services.initServiceCatalogs = sinon.stub().returns(Promise.resolve());
@@ -92,7 +45,8 @@ describe('webex-core', () => {
 
         services.initialize();
 
-        // call the onLoaded callback
+        // call the onReady callback
+        services.listenToOnce.getCall(0).args[2]();
         services.listenToOnce.getCall(1).args[2]();
         await waitForAsync();
 
@@ -105,7 +59,8 @@ describe('webex-core', () => {
 
         services.initialize();
 
-        // call the onLoaded callback
+        // call the onReady callback
+        services.listenToOnce.getCall(0).args[2]();
         services.listenToOnce.getCall(1).args[2]();
         await waitForAsync();
 
@@ -114,9 +69,9 @@ describe('webex-core', () => {
 
       it.each([
         {error: new Error('failed'), expectedMessage: 'failed'},
-        {error: undefined, expectedMessage: undefined},
+        {error: undefined, expectedMessage: undefined}
       ])(
-        'sets initFailed to true when collectPreauthCatalog errors but still sets ready to true',
+        'sets initFailed to true when collectPreauthCatalog errors',
         async ({error, expectedMessage}) => {
           services.collectPreauthCatalog = sinon.stub().callsFake(() => {
             return Promise.reject(error);
@@ -124,18 +79,16 @@ describe('webex-core', () => {
 
           services.listenToOnce = sinon.stub();
           services.logger.error = sinon.stub();
-          services.trigger = sinon.stub();
 
           services.initialize();
 
-          // call the onLoaded callback
+          // call the onReady callback
+          services.listenToOnce.getCall(0).args[2]();
           services.listenToOnce.getCall(1).args[2]();
 
           await waitForAsync();
 
           assert.isTrue(services.initFailed);
-          assert.isTrue(services.ready);
-          sinon.assert.calledWith(services.trigger, 'services:initialized');
           sinon.assert.calledWith(
             services.logger.error,
             `services: failed to init initial services when no credentials available, ${expectedMessage}`
@@ -145,132 +98,334 @@ describe('webex-core', () => {
 
       it.each([
         {error: new Error('failed'), expectedMessage: 'failed'},
-        {error: undefined, expectedMessage: undefined},
-      ])(
-        'sets initFailed to true when initServiceCatalogs errors but still sets ready to true',
-        async ({error, expectedMessage}) => {
-          services.initServiceCatalogs = sinon.stub().callsFake(() => {
-            return Promise.reject(error);
-          });
-          services.webex.credentials = {
-            supertoken: {
-              access_token: 'token',
-            },
-          };
+        {error: undefined, expectedMessage: undefined}
+      ])('sets initFailed to true when initServiceCatalogs errors', async ({error, expectedMessage}) => {
+        services.initServiceCatalogs = sinon.stub().callsFake(() => {
+          return Promise.reject(error);
+        });
+        services.webex.credentials = {
+          supertoken: {
+            access_token: 'token'
+          }
+        }
 
-          services.listenToOnce = sinon.stub();
-          services.logger.error = sinon.stub();
-          services.trigger = sinon.stub();
+        services.listenToOnce = sinon.stub();
+        services.logger.error = sinon.stub();
 
-          services.initialize();
+        services.initialize();
 
-          // call the onLoaded callback
-          services.listenToOnce.getCall(1).args[2]();
+        // call the onReady callback
+        services.listenToOnce.getCall(0).args[2]();
+        services.listenToOnce.getCall(1).args[2]();
 
-          await waitForAsync();
+        await waitForAsync();
 
-          assert.isTrue(services.initFailed);
-          assert.isTrue(services.ready);
-          sinon.assert.calledWith(services.trigger, 'services:initialized');
-          sinon.assert.calledWith(
-            services.logger.error,
-            `services: failed to init initial services when credentials available, ${expectedMessage}`
-          );
-        }
-      );
+        assert.isTrue(services.initFailed);
+        sinon.assert.calledWith(
+          services.logger.error,
+          `services: failed to init initial services when credentials available, ${expectedMessage}`
+        );
+      });
 
-      describe('when change:canAuthorize fires', () => {
-        it('calls initServiceCatalogs when canAuthorize becomes true and postauth catalog is not ready', async () => {
-          services.listenToOnce = sinon.stub();
-          services._loadCatalogFromCache = sinon.stub().returns(Promise.resolve(false));
-          services.collectPreauthCatalog = sinon.stub().returns(Promise.resolve());
-          services.initServiceCatalogs = sinon.stub().returns(Promise.resolve());
-          services.trigger = sinon.stub();
-          // Ensure no credentials so we go to the preauth path
-          services.webex.credentials = {};
+      it('sets services.ready to true when waitForCatalogInit is disabled (default)', () => {
+        services.listenToOnce = sinon.stub();
+        services.initialize();
 
-          services.initialize();
+        // Fire the change:config handler which decides gated-vs-ungated and, in
+        // ungated mode, flips services.ready to true.
+        services.listenToOnce.getCall(0).args[2]();
 
-          // Get the catalog after initialize creates it
-          const testCatalog = services._getCatalog();
-          testCatalog.status.postauth.ready = false;
+        assert.isTrue(services.ready, 'services.ready should be true so it does not block webex.ready');
+      });
 
-          // call the onLoaded callback (preauth path)
-          services.listenToOnce.getCall(1).args[2]();
-          await waitForAsync();
+      it('listens on the "ready" event when waitForCatalogInit is disabled (default)', () => {
+        services.listenToOnce = sinon.stub();
+        services.initialize();
 
-          // Now set canAuthorize to true to simulate auth completing
-          services.webex.canAuthorize = true;
+        // Fire change:config to trigger the mode-specific listener registration.
+        services.listenToOnce.getCall(0).args[2]();
 
-          // call the change:canAuthorize callback (should be call 2)
-          services.listenToOnce.getCall(2).args[2]();
-          await waitForAsync();
+        // Call 0 is 'change:config'; call 1 is the catalog init listener.
+        const [, event] = services.listenToOnce.getCall(1).args;
+        assert.equal(event, 'ready', 'default path listens on webex ready');
+      });
+    });
 
-          sinon.assert.calledOnce(services.initServiceCatalogs);
-          assert.isTrue(testCatalog.isReady);
-        });
+    describe('#initialize (waitForCatalogInit=true)', () => {
+      beforeEach(() => {
+        services.webex.config = {
+          ...(services.webex.config || {}),
+          services: {waitForCatalogInit: true, catalogInitTimeout: 15000},
+        };
+        // Reset ready flag: the outer beforeEach constructs services which
+        // runs initialize() once with no config (ungated path, flips ready to
+        // true). We reset here so tests that call initialize() a second time
+        // with the flag enabled observe the gated behavior from a clean state.
+        services.ready = false;
+      });
 
-        it('does not call initServiceCatalogs when postauth catalog is already ready', async () => {
-          services.listenToOnce = sinon.stub();
-          services._loadCatalogFromCache = sinon.stub().returns(Promise.resolve(false));
-          services.collectPreauthCatalog = sinon.stub().returns(Promise.resolve());
-          services.initServiceCatalogs = sinon.stub().returns(Promise.resolve());
-          services.trigger = sinon.stub();
-          // Ensure no credentials so we go to the preauth path
-          services.webex.credentials = {};
+      it('leaves services.ready=false after initialize (does not flip until finalize)', () => {
+        services.listenToOnce = sinon.stub();
+        services.initialize();
 
-          services.initialize();
+        assert.isFalse(services.ready, 'services.ready should block webex.ready until finalize');
+      });
 
-          // Get the catalog after initialize creates it
-          const testCatalog = services._getCatalog();
+      it('listens on the "loaded" event (not "ready") to avoid deadlock', () => {
+        services.listenToOnce = sinon.stub();
+        services.initialize();
 
-          // call the onLoaded callback (preauth path)
-          services.listenToOnce.getCall(1).args[2]();
-          await waitForAsync();
+        // Fire change:config to trigger the mode-specific listener registration.
+        services.listenToOnce.getCall(0).args[2]();
 
-          // Set canAuthorize to true and postauth as ready BEFORE calling the callback
-          services.webex.canAuthorize = true;
-          testCatalog.status.postauth.ready = true;
+        // Call 0 is 'change:config'; call 1 is the catalog init listener.
+        const [, event] = services.listenToOnce.getCall(1).args;
+        assert.equal(event, 'loaded', 'gated path must listen on loaded to avoid deadlock');
+      });
 
-          // call the change:canAuthorize callback (should be call 2)
-          services.listenToOnce.getCall(2).args[2]();
-          await waitForAsync();
+      it('flips services.ready=true after init succeeds with credentials', async () => {
+        services.listenToOnce = sinon.stub();
+        services.initServiceCatalogs = sinon.stub().returns(Promise.resolve());
+        services.webex.credentials = {
+          supertoken: {access_token: 'token'},
+        };
 
-          sinon.assert.notCalled(services.initServiceCatalogs);
-        });
+        services.initialize();
+        services.listenToOnce.getCall(0).args[2]();
+        services.listenToOnce.getCall(1).args[2]();
+        await waitForAsync();
 
-        it('logs an error when initServiceCatalogs fails after auth', async () => {
-          services.listenToOnce = sinon.stub();
-          services._loadCatalogFromCache = sinon.stub().returns(Promise.resolve(false));
-          services.collectPreauthCatalog = sinon.stub().returns(Promise.resolve());
-          services.initServiceCatalogs = sinon.stub().rejects(new Error('auth failed'));
-          services.logger.error = sinon.stub();
-          services.trigger = sinon.stub();
-          // Ensure no credentials so we go to the preauth path
-          services.webex.credentials = {};
+        assert.isTrue(services.ready);
+      });
 
-          services.initialize();
+      it('flips services.ready=true after init succeeds without credentials (preauth path)', async () => {
+        services.listenToOnce = sinon.stub();
+        services.collectPreauthCatalog = sinon.stub().returns(Promise.resolve());
 
-          // Get the catalog after initialize creates it
-          const testCatalog = services._getCatalog();
-          testCatalog.status.postauth.ready = false;
+        services.initialize();
+        services.listenToOnce.getCall(0).args[2]();
+        services.listenToOnce.getCall(1).args[2]();
+        await waitForAsync();
 
-          // call the onLoaded callback (preauth path)
-          services.listenToOnce.getCall(1).args[2]();
-          await waitForAsync();
+        assert.isTrue(services.ready);
+      });
 
-          // Now set canAuthorize to true to simulate auth completing
-          services.webex.canAuthorize = true;
+      it('flips services.ready=true even when initServiceCatalogs errors, so webex.ready can fire', async () => {
+        services.listenToOnce = sinon.stub();
+        services.initServiceCatalogs = sinon.stub().returns(Promise.reject(new Error('boom')));
+        services.webex.credentials = {
+          supertoken: {access_token: 'token'},
+        };
+        services.logger.error = sinon.stub();
 
-          // call the change:canAuthorize callback (should be call 2)
-          services.listenToOnce.getCall(2).args[2]();
-          await waitForAsync();
+        services.initialize();
+        services.listenToOnce.getCall(0).args[2]();
+        services.listenToOnce.getCall(1).args[2]();
+        await waitForAsync();
 
-          sinon.assert.calledWith(
-            services.logger.error,
-            'services: failed to init service catalogs after auth, auth failed'
-          );
-        });
+        assert.isTrue(services.initFailed);
+        assert.isTrue(services.ready);
+      });
+
+      it('flips services.ready=true even when collectPreauthCatalog errors', async () => {
+        services.listenToOnce = sinon.stub();
+        services.collectPreauthCatalog = sinon.stub().returns(Promise.reject(new Error('boom')));
+        services.logger.error = sinon.stub();
+
+        services.initialize();
+        services.listenToOnce.getCall(0).args[2]();
+        services.listenToOnce.getCall(1).args[2]();
+        await waitForAsync();
+
+        assert.isTrue(services.initFailed);
+        assert.isTrue(services.ready);
+      });
+
+      it('flips services.ready=true when init times out', async () => {
+        const clock = sinon.useFakeTimers();
+        services.listenToOnce = sinon.stub();
+        // Never resolves - the timeout must win the race.
+        services.initServiceCatalogs = sinon.stub().returns(new Promise(() => {}));
+        services.webex.credentials = {
+          supertoken: {access_token: 'token'},
+        };
+        services.logger.error = sinon.stub();
+
+        services.initialize();
+        services.listenToOnce.getCall(0).args[2]();
+        services.listenToOnce.getCall(1).args[2]();
+
+        // Advance past the 15s init timeout and flush microtasks so the
+        // rejected timeout can propagate through .catch and .finally into
+        // _finalizeReady().
+        await clock.tickAsync(15_001);
+        clock.restore();
+
+        assert.isTrue(services.initFailed);
+        assert.isTrue(services.ready);
+        sinon.assert.calledWithMatch(
+          services.logger.error,
+          /services: init timed out after 15000ms/
+        );
+      });
+
+      it('awaits an in-flight credentials refresh before flipping services.ready=true', async () => {
+        services.listenToOnce = sinon.stub();
+        services.initServiceCatalogs = sinon.stub().returns(Promise.resolve());
+
+        let onChangeIsRefreshing;
+        services.webex.credentials = {
+          supertoken: {access_token: 'token'},
+          isRefreshing: true,
+          once: sinon.stub().callsFake((event, cb) => {
+            if (event === 'change:isRefreshing') onChangeIsRefreshing = cb;
+          }),
+        };
+
+        services.initialize();
+        services.listenToOnce.getCall(0).args[2]();
+        services.listenToOnce.getCall(1).args[2]();
+        await waitForAsync();
+
+        assert.isFalse(services.ready, 'must not flip ready while refresh is in flight');
+        assert.isFunction(onChangeIsRefreshing, 'must subscribe to change:isRefreshing');
+        sinon.assert.calledWith(services.webex.credentials.once, 'change:isRefreshing');
+
+        // Simulate refresh completing.
+        onChangeIsRefreshing();
+        await waitForAsync();
+
+        assert.isTrue(services.ready);
+      });
+
+      it('registers a change:canAuthorize listener when there is no supertoken (fresh-login path)', async () => {
+        services.listenToOnce = sinon.stub();
+        services.collectPreauthCatalog = sinon.stub().returns(Promise.resolve());
+        services.initServiceCatalogs = sinon.stub().returns(Promise.resolve());
+
+        services.initialize();
+        // initialize() creates a new catalog and replaces the WeakMap entry.
+        const currentCatalog = services._getCatalog();
+        // Fire the 'loaded' listener (index 1; index 0 was 'change:config').
+        services.listenToOnce.getCall(0).args[2]();
+        services.listenToOnce.getCall(1).args[2]();
+        await waitForAsync();
+
+        const freshLoginCall = services.listenToOnce
+          .getCalls()
+          .find((call) => call.args[1] === 'change:canAuthorize');
+        assert.isDefined(freshLoginCall, 'expected change:canAuthorize listener to be registered');
+
+        // Simulate OAuth completing.
+        services.webex.canAuthorize = true;
+        currentCatalog.status.postauth.ready = false;
+        freshLoginCall.args[2]();
+
+        assert.isTrue(
+          services.initServiceCatalogs.called,
+          'expected postauth catalog init after canAuthorize flips'
+        );
+
+        // `catalog.isReady` is now set inside initServiceCatalogs (after the
+        // postauth updateServices) rather than by this listener, so it is not
+        // asserted here where initServiceCatalogs is stubbed.
+        await waitForAsync();
+      });
+
+      it('does not re-init postauth catalog when canAuthorize fires but catalog is already ready', async () => {
+        services.listenToOnce = sinon.stub();
+        services.collectPreauthCatalog = sinon.stub().returns(Promise.resolve());
+        services.initServiceCatalogs = sinon.stub().returns(Promise.resolve());
+
+        services.initialize();
+        // initialize() creates a new catalog; grab the current one.
+        const currentCatalog = services._getCatalog();
+        services.listenToOnce.getCall(0).args[2]();
+        services.listenToOnce.getCall(1).args[2]();
+        await waitForAsync();
+
+        const freshLoginCall = services.listenToOnce
+          .getCalls()
+          .find((call) => call.args[1] === 'change:canAuthorize');
+
+        services.webex.canAuthorize = true;
+        currentCatalog.status.postauth.ready = true; // already collected
+        freshLoginCall.args[2]();
+
+        assert.isFalse(
+          services.initServiceCatalogs.called,
+          'must not re-fetch postauth catalog if it is already ready'
+        );
+      });
+
+      it('finalizes ready when cache is warm (skips network fetch)', async () => {
+        services.listenToOnce = sinon.stub();
+        services._loadCatalogFromCache = sinon.stub().returns(Promise.resolve(true));
+        services.initServiceCatalogs = sinon.stub().returns(Promise.resolve());
+        services.collectPreauthCatalog = sinon.stub().returns(Promise.resolve());
+
+        services.initialize();
+        services.listenToOnce.getCall(0).args[2]();
+        services.listenToOnce.getCall(1).args[2]();
+        await waitForAsync();
+        await waitForAsync();
+
+        assert.isTrue(services.ready);
+        assert.isFalse(
+          services.initServiceCatalogs.called,
+          'must skip network fetch when cache is warm'
+        );
+        assert.isFalse(
+          services.collectPreauthCatalog.called,
+          'must skip preauth fetch when cache is warm'
+        );
+      });
+    });
+
+    describe('#_finalizeReady', () => {
+      beforeEach(() => {
+        // Outer beforeEach construction already ran initialize() (ungated,
+        // sets ready=true). Reset so _finalizeReady's flip is observable.
+        services.ready = false;
+      });
+
+      it('sets ready=true immediately when credentials are not refreshing', async () => {
+        services.webex.credentials = {isRefreshing: false};
+        assert.isFalse(services.ready);
+
+        await services._finalizeReady();
+
+        assert.isTrue(services.ready);
+      });
+
+      it('sets ready=true when credentials are missing', async () => {
+        services.webex.credentials = undefined;
+
+        await services._finalizeReady();
+
+        assert.isTrue(services.ready);
+      });
+
+      it('awaits change:isRefreshing before setting ready=true', async () => {
+        let onChangeIsRefreshing;
+        services.webex.credentials = {
+          isRefreshing: true,
+          once: sinon.stub().callsFake((event, cb) => {
+            if (event === 'change:isRefreshing') onChangeIsRefreshing = cb;
+          }),
+        };
+
+        const settled = services._finalizeReady();
+        // Let the async body reach its await point.
+        await waitForAsync();
+
+        assert.isFalse(services.ready, 'ready must not flip while refresh is in flight');
+        assert.isFunction(onChangeIsRefreshing);
+
+        onChangeIsRefreshing();
+        await settled;
+
+        assert.isTrue(services.ready);
       });
     });
 
@@ -309,7 +464,7 @@ describe('webex-core', () => {
 
         services.collectPreauthCatalog = sinon.stub().callsFake(() => {
           return Promise.resolve();
-        });
+        })
 
         services.updateServices = sinon.stub().callsFake(() => {
           return Promise.reject(error);
@@ -404,7 +559,7 @@ describe('webex-core', () => {
             discovery: {
               sqdiscovery: 'https://test.ciscospark.com/v1/region',
             },
-          },
+          }
         };
       });
 
@@ -424,8 +579,8 @@ describe('webex-core', () => {
           assert.calledWith(webex.request, {
             uri: 'https://test.ciscospark.com/v1/region',
             addAuthHeader: false,
-            headers: {'spark-user-agent': null},
-            timeout: 5000,
+            headers: { 'spark-user-agent': null },
+            timeout: 5000
           });
         });
       });
@@ -482,6 +637,7 @@ describe('webex-core', () => {
     });
 
     describe('#_fetchNewServiceHostmap()', () => {
+
       beforeEach(() => {
         sinon.spy(webex.internal.newMetrics.callDiagnosticLatencies, 'measureLatency');
       });
@@ -495,20 +651,17 @@ describe('webex-core', () => {
 
         sinon.stub(services, '_formatReceivedHostmap').resolves(mapResponse);
         sinon.stub(services, 'request').resolves({});
-
+        
         const mapResult = await services._fetchNewServiceHostmap({from: 'limited'});
 
         assert.calledOnceWithExactly(services.request, {
           method: 'GET',
           service: 'u2c',
           resource: '/limited/catalog',
-          qs: {format: 'hostmap'},
-        });
-        assert.calledOnceWithExactly(
-          webex.internal.newMetrics.callDiagnosticLatencies.measureLatency,
-          sinon.match.func,
-          'internal.get.u2c.time'
+          qs: {format: 'hostmap'}
+        }
         );
+        assert.calledOnceWithExactly(webex.internal.newMetrics.callDiagnosticLatencies.measureLatency, sinon.match.func, 'internal.get.u2c.time');
       });
 
       it('checks service request rejects', async () => {
@@ -516,7 +669,7 @@ describe('webex-core', () => {
 
         sinon.spy(services, '_formatReceivedHostmap');
         sinon.stub(services, 'request').rejects(error);
-
+        
         const promise = services._fetchNewServiceHostmap({from: 'limited'});
         const rejectedValue = await assert.isRejected(promise);
 
@@ -528,13 +681,10 @@ describe('webex-core', () => {
           method: 'GET',
           service: 'u2c',
           resource: '/limited/catalog',
-          qs: {format: 'hostmap'},
-        });
-        assert.calledOnceWithExactly(
-          webex.internal.newMetrics.callDiagnosticLatencies.measureLatency,
-          sinon.match.func,
-          'internal.get.u2c.time'
+          qs: {format: 'hostmap'}
+        }
         );
+        assert.calledOnceWithExactly(webex.internal.newMetrics.callDiagnosticLatencies.measureLatency, sinon.match.func, 'internal.get.u2c.time');
       });
     });
 
@@ -565,6 +715,7 @@ describe('webex-core', () => {
       });
 
       it('returns the original uri if the hostmap has no hosts for the host', () => {
+
         services._hostCatalog = {
           'example.com': [],
         };
@@ -728,7 +879,8 @@ describe('webex-core', () => {
                 id: '0:0:0:different-e-x',
               },
             ],
-            'example-f.com': [],
+            'example-f.com': [
+            ],
           },
           format: 'hostmap',
         };
@@ -936,7 +1088,7 @@ describe('webex-core', () => {
             defaultUrl: 'https://example-g.com/api/v1',
             hosts: [],
             name: 'example-g',
-          },
+          }
         ]);
       });
 
@@ -990,59 +1142,34 @@ describe('webex-core', () => {
         assert.equal(webex.config.credentials.authorizeUrl, authUrl);
       });
     });
-
+    
     describe('#getMobiusClusters', () => {
       it('returns unique mobius host entries from hostCatalog', () => {
         // Arrange: two hostCatalog keys, with duplicate mobius host across keys
         services._hostCatalog = {
           'mobius-us-east-2.prod.infra.webex.com': [
-            {
-              host: 'mobius-us-east-2.prod.infra.webex.com',
-              ttl: -1,
-              priority: 5,
-              id: 'urn:TEAM:xyz:mobius',
-            },
-            {
-              host: 'mobius-eu-central-1.prod.infra.webex.com',
-              ttl: -1,
-              priority: 10,
-              id: 'urn:TEAM:xyz:mobius',
-            },
-          ],
+            {host: 'mobius-us-east-2.prod.infra.webex.com', ttl: -1, priority: 5, id: 'urn:TEAM:xyz:mobius'},
+            {host: 'mobius-eu-central-1.prod.infra.webex.com', ttl: -1, priority: 10, id: 'urn:TEAM:xyz:mobius'},
+            ],
 
           'mobius-eu-central-1.prod.infra.webex.com': [
-            {
-              host: 'mobius-us-east-2.prod.infra.webex.com',
-              ttl: -1,
-              priority: 7,
-              id: 'urn:TEAM:xyz:mobius',
-            }, // duplicate host
-          ],
-          'wdm-a.webex.com': [
+            {host: 'mobius-us-east-2.prod.infra.webex.com', ttl: -1, priority: 7, id: 'urn:TEAM:xyz:mobius'}, // duplicate host
+            ],
+          'wdm-a.webex.com' : [
             {host: 'wdm-a.webex.com', ttl: -1, priority: 5, id: 'urn:TEAM:xyz:wdm'},
-          ],
+          ]
         };
-
+    
         // Act
         const clusters = services.getMobiusClusters();
-
+    
         // Assert
         // deduped; only mobius entries; keeps first seen mobius-a, then mobius-b
         assert.deepEqual(
           clusters.map(({host, id, ttl, priority}) => ({host, id, ttl, priority})),
           [
-            {
-              host: 'mobius-us-east-2.prod.infra.webex.com',
-              id: 'urn:TEAM:xyz:mobius',
-              ttl: -1,
-              priority: 5,
-            },
-            {
-              host: 'mobius-eu-central-1.prod.infra.webex.com',
-              id: 'urn:TEAM:xyz:mobius',
-              ttl: -1,
-              priority: 10,
-            },
+            {host: 'mobius-us-east-2.prod.infra.webex.com', id: 'urn:TEAM:xyz:mobius', ttl: -1, priority: 5},
+            {host: 'mobius-eu-central-1.prod.infra.webex.com', id: 'urn:TEAM:xyz:mobius', ttl: -1, priority: 10},
           ]
         );
       });
@@ -1051,31 +1178,31 @@ describe('webex-core', () => {
     describe('#isValidHost', () => {
       beforeEach(() => {
         // Setting up a mock host catalog
-        services._hostCatalog = {
-          'audit-ci-m.wbx2.com': [
-            {
-              host: 'audit-ci-m.wbx2.com',
-              ttl: -1,
-              priority: 5,
-              id: 'urn:IDENTITY:PA61:adminAudit',
-            },
-            {
-              host: 'audit-ci-m.wbx2.com',
-              ttl: -1,
-              priority: 5,
-              id: 'urn:IDENTITY:PA61:adminAuditV2',
-            },
-          ],
-          'mercury-connection-partition0-r.wbx2.com': [
-            {
-              host: 'mercury-connection-partition0-r.wbx2.com',
-              ttl: -1,
-              priority: 5,
-              id: 'urn:TEAM:us-west-2_r:mercuryConnectionPartition0',
-            },
-          ],
-          'empty.com': [],
-        };
+          services._hostCatalog = {
+            "audit-ci-m.wbx2.com": [
+              {
+                  "host": "audit-ci-m.wbx2.com",
+                  "ttl": -1,
+                  "priority": 5,
+                  "id": "urn:IDENTITY:PA61:adminAudit"
+              },
+              {
+                  "host": "audit-ci-m.wbx2.com",
+                  "ttl": -1,
+                  "priority": 5,
+                  "id": "urn:IDENTITY:PA61:adminAuditV2"
+              }
+            ],
+            "mercury-connection-partition0-r.wbx2.com": [
+                {
+                    "host": "mercury-connection-partition0-r.wbx2.com",
+                    "ttl": -1,
+                    "priority": 5,
+                    "id": "urn:TEAM:us-west-2_r:mercuryConnectionPartition0"
+                }
+            ],
+            "empty.com": []
+          };
       });
       afterAll(() => {
         // Clean up the mock host catalog
@@ -1100,13 +1227,64 @@ describe('webex-core', () => {
       });
     });
 
+    describe('#isIntegrationEnvironment', () => {
+      it('returns true when u2c URL contains "intb"', () => {
+        services.webex.config = {
+          services: {
+            discovery: {
+              u2c: 'https://u2c-intb.ciscospark.com/u2c/api/v1',
+            },
+          },
+        };
+        assert.isTrue(services.isIntegrationEnvironment());
+      });
+
+      it('returns false when u2c URL does not contain "intb" (production)', () => {
+        services.webex.config = {
+          services: {
+            discovery: {
+              u2c: 'https://u2c.wbx2.com/u2c/api/v1',
+            },
+          },
+        };
+        assert.isFalse(services.isIntegrationEnvironment());
+      });
+
+      it('returns false when u2c URL is for FedRAMP', () => {
+        services.webex.config = {
+          services: {
+            discovery: {
+              u2c: 'https://u2c.gov.ciscospark.com/u2c/api/v1',
+            },
+          },
+        };
+        assert.isFalse(services.isIntegrationEnvironment());
+      });
+
+      it('returns false when u2c URL is undefined', () => {
+        services.webex.config = {
+          services: {
+            discovery: {
+              u2c: undefined,
+            },
+          },
+        };
+        assert.isFalse(services.isIntegrationEnvironment());
+      });
+
+      it('returns false when config is not available', () => {
+        services.webex.config = undefined;
+        assert.isFalse(services.isIntegrationEnvironment());
+      });
+    });
+
     describe('U2C catalog cache behavior', () => {
       let webex;
       let services;
       let catalog;
       let localStorageBackup;
       let windowBackup;
-
+  
       const makeLocalStorageShim = () => {
         const store = new Map();
         return {
@@ -1116,16 +1294,13 @@ describe('webex-core', () => {
           _store: store,
         };
       };
-
+  
       beforeEach(() => {
         // Build a fresh webex instance
-        webex = new MockWebex({
-          children: {services: Services},
-          config: {credentials: {federation: true}},
-        });
+        webex = new MockWebex({children: {services: Services}, config: {credentials: {federation: true}}});
         services = webex.internal.services;
         catalog = services._getCatalog();
-
+  
         // enable U2C caching feature flag in tests that rely on localStorage writes/reads
         services.webex.config = services.webex.config || {};
         services.webex.config.calling = {...(services.webex.config.calling || {}), cacheU2C: true};
@@ -1137,15 +1312,13 @@ describe('webex-core', () => {
         global.window.localStorage = makeLocalStorageShim();
         // Ensure code under test uses our shim via util method
         sinon.stub(services, '_getLocalStorageSafe').returns(global.window.localStorage);
-
+  
         // Stub the formatter so we don't need a full hostmap payload in tests
-        sinon
-          .stub(services, '_formatReceivedHostmap')
-          .callsFake(() => [
-            {name: 'hydra', defaultUrl: 'https://api.ciscospark.com/v1', hosts: []},
-          ]);
+        sinon.stub(services, '_formatReceivedHostmap').callsFake(() => [
+          {name: 'hydra', defaultUrl: 'https://api.ciscospark.com/v1', hosts: []},
+        ]);
       });
-
+  
       afterEach(() => {
         global.window.localStorage = localStorageBackup || undefined;
         if (!windowBackup) {
@@ -1158,7 +1331,7 @@ describe('webex-core', () => {
           services._getLocalStorageSafe.restore();
         }
       });
-
+  
       it('invokes initServiceCatalogs on ready, caches catalog, and stores in localStorage', async () => {
         // Arrange: authenticated credentials and spies
         services.webex.credentials = {
@@ -1170,20 +1343,10 @@ describe('webex-core', () => {
         const cacheSpy = sinon.spy(services, '_cacheCatalog');
         const setItemSpy = sinon.spy(global.window.localStorage, 'setItem');
         // Make fetch return a hostmap object and allow formatter to reduce it
-        sinon
-          .stub(services, 'request')
-          .resolves({
-            body: {
-              services: [],
-              activeServices: {},
-              timestamp: Date.now().toString(),
-              orgId: 'urn:EXAMPLE:org',
-              format: 'U2CV2',
-            },
-          });
-        // Cause loaded callback to run immediately
+        sinon.stub(services, 'request').resolves({body: {services: [], activeServices: {}, timestamp: Date.now().toString(), orgId: 'urn:EXAMPLE:org', format: 'U2CV2'}});
+        // Cause ready callback to run immediately
         services.listenToOnce = sinon.stub().callsFake((ctx, event, cb) => {
-          if (event === 'loaded') cb();
+          if (event === 'change:config' || event === 'ready') cb();
         });
 
         // Act
@@ -1223,9 +1386,9 @@ describe('webex-core', () => {
 
         const initSpy = sinon.spy(services, 'initServiceCatalogs');
         const cacheSpy = sinon.spy(services, '_cacheCatalog');
-        // Cause loaded callback to run immediately
+        // Cause ready callback to run immediately
         services.listenToOnce = sinon.stub().callsFake((ctx, event, cb) => {
-          if (event === 'loaded') cb();
+          if (event === 'change:config' || event === 'ready') cb();
         });
 
         // Act
@@ -1233,18 +1396,9 @@ describe('webex-core', () => {
         await waitForAsync();
 
         // Assert: ready path found cache and skipped initServiceCatalogs
-        assert.isFalse(
-          initSpy.called,
-          'expected initServiceCatalogs to be skipped with cache present'
-        );
-        assert.isTrue(
-          services._getCatalog().status.preauth.ready,
-          'preauth should be ready from cache'
-        );
-        assert.isTrue(
-          services._getCatalog().status.postauth.ready,
-          'postauth should be ready from cache'
-        );
+        assert.isFalse(initSpy.called, 'expected initServiceCatalogs to be skipped with cache present');
+        assert.isTrue(services._getCatalog().status.preauth.ready, 'preauth should be ready from cache');
+        assert.isTrue(services._getCatalog().status.postauth.ready, 'postauth should be ready from cache');
         assert.isFalse(cacheSpy.called, 'should not write cache during warm-up-only path');
 
         // Cleanup
@@ -1260,29 +1414,26 @@ describe('webex-core', () => {
           preauth: {serviceLinks: {}, hostCatalog: {}},
           postauth: {serviceLinks: {}, hostCatalog: {}},
         };
-
+  
         window.localStorage.setItem(CATALOG_CACHE_KEY_V1, JSON.stringify(staleCached));
-
+  
         const warmed = await services._loadCatalogFromCache();
-
+  
         assert.isFalse(warmed, 'stale cache must not warm');
-        assert.isNull(
-          window.localStorage.getItem(CATALOG_CACHE_KEY_V1),
-          'expired cache must be cleared'
-        );
+        assert.isNull(window.localStorage.getItem(CATALOG_CACHE_KEY_V1), 'expired cache must be cleared');
         assert.isFalse(catalog.status.preauth.ready);
         assert.isFalse(catalog.status.postauth.ready);
       });
-
+  
       it('clearCatalogCache() removes the cached entry', async () => {
         const CATALOG_CACHE_KEY_V1 = 'services.v1.u2cHostMap';
         window.localStorage.setItem(CATALOG_CACHE_KEY_V1, JSON.stringify({cachedAt: Date.now()}));
-
+  
         await services.clearCatalogCache();
-
+  
         assert.isNull(window.localStorage.getItem(CATALOG_CACHE_KEY_V1), 'cache should be cleared');
       });
-
+  
       it('still fetches when forceRefresh=true even if ready', async () => {
         const CATALOG_CACHE_KEY_V1 = 'services.v1.u2cHostMap';
         window.localStorage.setItem(
@@ -1294,24 +1445,20 @@ describe('webex-core', () => {
             postauth: {serviceLinks: {}, hostCatalog: {}},
           })
         );
-
+  
         // warm from cache
         const warmed = await services._loadCatalogFromCache();
         assert.isTrue(warmed);
         assert.isTrue(catalog.status.preauth.ready);
         assert.isTrue(catalog.status.postauth.ready);
-
+  
         const fetchSpy = sinon.spy(services, '_fetchNewServiceHostmap');
-
+  
         // with forceRefresh we should fetch despite ready=true
-        await services.updateServices({
-          from: 'limited',
-          query: {orgId: 'urn:EXAMPLE:org'},
-          forceRefresh: true,
-        });
+        await services.updateServices({from: 'limited', query: {orgId: 'urn:EXAMPLE:org'}, forceRefresh: true});
         // pass an empty query to avoid spreading undefined in qs construction
         await services.updateServices({forceRefresh: true});
-
+  
         assert.isTrue(fetchSpy.called, 'forceRefresh should bypass cache short-circuit');
         fetchSpy.restore();
       });
@@ -1372,11 +1519,9 @@ describe('webex-core', () => {
         );
         // formatter returns at least one entry to mark ready
         services._formatReceivedHostmap.restore && services._formatReceivedHostmap.restore();
-        sinon
-          .stub(services, '_formatReceivedHostmap')
-          .callsFake(() => [
-            {name: 'hydra', defaultUrl: 'https://api.ciscospark.com/v1', hosts: []},
-          ]);
+        sinon.stub(services, '_formatReceivedHostmap').callsFake(() => [
+          {name: 'hydra', defaultUrl: 'https://api.ciscospark.com/v1', hosts: []},
+        ]);
 
         const warmed = await services._loadCatalogFromCache();
         assert.isTrue(warmed);
@@ -1398,11 +1543,9 @@ describe('webex-core', () => {
           })
         );
         services._formatReceivedHostmap.restore && services._formatReceivedHostmap.restore();
-        sinon
-          .stub(services, '_formatReceivedHostmap')
-          .callsFake(() => [
-            {name: 'hydra', defaultUrl: 'https://api.ciscospark.com/v1', hosts: []},
-          ]);
+        sinon.stub(services, '_formatReceivedHostmap').callsFake(() => [
+          {name: 'hydra', defaultUrl: 'https://api.ciscospark.com/v1', hosts: []},
+        ]);
 
         const warmed = await services._loadCatalogFromCache();
         // function returns true if overall cache path succeeded; we only verify group readiness
@@ -1429,17 +1572,12 @@ describe('webex-core', () => {
           })
         );
         services._formatReceivedHostmap.restore && services._formatReceivedHostmap.restore();
-        sinon
-          .stub(services, '_formatReceivedHostmap')
-          .callsFake(() => [
-            {name: 'hydra', defaultUrl: 'https://api.ciscospark.com/v1', hosts: []},
-          ]);
+        sinon.stub(services, '_formatReceivedHostmap').callsFake(() => [
+          {name: 'hydra', defaultUrl: 'https://api.ciscospark.com/v1', hosts: []},
+        ]);
 
         await services._loadCatalogFromCache();
-        assert.isFalse(
-          catalog.status.preauth.ready,
-          'preauth should not warm on selection mismatch'
-        );
+        assert.isFalse(catalog.status.preauth.ready, 'preauth should not warm on selection mismatch');
       });
 
       it('skips warming when environment fingerprint mismatches', async () => {
@@ -1450,10 +1588,7 @@ describe('webex-core', () => {
           JSON.stringify({
             cachedAt: Date.now(),
             env: {fedramp: false, u2cDiscoveryUrl: 'https://u2c.other.com/u2c/api/v1'},
-            preauth: {
-              hostMap: {serviceLinks: {}, hostCatalog: {}},
-              meta: {selectionType: 'mode', selectionValue: 'DEFAULT_BY_PROXIMITY'},
-            },
+            preauth: {hostMap: {serviceLinks: {}, hostCatalog: {}}, meta: {selectionType: 'mode', selectionValue: 'DEFAULT_BY_PROXIMITY'}},
           })
         );
         // current env
@@ -1468,6 +1603,7 @@ describe('webex-core', () => {
         assert.isFalse(catalog.status.postauth.ready);
       });
     });
+    
   });
 });
 /* eslint-enable no-underscore-dangle */