@webex/webex-core 3.12.0-task-refactor.1 → 3.12.0-webex-services-ready.1

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

@@ -34,6 +34,53 @@ 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());
@@ -45,7 +92,7 @@ describe('webex-core', () => {
 
         services.initialize();
 
-        // call the onReady callback
+        // call the onLoaded callback
         services.listenToOnce.getCall(1).args[2]();
         await waitForAsync();
 
@@ -58,7 +105,7 @@ describe('webex-core', () => {
 
         services.initialize();
 
-        // call the onReady callback
+        // call the onLoaded callback
         services.listenToOnce.getCall(1).args[2]();
         await waitForAsync();
 
@@ -69,7 +116,7 @@ describe('webex-core', () => {
         {error: new Error('failed'), expectedMessage: 'failed'},
         {error: undefined, expectedMessage: undefined},
       ])(
-        'sets initFailed to true when collectPreauthCatalog errors',
+        'sets initFailed to true when collectPreauthCatalog errors but still sets ready to true',
         async ({error, expectedMessage}) => {
           services.collectPreauthCatalog = sinon.stub().callsFake(() => {
             return Promise.reject(error);
@@ -77,15 +124,18 @@ describe('webex-core', () => {
 
           services.listenToOnce = sinon.stub();
           services.logger.error = sinon.stub();
+          services.trigger = sinon.stub();
 
           services.initialize();
 
-          // call the onReady callback
+          // call the onLoaded callback
           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}`
@@ -97,7 +147,7 @@ describe('webex-core', () => {
         {error: new Error('failed'), expectedMessage: 'failed'},
         {error: undefined, expectedMessage: undefined},
       ])(
-        'sets initFailed to true when initServiceCatalogs errors',
+        '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);
@@ -110,21 +160,118 @@ describe('webex-core', () => {
 
           services.listenToOnce = sinon.stub();
           services.logger.error = sinon.stub();
+          services.trigger = sinon.stub();
 
           services.initialize();
 
-          // call the onReady callback
+          // call the onLoaded callback
           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}`
           );
         }
       );
+
+      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 = {};
+
+          services.initialize();
+
+          // Get the catalog after initialize creates it
+          const testCatalog = services._getCatalog();
+          testCatalog.status.postauth.ready = false;
+
+          // call the onLoaded callback (preauth path)
+          services.listenToOnce.getCall(1).args[2]();
+          await waitForAsync();
+
+          // Now set canAuthorize to true to simulate auth completing
+          services.webex.canAuthorize = true;
+
+          // call the change:canAuthorize callback (should be call 2)
+          services.listenToOnce.getCall(2).args[2]();
+          await waitForAsync();
+
+          sinon.assert.calledOnce(services.initServiceCatalogs);
+          assert.isTrue(testCatalog.isReady);
+        });
+
+        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 = {};
+
+          services.initialize();
+
+          // Get the catalog after initialize creates it
+          const testCatalog = services._getCatalog();
+
+          // call the onLoaded callback (preauth path)
+          services.listenToOnce.getCall(1).args[2]();
+          await waitForAsync();
+
+          // Set canAuthorize to true and postauth as ready BEFORE calling the callback
+          services.webex.canAuthorize = true;
+          testCatalog.status.postauth.ready = true;
+
+          // call the change:canAuthorize callback (should be call 2)
+          services.listenToOnce.getCall(2).args[2]();
+          await waitForAsync();
+
+          sinon.assert.notCalled(services.initServiceCatalogs);
+        });
+
+        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 = {};
+
+          services.initialize();
+
+          // Get the catalog after initialize creates it
+          const testCatalog = services._getCatalog();
+          testCatalog.status.postauth.ready = false;
+
+          // call the onLoaded callback (preauth path)
+          services.listenToOnce.getCall(1).args[2]();
+          await waitForAsync();
+
+          // Now set canAuthorize to true to simulate auth completing
+          services.webex.canAuthorize = true;
+
+          // call the change:canAuthorize callback (should be call 2)
+          services.listenToOnce.getCall(2).args[2]();
+          await waitForAsync();
+
+          sinon.assert.calledWith(
+            services.logger.error,
+            'services: failed to init service catalogs after auth, auth failed'
+          );
+        });
+      });
     });
 
     describe('#initServiceCatalogs', () => {
@@ -278,7 +425,7 @@ describe('webex-core', () => {
 
         services.initServiceCatalogs = sinon.stub().returns(Promise.resolve());
         services.webex.credentials = {
-          getOrgId: sinon.stub().returns('')
+          getOrgId: sinon.stub().returns(''),
         };
         catalog.status = {};
       });
@@ -319,7 +466,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'}]));
 
@@ -335,7 +482,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'}]));
 
@@ -574,13 +721,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();
@@ -588,7 +735,11 @@ 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 () => {
@@ -715,30 +866,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
@@ -756,41 +907,64 @@ 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
@@ -813,5 +987,253 @@ describe('webex-core', () => {
         assert.isFalse(services.isValidHost([]));
       });
     });
+
+    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;
+      let localStorageBackup;
+
+      const makeLocalStorageShim = () => {
+        const store = new Map<string, string>();
+        return {
+          getItem: (k: string) => (store.has(k) ? store.get(k) : null),
+          setItem: (k: string, v: string) => store.set(k, v),
+          removeItem: (k: string) => store.delete(k),
+          _store: store,
+        };
+      };
+
+      beforeEach(() => {
+        // Stub window.localStorage
+        windowBackup = global.window;
+        if (!global.window) global.window = {} as Window & typeof globalThis;
+        localStorageBackup = global.window.localStorage;
+        global.window.localStorage = makeLocalStorageShim();
+        // Enable U2C caching feature flag for tests that depend on cache writes/reads
+        services.webex.config = services.webex.config || {};
+        services.webex.config.calling = {...(services.webex.config.calling || {}), cacheU2C: true};
+        // Ensure code under test uses our shim via util method
+        sinon.stub(services, '_getLocalStorageSafe').returns(global.window.localStorage);
+        // default current env
+        services.webex.config = services.webex.config || {};
+        services.webex.config.services = services.webex.config.services || {discovery: {}};
+        services.webex.config.services.discovery.u2c =
+          services.webex.config.services.discovery.u2c || 'https://u2c.wbx2.com/u2c/api/v1';
+        services.webex.config.fedramp =
+          typeof services.webex.config.fedramp === 'boolean'
+            ? services.webex.config.fedramp
+            : false;
+      });
+
+      afterEach(() => {
+        global.window.localStorage = localStorageBackup || undefined;
+        if (!windowBackup) {
+          delete global.window;
+        } else {
+          global.window = windowBackup;
+        }
+        // Restore util stub if present
+        if (services._getLocalStorageSafe && services._getLocalStorageSafe.restore) {
+          services._getLocalStorageSafe.restore();
+        }
+      });
+
+      it('stores selection metadata and env on cache write for preauth', async () => {
+        // Arrange env
+        services.webex.config.services.discovery.u2c = 'https://u2c.wbx2.com/u2c/api/v1';
+        services.webex.config.fedramp = false;
+
+        // Act
+        await services._cacheCatalog(
+          'preauth',
+          {services: [], timestamp: Date.now().toString()},
+          {selectionType: 'orgId', selectionValue: 'urn:EXAMPLE:org'}
+        );
+
+        // Assert
+        const raw = window.localStorage.getItem(CATALOG_CACHE_KEY_V2);
+        assert.isString(raw);
+        const parsed = JSON.parse(raw as string);
+        assert.deepEqual(parsed.env, {
+          fedramp: false,
+          u2cDiscoveryUrl: 'https://u2c.wbx2.com/u2c/api/v1',
+        });
+        assert.isObject(parsed.preauth);
+        assert.deepEqual(parsed.preauth.meta, {
+          selectionType: 'orgId',
+          selectionValue: 'urn:EXAMPLE:org',
+        });
+      });
+
+      it('warms preauth from cache when selection meta matches intended orgId', async () => {
+        // Arrange current env and credentials
+        services.webex.config.services.discovery.u2c = 'https://u2c.wbx2.com/u2c/api/v1';
+        services.webex.config.fedramp = false;
+        services.webex.credentials = {
+          canAuthorize: true,
+          getOrgId: sinon.stub().returns('urn:EXAMPLE:org'),
+        };
+        // Seed cache
+        window.localStorage.setItem(
+          CATALOG_CACHE_KEY_V2,
+          JSON.stringify({
+            cachedAt: Date.now(),
+            env: {fedramp: false, u2cDiscoveryUrl: 'https://u2c.wbx2.com/u2c/api/v1'},
+            preauth: {
+              hostMap: {services: [], timestamp: '1'},
+              meta: {selectionType: 'orgId', selectionValue: 'urn:EXAMPLE:org'},
+            },
+          })
+        );
+        // Spy updateServiceGroups
+        const spy = sinon.spy(services._getCatalog(), 'updateServiceGroups');
+
+        // Act
+        const warmed = await services._loadCatalogFromCache();
+
+        // Assert
+        assert.isTrue(warmed);
+        assert.isTrue(
+          spy.calledWith('preauth', [], '1'),
+          'expected preauth to be warmed when selection matches'
+        );
+        spy.restore && spy.restore();
+      });
+
+      it('does not warm preauth when selection meta is proximity mode', async () => {
+        // Arrange env
+        services.webex.config.services.discovery.u2c = 'https://u2c.wbx2.com/u2c/api/v1';
+        services.webex.config.fedramp = false;
+        window.localStorage.setItem(
+          CATALOG_CACHE_KEY_V2,
+          JSON.stringify({
+            cachedAt: Date.now(),
+            env: {fedramp: false, u2cDiscoveryUrl: 'https://u2c.wbx2.com/u2c/api/v1'},
+            preauth: {
+              hostMap: {services: [], timestamp: '1'},
+              meta: {selectionType: 'mode', selectionValue: 'DEFAULT_BY_PROXIMITY'},
+            },
+          })
+        );
+        const spy = sinon.spy(services._getCatalog(), 'updateServiceGroups');
+
+        // Act
+        const warmed = await services._loadCatalogFromCache();
+
+        // Assert: overall warm-up succeeds, but preauth is skipped
+        assert.isTrue(warmed);
+        assert.isFalse(
+          spy.calledWith('preauth', sinon.match.any, sinon.match.any),
+          'expected preauth not to be warmed for proximity mode'
+        );
+        spy.restore && spy.restore();
+      });
+
+      it('does not warm preauth when selection meta mismatches intended selection', async () => {
+        // Arrange env and credentials
+        services.webex.config.services.discovery.u2c = 'https://u2c.wbx2.com/u2c/api/v1';
+        services.webex.config.fedramp = false;
+        services.webex.credentials = {
+          canAuthorize: true,
+          getOrgId: sinon.stub().returns('urn:EXAMPLE:org'),
+        };
+        window.localStorage.setItem(
+          CATALOG_CACHE_KEY_V2,
+          JSON.stringify({
+            cachedAt: Date.now(),
+            env: {fedramp: false, u2cDiscoveryUrl: 'https://u2c.wbx2.com/u2c/api/v1'},
+            preauth: {
+              hostMap: {services: [], timestamp: '1'},
+              meta: {selectionType: 'orgId', selectionValue: 'urn:DIFF:org'},
+            },
+          })
+        );
+        const spy = sinon.spy(services._getCatalog(), 'updateServiceGroups');
+
+        const warmed = await services._loadCatalogFromCache();
+
+        assert.isTrue(warmed);
+        assert.isFalse(
+          spy.calledWith('preauth', sinon.match.any, sinon.match.any),
+          'expected preauth not to be warmed on selection mismatch'
+        );
+        spy.restore && spy.restore();
+      });
+
+      it('skips warm entirely when environment fingerprint mismatches', async () => {
+        // Cached env differs from current env
+        services.webex.config.services.discovery.u2c = 'https://u2c.current.com/u2c/api/v1';
+        services.webex.config.fedramp = false;
+        window.localStorage.setItem(
+          CATALOG_CACHE_KEY_V2,
+          JSON.stringify({
+            cachedAt: Date.now(),
+            env: {fedramp: false, u2cDiscoveryUrl: 'https://u2c.cached.com/u2c/api/v1'},
+            preauth: {
+              hostMap: {services: [], timestamp: '1'},
+              meta: {selectionType: 'orgId', selectionValue: 'urn:EXAMPLE:org'},
+            },
+          })
+        );
+        const spy = sinon.spy(services._getCatalog(), 'updateServiceGroups');
+
+        const warmed = await services._loadCatalogFromCache();
+
+        assert.isFalse(warmed, 'env mismatch should skip warm and return false');
+        assert.isFalse(spy.called, 'no group should be warmed on env mismatch');
+        spy.restore && spy.restore();
+      });
+    });
   });
 });