@google/gemini-cli-core 0.34.0-preview.2 → 0.35.0-nightly.20260313.bb060d7a9

package/dist/src/config/config.test.js

@@ -5,6 +5,7 @@
  */
 import { describe, it, expect, vi, beforeEach, afterEach, } from 'vitest';
 import { Config, DEFAULT_FILE_FILTERING_OPTIONS, } from './config.js';
+import { createMockSandboxConfig } from '@google/gemini-cli-test-utils';
 import { DEFAULT_MAX_ATTEMPTS } from '../utils/retry.js';
 import { ExperimentFlags } from '../code_assist/experiments/flagNames.js';
 import { debugLogger } from '../utils/debugLogger.js';
@@ -182,10 +183,10 @@ vi.mock('../code_assist/codeAssist.js');
 vi.mock('../code_assist/experiments/experiments.js');
 describe('Server Config (config.ts)', () => {
     const MODEL = DEFAULT_GEMINI_MODEL;
-    const SANDBOX = {
+    const SANDBOX = createMockSandboxConfig({
         command: 'docker',
         image: 'gemini-cli-sandbox',
-    };
+    });
     const TARGET_DIR = '/path/to/target';
     const DEBUG_MODE = false;
     const QUESTION = 'test question';
@@ -385,6 +386,88 @@ describe('Server Config (config.ts)', () => {
                 expect(await config.getUserCaching()).toBeUndefined();
             });
         });
