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

package/test/unit/spec/services-v2/services-v2.ts

@@ -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();
 
@@ -116,7 +71,7 @@ describe('webex-core', () => {
         {error: new Error('failed'), expectedMessage: 'failed'},
         {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}`
@@ -147,7 +100,7 @@ describe('webex-core', () => {
         {error: new Error('failed'), expectedMessage: 'failed'},
         {error: undefined, expectedMessage: undefined},
       ])(
-        'sets initFailed to true when initServiceCatalogs errors but still sets ready to true',
+        'sets initFailed to true when initServiceCatalogs errors',
         async ({error, expectedMessage}) => {
           services.initServiceCatalogs = sinon.stub().callsFake(() => {
             return Promise.reject(error);
@@ -160,18 +113,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 credentials available, ${expectedMessage}`
@@ -179,98 +130,295 @@ describe('webex-core', () => {
         }
       );
 
-      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();
+        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;
+        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();
+        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]();
+
+        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: (() => void) | undefined;
+        services.webex.credentials = {
+          supertoken: {access_token: 'token'},
+          isRefreshing: true,
+          once: sinon.stub().callsFake((event: string, cb: () => void) => {
+            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');
+
+        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();
+        services.listenToOnce.getCall(0).args[2]();
+        services.listenToOnce.getCall(1).args[2]();
+        await waitForAsync();
+
+        const freshLoginCall = services.listenToOnce
+          .getCalls()
+          .find((call: any) => call.args[1] === 'change:canAuthorize');
+        assert.isDefined(freshLoginCall, 'expected change:canAuthorize listener to be registered');
+
+        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: any) => call.args[1] === 'change:canAuthorize');
+
+        services.webex.canAuthorize = true;
+        currentCatalog.status.postauth.ready = true;
+        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: (() => void) | undefined;
+        services.webex.credentials = {
+          isRefreshing: true,
+          once: sinon.stub().callsFake((event: string, cb: () => void) => {
+            if (event === 'change:isRefreshing') onChangeIsRefreshing = cb;
+          }),
+        };
+
+        const settled = services._finalizeReady();
+        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);
       });
     });
 
@@ -425,7 +573,7 @@ describe('webex-core', () => {
 
         services.initServiceCatalogs = sinon.stub().returns(Promise.resolve());
         services.webex.credentials = {
-          getOrgId: sinon.stub().returns(''),
+          getOrgId: sinon.stub().returns('')
         };
         catalog.status = {};
       });
