test(cliproxy): stabilize routing strategy config scope

tests/unit/cliproxy/routing-strategy.test.ts

@@ -5,8 +5,8 @@ import * as path from 'path';
 
 describe('cliproxy routing strategy service', () => {
   let tempHome = '';
-  let originalCcsHome: string | undefined;
+  let scopedConfigDir = '';
-  let setGlobalConfigDir: (dir: string | undefined) => void;
+  let runWithScopedConfigDir: <T>(ccsDir: string, fn: () => Promise<T> | T) => Promise<T>;
   let routingTarget = {
     host: '127.0.0.1',
     port: 8317,
@@ -16,29 +16,24 @@ describe('cliproxy routing strategy service', () => {
   let responseFactory: (() => Promise<Response>) | null = null;
 
   beforeEach(async () => {
-    originalCcsHome = process.env.CCS_HOME;
     tempHome = fs.mkdtempSync(path.join(os.tmpdir(), 'ccs-routing-strategy-'));
-    process.env.CCS_HOME = tempHome;
+    scopedConfigDir = path.join(tempHome, '.ccs');
 
-    ({ setGlobalConfigDir } = await import('../../../src/utils/config-manager'));
+    ({ runWithScopedConfigDir } = await import('../../../src/utils/config-manager'));
-    setGlobalConfigDir(path.join(tempHome, '.ccs'));
   });
 
   afterEach(() => {
     mock.restore();
-    setGlobalConfigDir(undefined);
-
-    if (originalCcsHome !== undefined) {
-      process.env.CCS_HOME = originalCcsHome;
-    } else {
-      delete process.env.CCS_HOME;
-    }
 
     if (tempHome && fs.existsSync(tempHome)) {
       fs.rmSync(tempHome, { recursive: true, force: true });
     }
   });
 
+  async function withScopedConfig<T>(fn: () => Promise<T> | T): Promise<T> {
+    return await runWithScopedConfigDir(scopedConfigDir, fn);
+  }
+
   async function loadRoutingModule() {
     mock.module('../../../src/cliproxy/routing-strategy-http', () => ({
       getCliproxyRoutingTarget: () => routingTarget,
@@ -58,6 +53,7 @@ describe('cliproxy routing strategy service', () => {
   }
 
   it('normalizes canonical and shorthand strategy values', async () => {
+    await withScopedConfig(async () => {
       const mod = await loadRoutingModule();
 
       expect(mod.normalizeCliproxyRoutingStrategy('round-robin')).toBe('round-robin');
@@ -66,8 +62,10 @@ describe('cliproxy routing strategy service', () => {
       expect(mod.normalizeCliproxyRoutingStrategy('ff')).toBe('fill-first');
       expect(mod.normalizeCliproxyRoutingStrategy('nope')).toBeNull();
     });
+  });
 
   it('falls back to the saved local default when live CLIProxy is unavailable', async () => {
+    await withScopedConfig(async () => {
       const { mutateUnifiedConfig } = await import('../../../src/config/unified-config-loader');
       mutateUnifiedConfig((config) => {
         if (config.cliproxy) {
@@ -83,21 +81,25 @@ describe('cliproxy routing strategy service', () => {
       expect(state.target).toBe('local');
       expect(state.reachable).toBe(false);
     });
+  });
 
   it('persists the local startup default even when the live proxy is down', async () => {
+    await withScopedConfig(async () => {
       const mod = await loadRoutingModule();
       const result = await mod.applyCliproxyRoutingStrategy('fill-first');
 
       expect(result.applied).toBe('config-only');
       expect(result.strategy).toBe('fill-first');
 
-    const configPath = path.join(tempHome, '.ccs', 'cliproxy', 'config.yaml');
+      const configPath = path.join(scopedConfigDir, 'cliproxy', 'config.yaml');
       const configContent = fs.readFileSync(configPath, 'utf8');
       expect(configContent).toContain('routing:');
       expect(configContent).toContain('strategy: fill-first');
     });
+  });
 
   it('reads and writes remote strategy without mutating the local default', async () => {
+    await withScopedConfig(async () => {
       routingTarget = {
         host: 'remote.example.com',
         port: 8080,
@@ -125,3 +127,4 @@ describe('cliproxy routing strategy service', () => {
       expect(methodCount).toBe(2);
     });
   });
+});