@google/gemini-cli 0.19.0-nightly.20251121.5982abeff → 0.19.0-nightly.20251123.dadd606c0

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

@@ -104,76 +104,42 @@ describe('Settings Loading and Merging', () => {
             expect(settings.workspace.settings).toEqual({});
             expect(settings.merged).toEqual({});
         });
-        it('should load system settings if only system file exists', () => {
-            mockFsExistsSync.mockImplementation((p) => p === getSystemSettingsPath());
-            const systemSettingsContent = {
-                ui: {
-                    theme: 'system-default',
-                },
-                tools: {
-                    sandbox: false,
-                },
-            };
-            fs.readFileSync.mockImplementation((p) => {
-                if (p === getSystemSettingsPath())
-                    return JSON.stringify(systemSettingsContent);
-                return '{}';
-            });
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(fs.readFileSync).toHaveBeenCalledWith(getSystemSettingsPath(), 'utf-8');
-            expect(settings.system.settings).toEqual(systemSettingsContent);
-            expect(settings.user.settings).toEqual({});
-            expect(settings.workspace.settings).toEqual({});
-            expect(settings.merged).toEqual({
-                ...systemSettingsContent,
-            });
-        });
-        it('should load user settings if only user file exists', () => {
-            const expectedUserSettingsPath = USER_SETTINGS_PATH; // Use the path actually resolved by the (mocked) module
-            mockFsExistsSync.mockImplementation((p) => p === expectedUserSettingsPath);
-            const userSettingsContent = {
-                ui: {
-                    theme: 'dark',
-                },
-                context: {
-                    fileName: 'USER_CONTEXT.md',
+        it.each([
+            {
+                scope: 'system',
+                path: getSystemSettingsPath(),
+                content: {
+                    ui: { theme: 'system-default' },
+                    tools: { sandbox: false },
+                },
+            },
+            {
+                scope: 'user',
+                path: USER_SETTINGS_PATH,
+                content: {
+                    ui: { theme: 'dark' },
+                    context: { fileName: 'USER_CONTEXT.md' },
+                },
+            },
+            {
+                scope: 'workspace',
+                path: MOCK_WORKSPACE_SETTINGS_PATH,
+                content: {
+                    tools: { sandbox: true },
+                    context: { fileName: 'WORKSPACE_CONTEXT.md' },
                 },
-            };
+            },
+        ])('should load $scope settings if only $scope file exists', ({ scope, path, content }) => {
+            mockFsExistsSync.mockImplementation((p) => p === path);
             fs.readFileSync.mockImplementation((p) => {
-                if (p === expectedUserSettingsPath)
-                    return JSON.stringify(userSettingsContent);
+                if (p === path)
+                    return JSON.stringify(content);
                 return '{}';
             });
             const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(fs.readFileSync).toHaveBeenCalledWith(expectedUserSettingsPath, 'utf-8');
-            expect(settings.user.settings).toEqual(userSettingsContent);
-            expect(settings.workspace.settings).toEqual({});
-            expect(settings.merged).toEqual({
-                ...userSettingsContent,
-            });
-        });
-        it('should load workspace settings if only workspace file exists', () => {
-            mockFsExistsSync.mockImplementation((p) => p === MOCK_WORKSPACE_SETTINGS_PATH);
-            const workspaceSettingsContent = {
-                tools: {
-                    sandbox: true,
-                },
-                context: {
-                    fileName: 'WORKSPACE_CONTEXT.md',
-                },
-            };
-            fs.readFileSync.mockImplementation((p) => {
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
-                    return JSON.stringify(workspaceSettingsContent);
-                return '';
-            });
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(fs.readFileSync).toHaveBeenCalledWith(MOCK_WORKSPACE_SETTINGS_PATH, 'utf-8');
-            expect(settings.user.settings).toEqual({});
-            expect(settings.workspace.settings).toEqual(workspaceSettingsContent);
-            expect(settings.merged).toEqual({
-                ...workspaceSettingsContent,
-            });
+            expect(fs.readFileSync).toHaveBeenCalledWith(path, 'utf-8');
+            expect(settings[scope].settings).toEqual(content);
+            expect(settings.merged).toEqual(content);
         });
         it('should merge system, user and workspace settings, with system taking precedence over workspace, and workspace over user', () => {
             mockFsExistsSync.mockImplementation((p) => p === getSystemSettingsPath() ||
@@ -523,64 +489,55 @@ describe('Settings Loading and Merging', () => {
             const settings = loadSettings(MOCK_WORKSPACE_DIR);
             expect(settings.merged.security?.disableYoloMode).toBe(true); // System setting should be used
         });
-        it('should handle contextFileName correctly when only in user settings', () => {
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH);
-            const userSettingsContent = { context: { fileName: 'CUSTOM.md' } };
-            fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
-                    return JSON.stringify(userSettingsContent);
-                return '';
-            });
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged.context?.fileName).toBe('CUSTOM.md');
-        });
-        it('should handle contextFileName correctly when only in workspace settings', () => {
-            mockFsExistsSync.mockImplementation((p) => p === MOCK_WORKSPACE_SETTINGS_PATH);
-            const workspaceSettingsContent = {
-                context: { fileName: 'PROJECT_SPECIFIC.md' },
-            };
+        it.each([
+            {
+                description: 'contextFileName in user settings',
+                path: USER_SETTINGS_PATH,
+                content: { context: { fileName: 'CUSTOM.md' } },
+                expected: { key: 'context.fileName', value: 'CUSTOM.md' },
+            },
+            {
+                description: 'contextFileName in workspace settings',
+                path: MOCK_WORKSPACE_SETTINGS_PATH,
+                content: { context: { fileName: 'PROJECT_SPECIFIC.md' } },
+                expected: { key: 'context.fileName', value: 'PROJECT_SPECIFIC.md' },
+            },
+            {
+                description: 'excludedProjectEnvVars in user settings',
+                path: USER_SETTINGS_PATH,
+                content: {
+                    advanced: { excludedEnvVars: ['DEBUG', 'NODE_ENV', 'CUSTOM_VAR'] },
+                },
+                expected: {
+                    key: 'advanced.excludedEnvVars',
+                    value: ['DEBUG', 'NODE_ENV', 'CUSTOM_VAR'],
+                },
+            },
+            {
+                description: 'excludedProjectEnvVars in workspace settings',
+                path: MOCK_WORKSPACE_SETTINGS_PATH,
+                content: {
+                    advanced: { excludedEnvVars: ['WORKSPACE_DEBUG', 'WORKSPACE_VAR'] },
+                },
+                expected: {
+                    key: 'advanced.excludedEnvVars',
+                    value: ['WORKSPACE_DEBUG', 'WORKSPACE_VAR'],
+                },
+            },
+        ])('should handle $description correctly', ({ path, content, expected }) => {
+            mockFsExistsSync.mockImplementation((p) => p === path);
             fs.readFileSync.mockImplementation((p) => {
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
-                    return JSON.stringify(workspaceSettingsContent);
-                return '';
-            });
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged.context?.fileName).toBe('PROJECT_SPECIFIC.md');
-        });
-        it('should handle excludedProjectEnvVars correctly when only in user settings', () => {
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH);
-            const userSettingsContent = {
-                general: {},
-                advanced: { excludedEnvVars: ['DEBUG', 'NODE_ENV', 'CUSTOM_VAR'] },
-            };
-            fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
-                    return JSON.stringify(userSettingsContent);
-                return '';
-            });
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged.advanced?.excludedEnvVars).toEqual([
-                'DEBUG',
-                'NODE_ENV',
-                'CUSTOM_VAR',
-            ]);
-        });
-        it('should handle excludedProjectEnvVars correctly when only in workspace settings', () => {
-            mockFsExistsSync.mockImplementation((p) => p === MOCK_WORKSPACE_SETTINGS_PATH);
-            const workspaceSettingsContent = {
-                general: {},
-                advanced: { excludedEnvVars: ['WORKSPACE_DEBUG', 'WORKSPACE_VAR'] },
-            };
-            fs.readFileSync.mockImplementation((p) => {
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
-                    return JSON.stringify(workspaceSettingsContent);
-                return '';
+                if (p === path)
+                    return JSON.stringify(content);
+                return '{}';
             });
             const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged.advanced?.excludedEnvVars).toEqual([
-                'WORKSPACE_DEBUG',
-                'WORKSPACE_VAR',
-            ]);
+            const keys = expected.key.split('.');
+            let result = settings.merged;
+            for (const key of keys) {
+                result = result[key];
+            }
+            expect(result).toEqual(expected.value);
         });
         it('should merge excludedProjectEnvVars with workspace taking precedence over user', () => {
             mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH || p === MOCK_WORKSPACE_SETTINGS_PATH);
@@ -631,27 +588,28 @@ describe('Settings Loading and Merging', () => {
             const settings = loadSettings(MOCK_WORKSPACE_DIR);
             expect(settings.merged.context?.fileName).toBeUndefined();
         });
-        it('should load telemetry setting from user settings', () => {
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH);
-            const userSettingsContent = { telemetry: { enabled: true } };
-            fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
-                    return JSON.stringify(userSettingsContent);
-                return '{}';
-            });
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged.telemetry?.enabled).toBe(true);
-        });
-        it('should load telemetry setting from workspace settings', () => {
-            mockFsExistsSync.mockImplementation((p) => p === MOCK_WORKSPACE_SETTINGS_PATH);
-            const workspaceSettingsContent = { telemetry: { enabled: false } };
+        it.each([
+            {
+                scope: 'user',
+                path: USER_SETTINGS_PATH,
+                content: { telemetry: { enabled: true } },
+                expected: true,
+            },
+            {
+                scope: 'workspace',
+                path: MOCK_WORKSPACE_SETTINGS_PATH,
+                content: { telemetry: { enabled: false } },
+                expected: false,
+            },
+        ])('should load telemetry setting from $scope settings', ({ path, content, expected }) => {
+            mockFsExistsSync.mockImplementation((p) => p === path);
             fs.readFileSync.mockImplementation((p) => {
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
-                    return JSON.stringify(workspaceSettingsContent);
+                if (p === path)
+                    return JSON.stringify(content);
                 return '{}';
             });
             const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged.telemetry?.enabled).toBe(false);
+            expect(settings.merged.telemetry?.enabled).toBe(expected);
         });
         it('should prioritize workspace telemetry setting over user setting', () => {
             mockFsExistsSync.mockReturnValue(true);
@@ -730,51 +688,52 @@ describe('Settings Loading and Merging', () => {
                 },
             });
         });