@@ -466,7 +614,7 @@ describe('webex-core', () => {
         const serviceGroup = 'postauth';
         const hostmap = {services: [{hostmap: 'hostmap'}]};
 
-        services._formatReceivedHostmap = sinon.stub().returns({services: [{some: 'hostmap'}]});
+        services._formatReceivedHostmap = sinon.stub().returns({services : [{some: 'hostmap'}]});
 
         catalog.updateServiceGroups = sinon.stub().returns(Promise.resolve([{some: 'value'}]));
 
@@ -482,7 +630,7 @@ describe('webex-core', () => {
         const serviceGroup = 'postauth';
         const hostmap = {};
 
-        services._formatReceivedHostmap = sinon.stub().returns({services: undefined});
+        services._formatReceivedHostmap = sinon.stub().returns({services : undefined});
 
         catalog.updateServiceGroups = sinon.stub().returns(Promise.resolve([{some: 'value'}]));
 
@@ -527,6 +675,22 @@ describe('webex-core', () => {
         );
       });
 
+      it('includes the catalog override query when configured', async () => {
+        services.webex.config.services = {useCatalogOverride: true};
+        sinon.stub(services, '_formatReceivedHostmap').resolves('map response');
+        sinon.stub(services, 'request').resolves({});
+
+        await services._fetchNewServiceHostmap({from: 'limited'});
+
+        assert.calledOnceWithExactly(services.request, {
+          method: 'GET',
+          service: 'u2c',
+          resource: '/limited/catalog',
+          qs: {format: 'U2CV2', useCatalogOverride: true},
+          headers: {},
+        });
+      });
+
       it('checks service request rejects', async () => {
         const error = new Error('some error');
 
@@ -721,13 +885,13 @@ describe('webex-core', () => {
     });
 
     describe('#invalidateCache', () => {
-      beforeEach(() => {
+      beforeEach( () => {
         services.initServiceCatalogs = sinon.stub().returns(Promise.resolve());
         services.webex.credentials = {
-          getOrgId: sinon.stub().returns(''),
+          getOrgId: sinon.stub().returns('')
         };
         catalog.status = {};
-      });
+      })
       it('should log the timestamp parameter', async () => {
         const timestamp = '1234567890';
         services.logger.info = sinon.stub();
@@ -735,11 +899,7 @@ describe('webex-core', () => {
 
         await services.invalidateCache(timestamp);
 
-        assert.calledWith(
-          services.logger.info,
-          'services: invalidate cache, timestamp:',
-          timestamp
-        );
+        assert.calledWith(services.logger.info, 'services: invalidate cache, timestamp:', timestamp);
       });
 
       it('should call initServiceCatalogs when invalidate timestamp is newer than catalog timestamp', async () => {
@@ -866,30 +1026,30 @@ describe('webex-core', () => {
         // Arrange: seed internal _services with mobius (including duplicate baseUrl)
         services._services = [
           {
-            id: 'urn:TEAM:us-east-2_a:mobius',
-            serviceName: 'mobius',
-            serviceUrls: [
-              {baseUrl: 'https://mobius-us-east-2.prod.infra.webex.com/api/v1', priority: 5},
-              {baseUrl: 'https://mobius-eu-central-1.prod.infra.webex.com/api/v1', priority: 10},
-              {baseUrl: 'https://mobius-ap-southeast-2.prod.infra.webex.com/api/v1', priority: 15}, // duplicate
+            "id": "urn:TEAM:us-east-2_a:mobius",
+            "serviceName": 'mobius',
+            "serviceUrls": [
+              {"baseUrl": 'https://mobius-us-east-2.prod.infra.webex.com/api/v1', "priority": 5},
+              {"baseUrl": 'https://mobius-eu-central-1.prod.infra.webex.com/api/v1', "priority": 10},
+              {"baseUrl": 'https://mobius-ap-southeast-2.prod.infra.webex.com/api/v1', "priority": 15}, // duplicate
             ],
           },
           {
-            id: 'urn:TEAM:ap-southeast-2_m:mobius',
-            serviceName: 'mobius',
-            serviceUrls: [
-              {
-                baseUrl: 'https://mobius-me-central-1.prod.infra.webex.com/api/v1',
-                priority: 5,
-              },
-              {
-                baseUrl: 'https://mobius-eu-central-1.prod.infra.webex.com/api/v1',
-                priority: 10,
-              },
-              {
-                baseUrl: 'https://mobius-ap-southeast-2.prod.infra.webex.com/api/v1',
-                priority: 15,
-              },
+            "id": "urn:TEAM:ap-southeast-2_m:mobius",
+            "serviceName": "mobius",
+            "serviceUrls": [
+                {
+                    "baseUrl": "https://mobius-me-central-1.prod.infra.webex.com/api/v1",
+                    "priority": 5
+                },
+                {
+                    "baseUrl": "https://mobius-eu-central-1.prod.infra.webex.com/api/v1",
+                    "priority": 10
+                },
+                {
+                    "baseUrl": "https://mobius-ap-southeast-2.prod.infra.webex.com/api/v1",
+                    "priority": 15
+                },
             ],
           },
           // Non-mobius service should be ignored by getMobiusClusters
@@ -907,64 +1067,42 @@ describe('webex-core', () => {
         assert.deepEqual(
           clusters.map(({host, id, ttl, priority}) => ({host, id, ttl, priority})),
           [
-            {
-              host: 'mobius-us-east-2.prod.infra.webex.com',
-              id: 'urn:TEAM:us-east-2_a:mobius',
-              ttl: 0,
-              priority: 5,
-            },
-            {
-              host: 'mobius-eu-central-1.prod.infra.webex.com',
-              id: 'urn:TEAM:us-east-2_a:mobius',
-              ttl: 0,
-              priority: 10,
-            },
-            {
-              host: 'mobius-ap-southeast-2.prod.infra.webex.com',
-              id: 'urn:TEAM:us-east-2_a:mobius',
-              ttl: 0,
-              priority: 15,
-            },
-            {
-              host: 'mobius-me-central-1.prod.infra.webex.com',
-              id: 'urn:TEAM:ap-southeast-2_m:mobius',
-              ttl: 0,
-              priority: 5,
-            },
+            {host: 'mobius-us-east-2.prod.infra.webex.com', id: 'urn:TEAM:us-east-2_a:mobius', ttl: 0, priority: 5},
+            {host: 'mobius-eu-central-1.prod.infra.webex.com', id: 'urn:TEAM:us-east-2_a:mobius', ttl: 0, priority: 10},
+            {host: 'mobius-ap-southeast-2.prod.infra.webex.com', id: 'urn:TEAM:us-east-2_a:mobius', ttl: 0, priority: 15},
+            {host: 'mobius-me-central-1.prod.infra.webex.com', id: 'urn:TEAM:ap-southeast-2_m:mobius', ttl: 0, priority: 5},
           ]
         );
       });
     });
-
+    
     describe('#isValidHost', () => {
       beforeEach(() => {
         // Setting up a mock services list
-        services._services = [
-          {
-            id: 'urn:IDENTITY:PC75:adminAudit',
-            serviceName: 'adminAudit',
-            serviceUrls: [
-              {
-                baseUrl: 'https://audit-ci-r.wbx2.com/audit-ci/api/v2',
-                priority: 5,
-              },
-              {
-                baseUrl: 'https://audit-ci-t.wbx2.com/audit-ci/api/v2',
-                priority: 10,
-              },
-            ],
-          },
-          {
-            id: 'urn:IDENTITY:PC75:cdf',
-            serviceName: 'cdf',
-            serviceUrls: [
-              {
-                baseUrl: 'https://wapdavis.webex.com/davis/api/v1',
-                priority: 5,
-              },
-            ],
-          },
-        ];
+         services._services = [{
+            "id": "urn:IDENTITY:PC75:adminAudit",
+            "serviceName": "adminAudit",
+            "serviceUrls": [
+                {
+                    "baseUrl": "https://audit-ci-r.wbx2.com/audit-ci/api/v2",
+                    "priority": 5
+                },
+                 {
+                    "baseUrl": "https://audit-ci-t.wbx2.com/audit-ci/api/v2",
+                    "priority": 10
+                }
+            ]
+        },
+         {
+            "id": "urn:IDENTITY:PC75:cdf",
+            "serviceName": "cdf",
+            "serviceUrls": [
+                {
+                    "baseUrl": "https://wapdavis.webex.com/davis/api/v1",
+                    "priority": 5
+                }
+            ]
+        }];
       });
       afterAll(() => {
         // Clean up the mock services list
@@ -988,6 +1126,57 @@ 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 (v2)', () => {
       const CATALOG_CACHE_KEY_V2 = 'services.v2.u2cHostMap';
       let windowBackup;