+        describe('getNumericalRoutingEnabled', () => {
+            it('should return true by default if there are no experiments', async () => {
+                const config = new Config(baseParams);
+                expect(await config.getNumericalRoutingEnabled()).toBe(true);
+            });
+            it('should return true if the remote flag is set to true', async () => {
+                const config = new Config({
+                    ...baseParams,
+                    experiments: {
+                        flags: {
+                            [ExperimentFlags.ENABLE_NUMERICAL_ROUTING]: {
+                                boolValue: true,
+                            },
+                        },
+                        experimentIds: [],
+                    },
+                });
+                expect(await config.getNumericalRoutingEnabled()).toBe(true);
+            });
+            it('should return false if the remote flag is explicitly set to false', async () => {
+                const config = new Config({
+                    ...baseParams,
+                    experiments: {
+                        flags: {
+                            [ExperimentFlags.ENABLE_NUMERICAL_ROUTING]: {
+                                boolValue: false,
+                            },
+                        },
+                        experimentIds: [],
+                    },
+                });
+                expect(await config.getNumericalRoutingEnabled()).toBe(false);
+            });
+        });
+        describe('getResolvedClassifierThreshold', () => {
+            it('should return 90 by default if there are no experiments', async () => {
+                const config = new Config(baseParams);
+                expect(await config.getResolvedClassifierThreshold()).toBe(90);
+            });
+            it('should return the remote flag value if it is within range (0-100)', async () => {
+                const config = new Config({
+                    ...baseParams,
+                    experiments: {
+                        flags: {
+                            [ExperimentFlags.CLASSIFIER_THRESHOLD]: {
+                                intValue: '75',
+                            },
+                        },
+                        experimentIds: [],
+                    },
+                });
+                expect(await config.getResolvedClassifierThreshold()).toBe(75);
+            });
+            it('should return 90 if the remote flag is out of range (less than 0)', async () => {
+                const config = new Config({
+                    ...baseParams,
+                    experiments: {
+                        flags: {
+                            [ExperimentFlags.CLASSIFIER_THRESHOLD]: {
+                                intValue: '-10',
+                            },
+                        },
+                        experimentIds: [],
+                    },
+                });
+                expect(await config.getResolvedClassifierThreshold()).toBe(90);
+            });
+            it('should return 90 if the remote flag is out of range (greater than 100)', async () => {
+                const config = new Config({
+                    ...baseParams,
+                    experiments: {
+                        flags: {
+                            [ExperimentFlags.CLASSIFIER_THRESHOLD]: {
+                                intValue: '110',
+                            },
+                        },
+                        experimentIds: [],
+                    },
+                });
+                expect(await config.getResolvedClassifierThreshold()).toBe(90);
+            });
+        });
     });
     describe('refreshAuth', () => {
         it('should refresh auth and update config', async () => {
@@ -1115,13 +1198,55 @@ describe('Server Config (config.ts)', () => {
             expect(browserConfig.customConfig.sessionMode).toBe('persistent');
         });
     });
+    describe('Sandbox Configuration', () => {
+        it('should default sandbox settings when not provided', () => {
+            const config = new Config({
+                ...baseParams,
+                sandbox: undefined,
+            });
+            expect(config.getSandboxEnabled()).toBe(false);
+            expect(config.getSandboxAllowedPaths()).toEqual([]);
+            expect(config.getSandboxNetworkAccess()).toBe(false);
+        });
+        it('should store provided sandbox settings', () => {
+            const sandbox = {
+                enabled: true,
+                allowedPaths: ['/tmp/foo', '/var/bar'],
+                networkAccess: true,
+                command: 'docker',
+                image: 'my-image',
+            };
+            const config = new Config({
+                ...baseParams,
+                sandbox,
+            });
+            expect(config.getSandboxEnabled()).toBe(true);
+            expect(config.getSandboxAllowedPaths()).toEqual(['/tmp/foo', '/var/bar']);
+            expect(config.getSandboxNetworkAccess()).toBe(true);
+            expect(config.getSandbox()?.command).toBe('docker');
+            expect(config.getSandbox()?.image).toBe('my-image');
+        });
+        it('should partially override default sandbox settings', () => {
+            const config = new Config({
+                ...baseParams,
+                sandbox: {
+                    enabled: true,
+                    allowedPaths: ['/only/this'],
+                    networkAccess: false,
+                },
+            });
+            expect(config.getSandboxEnabled()).toBe(true);
+            expect(config.getSandboxAllowedPaths()).toEqual(['/only/this']);
+            expect(config.getSandboxNetworkAccess()).toBe(false);
+        });
+    });
 });
 describe('GemmaModelRouterSettings', () => {
     const MODEL = DEFAULT_GEMINI_MODEL;
-    const SANDBOX = {
+    const SANDBOX = createMockSandboxConfig({
         command: 'docker',
         image: 'gemini-cli-sandbox',
-    };
+    });
     const TARGET_DIR = '/path/to/target';
     const DEBUG_MODE = false;
     const QUESTION = 'test question';
@@ -1408,10 +1533,10 @@ describe('isYoloModeDisabled', () => {
 });
 describe('BaseLlmClient Lifecycle', () => {
     const MODEL = 'gemini-pro';
-    const SANDBOX = {
+    const SANDBOX = createMockSandboxConfig({
         command: 'docker',
         image: 'gemini-cli-sandbox',
-    };
+    });
     const TARGET_DIR = '/path/to/target';
     const DEBUG_MODE = false;
     const QUESTION = 'test question';
@@ -1450,10 +1575,10 @@ describe('BaseLlmClient Lifecycle', () => {
 });
 describe('Generation Config Merging (HACK)', () => {
     const MODEL = 'gemini-pro';
-    const SANDBOX = {
+    const SANDBOX = createMockSandboxConfig({
         command: 'docker',
         image: 'gemini-cli-sandbox',
-    };
+    });
     const TARGET_DIR = '/path/to/target';
     const DEBUG_MODE = false;
     const QUESTION = 'test question';
@@ -1695,10 +1820,10 @@ describe('Config getHooks', () => {
 });
 describe('LocalLiteRtLmClient Lifecycle', () => {
     const MODEL = 'gemini-pro';
-    const SANDBOX = {
+    const SANDBOX = createMockSandboxConfig({
         command: 'docker',
         image: 'gemini-cli-sandbox',
-    };
+    });
     const TARGET_DIR = '/path/to/target';
     const DEBUG_MODE = false;
     const QUESTION = 'test question';
@@ -1962,6 +2087,9 @@ describe('Config Quota & Preview Model Access', () => {
         usageStatisticsEnabled: false,
         embeddingModel: 'gemini-embedding',
         sandbox: {
+            enabled: true,
+            allowedPaths: [],
+            networkAccess: false,
             command: 'docker',
             image: 'gemini-cli-sandbox',
         },
@@ -2454,4 +2582,36 @@ describe('Model Persistence Bug Fix (#19864)', () => {
         expect(config.getModel()).toBe(PREVIEW_GEMINI_3_1_MODEL);
     });
 });
+describe('ConfigSchema validation', () => {
+    it('should validate a valid sandbox config', async () => {
+        const validConfig = {
+            sandbox: {
+                enabled: true,
+                allowedPaths: ['/tmp'],
+                networkAccess: false,
+                command: 'docker',
+                image: 'node:20',
+            },
+        };
+        const { ConfigSchema } = await import('./config.js');
+        const result = ConfigSchema.safeParse(validConfig);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.sandbox?.enabled).toBe(true);
+        }
+    });
+    it('should apply defaults in ConfigSchema', async () => {
+        const minimalConfig = {
+            sandbox: {},
+        };
+        const { ConfigSchema } = await import('./config.js');
+        const result = ConfigSchema.safeParse(minimalConfig);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.sandbox?.enabled).toBe(false);
+            expect(result.data.sandbox?.allowedPaths).toEqual([]);
+            expect(result.data.sandbox?.networkAccess).toBe(false);
+        }
+    });
+});
 //# sourceMappingURL=config.test.js.map