-        it('should handle MCP servers when only in user settings', () => {
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH);
-            const userSettingsContent = {
-                mcpServers: {
+        it.each([
+            {
+                scope: 'user',
+                path: USER_SETTINGS_PATH,
+                content: {
+                    mcpServers: {
+                        'user-only-server': {
+                            command: 'user-only-command',
+                            description: 'User only server',
+                        },
+                    },
+                },
+                expected: {
                     'user-only-server': {
                         command: 'user-only-command',
                         description: 'User only server',
                     },
                 },
-            };
-            fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
-                    return JSON.stringify(userSettingsContent);
-                return '';
-            });
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged.mcpServers).toEqual({
-                'user-only-server': {
-                    command: 'user-only-command',
-                    description: 'User only server',
+            },
+            {
+                scope: 'workspace',
+                path: MOCK_WORKSPACE_SETTINGS_PATH,
+                content: {
+                    mcpServers: {
+                        'workspace-only-server': {
+                            command: 'workspace-only-command',
+                            description: 'Workspace only server',
+                        },
+                    },
                 },
-            });
-        });
-        it('should handle MCP servers when only in workspace settings', () => {
-            mockFsExistsSync.mockImplementation((p) => p === MOCK_WORKSPACE_SETTINGS_PATH);
-            const workspaceSettingsContent = {
-                mcpServers: {
+                expected: {
                     'workspace-only-server': {
                         command: 'workspace-only-command',
                         description: 'Workspace only server',
                     },
                 },
-            };
+            },
+        ])('should handle MCP servers when only in $scope settings', ({ path, content, expected }) => {
+            mockFsExistsSync.mockImplementation((p) => p === path);
             fs.readFileSync.mockImplementation((p) => {
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
-                    return JSON.stringify(workspaceSettingsContent);
-                return '';
+                if (p === path)
+                    return JSON.stringify(content);
+                return '{}';
             });
             const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged.mcpServers).toEqual({
-                'workspace-only-server': {
-                    command: 'workspace-only-command',
-                    description: 'Workspace only server',
-                },
-            });
+            expect(settings.merged.mcpServers).toEqual(expected);
         });
         it('should have mcpServers as undefined if not in any settings file', () => {
             mockFsExistsSync.mockReturnValue(false); // No settings files exist
@@ -877,65 +836,44 @@ describe('Settings Loading and Merging', () => {
                 excluded: ['workspace-excluded'],
             });
         });
-        it('should merge compressionThreshold settings, with workspace taking precedence', () => {
-            mockFsExistsSync.mockReturnValue(true);
-            const userSettingsContent = {
-                general: {},
-                model: { compressionThreshold: 0.5 },
-            };
-            const workspaceSettingsContent = {
-                general: {},
-                model: { compressionThreshold: 0.8 },
-            };
-            fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
-                    return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
-                    return JSON.stringify(workspaceSettingsContent);
-                return '{}';
-            });
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.user.settings.model?.compressionThreshold).toEqual(0.5);
-            expect(settings.workspace.settings.model?.compressionThreshold).toEqual(0.8);
-            expect(settings.merged.model?.compressionThreshold).toEqual(0.8);
-        });
-        it('should merge output format settings, with workspace taking precedence', () => {
-            mockFsExistsSync.mockReturnValue(true);
-            const userSettingsContent = {
-                output: { format: 'text' },
-            };
-            const workspaceSettingsContent = {
-                output: { format: 'json' },
-            };
-            fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
-                    return JSON.stringify(userSettingsContent);
-                if (p === MOCK_WORKSPACE_SETTINGS_PATH)
-                    return JSON.stringify(workspaceSettingsContent);
-                return '{}';
-            });
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged.output?.format).toBe('json');
-        });
-        it('should handle compressionThreshold when only in user settings', () => {
-            mockFsExistsSync.mockImplementation((p) => p === USER_SETTINGS_PATH);
-            const userSettingsContent = {
-                general: {},
-                model: { compressionThreshold: 0.5 },
-            };
-            fs.readFileSync.mockImplementation((p) => {
-                if (p === USER_SETTINGS_PATH)
-                    return JSON.stringify(userSettingsContent);
-                return '{}';
+        describe('compressionThreshold settings', () => {
+            it.each([
+                {
+                    description: 'should be taken from user settings if only present there',
+                    userContent: { model: { compressionThreshold: 0.5 } },
+                    workspaceContent: {},
+                    expected: 0.5,
+                },
+                {
+                    description: 'should be taken from workspace settings if only present there',
+                    userContent: {},
+                    workspaceContent: { model: { compressionThreshold: 0.8 } },
+                    expected: 0.8,
+                },
+                {
+                    description: 'should prioritize workspace settings over user settings',
+                    userContent: { model: { compressionThreshold: 0.5 } },
+                    workspaceContent: { model: { compressionThreshold: 0.8 } },
+                    expected: 0.8,
+                },
+                {
+                    description: 'should be undefined if not in any settings file',
+                    userContent: {},
+                    workspaceContent: {},
+                    expected: undefined,
+                },
+            ])('$description', ({ userContent, workspaceContent, expected }) => {
+                mockFsExistsSync.mockReturnValue(true);
+                fs.readFileSync.mockImplementation((p) => {
+                    if (p === USER_SETTINGS_PATH)
+                        return JSON.stringify(userContent);
+                    if (p === MOCK_WORKSPACE_SETTINGS_PATH)
+                        return JSON.stringify(workspaceContent);
+                    return '{}';
+                });
+                const settings = loadSettings(MOCK_WORKSPACE_DIR);
+                expect(settings.merged.model?.compressionThreshold).toEqual(expected);
             });
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged.model?.compressionThreshold).toEqual(0.5);
-        });
-        it('should have model as undefined if not in any settings file', () => {
-            mockFsExistsSync.mockReturnValue(false); // No settings files exist
-            fs.readFileSync.mockReturnValue('{}');
-            const settings = loadSettings(MOCK_WORKSPACE_DIR);
-            expect(settings.merged.model).toBeUndefined();
         });
         it('should use user compressionThreshold if workspace does not define it', () => {
             mockFsExistsSync.mockReturnValue(true);