Download projects/gemini-cli/packages/cli/src/utils/settingsUtils.test.ts from LevelUp2x/adaptai: direct link, hf CLI and curl.
- Browser
- Download file 28.1 kB
-
https://huggingface.co/datasets/LevelUp2x/adaptai/resolve/2147bc06c2ccf123b96f98eace2e6bf6486e7f0e/projects/gemini-cli/packages/cli/src/utils/settingsUtils.test.ts
- Command line
-
hf download hf://datasets/LevelUp2x/adaptai@2147bc06c2ccf123b96f98eace2e6bf6486e7f0e/projects/gemini-cli/packages/cli/src/utils/settingsUtils.test.ts
-
curl -L -o settingsUtils.test.ts https://huggingface.co/datasets/LevelUp2x/adaptai/resolve/2147bc06c2ccf123b96f98eace2e6bf6486e7f0e/projects/gemini-cli/packages/cli/src/utils/settingsUtils.test.ts
28.1 kB
| /** | |
| * @license | |
| * Copyright 2025 Google LLC | |
| * SPDX-License-Identifier: Apache-2.0 | |
| */ | |
| import { describe, it, expect } from 'vitest'; | |
| import { | |
| // Schema utilities | |
| getSettingsByCategory, | |
| getSettingDefinition, | |
| requiresRestart, | |
| getDefaultValue, | |
| getRestartRequiredSettings, | |
| getEffectiveValue, | |
| getAllSettingKeys, | |
| getSettingsByType, | |
| getSettingsRequiringRestart, | |
| isValidSettingKey, | |
| getSettingCategory, | |
| shouldShowInDialog, | |
| getDialogSettingsByCategory, | |
| getDialogSettingsByType, | |
| getDialogSettingKeys, | |
| // Business logic utilities | |
| getSettingValue, | |
| isSettingModified, | |
| settingExistsInScope, | |
| setPendingSettingValue, | |
| hasRestartRequiredSettings, | |
| getRestartRequiredFromModified, | |
| getDisplayValue, | |
| isDefaultValue, | |
| isValueInherited, | |
| getEffectiveDisplayValue, | |
| } from './settingsUtils.js'; | |
| describe('SettingsUtils', () => { | |
| describe('Schema Utilities', () => { | |
| describe('getSettingsByCategory', () => { | |
| it('should group settings by category', () => { | |
| const categories = getSettingsByCategory(); | |
| expect(categories).toHaveProperty('General'); | |
| expect(categories).toHaveProperty('UI'); | |
| }); | |
| it('should include key property in grouped settings', () => { | |
| const categories = getSettingsByCategory(); | |
| Object.entries(categories).forEach(([_category, settings]) => { | |
| settings.forEach((setting) => { | |
| expect(setting.key).toBeDefined(); | |
| }); | |
| }); | |
| }); | |
| }); | |
| describe('getSettingDefinition', () => { | |
| it('should return definition for valid setting', () => { | |
| const definition = getSettingDefinition('ui.showMemoryUsage'); | |
| expect(definition).toBeDefined(); | |
| expect(definition?.label).toBe('Show Memory Usage'); | |
| }); | |
| it('should return undefined for invalid setting', () => { | |
| const definition = getSettingDefinition('invalidSetting'); | |
| expect(definition).toBeUndefined(); | |
| }); | |
| }); | |
| describe('requiresRestart', () => { | |
| it('should return true for settings that require restart', () => { | |
| expect(requiresRestart('advanced.autoConfigureMemory')).toBe(true); | |
| expect(requiresRestart('general.checkpointing.enabled')).toBe(true); | |
| }); | |
| it('should return false for settings that do not require restart', () => { | |
| expect(requiresRestart('ui.showMemoryUsage')).toBe(false); | |
| expect(requiresRestart('ui.hideTips')).toBe(false); | |
| }); | |
| it('should return false for invalid settings', () => { | |
| expect(requiresRestart('invalidSetting')).toBe(false); | |
| }); | |
| }); | |
| describe('getDefaultValue', () => { | |
| it('should return correct default values', () => { | |
| expect(getDefaultValue('ui.showMemoryUsage')).toBe(false); | |
| expect( | |
| getDefaultValue('context.fileFiltering.enableRecursiveFileSearch'), | |
| ).toBe(true); | |
| }); | |
| it('should return undefined for invalid settings', () => { | |
| expect(getDefaultValue('invalidSetting')).toBeUndefined(); | |
| }); | |
| }); | |
| describe('getRestartRequiredSettings', () => { | |
| it('should return all settings that require restart', () => { | |
| const restartSettings = getRestartRequiredSettings(); | |
| expect(restartSettings).toContain('advanced.autoConfigureMemory'); | |
| expect(restartSettings).toContain('general.checkpointing.enabled'); | |
| expect(restartSettings).not.toContain('ui.showMemoryUsage'); | |
| }); | |
| }); | |
| describe('getEffectiveValue', () => { | |
| it('should return value from settings when set', () => { | |
| const settings = { ui: { showMemoryUsage: true } }; | |
| const mergedSettings = { ui: { showMemoryUsage: false } }; | |
| const value = getEffectiveValue( | |
| 'ui.showMemoryUsage', | |
| settings, | |
| mergedSettings, | |
| ); | |
| expect(value).toBe(true); | |
| }); | |
| it('should return value from merged settings when not set in current scope', () => { | |
| const settings = {}; | |
| const mergedSettings = { ui: { showMemoryUsage: true } }; | |
| const value = getEffectiveValue( | |
| 'ui.showMemoryUsage', | |
| settings, | |
| mergedSettings, | |
| ); | |
| expect(value).toBe(true); | |
| }); | |
| it('should return default value when not set anywhere', () => { | |
| const settings = {}; | |
| const mergedSettings = {}; | |
| const value = getEffectiveValue( | |
| 'ui.showMemoryUsage', | |
| settings, | |
| mergedSettings, | |
| ); | |
| expect(value).toBe(false); // default value | |
| }); | |
| it('should handle nested settings correctly', () => { | |
| const settings = { | |
| ui: { accessibility: { disableLoadingPhrases: true } }, | |
| }; | |
| const mergedSettings = { | |
| ui: { accessibility: { disableLoadingPhrases: false } }, | |
| }; | |
| const value = getEffectiveValue( | |
| 'ui.accessibility.disableLoadingPhrases', | |
| settings, | |
| mergedSettings, | |
| ); | |
| expect(value).toBe(true); | |
| }); | |
| it('should return undefined for invalid settings', () => { | |
| const settings = {}; | |
| const mergedSettings = {}; | |
| const value = getEffectiveValue( | |
| 'invalidSetting', | |
| settings, | |
| mergedSettings, | |
| ); | |
| expect(value).toBeUndefined(); | |
| }); | |
| }); | |
| describe('getAllSettingKeys', () => { | |
| it('should return all setting keys', () => { | |
| const keys = getAllSettingKeys(); | |
| expect(keys).toContain('ui.showMemoryUsage'); | |
| expect(keys).toContain('ui.accessibility.disableLoadingPhrases'); | |
| expect(keys).toContain('general.checkpointing.enabled'); | |
| }); | |
| }); | |
| describe('getSettingsByType', () => { | |
| it('should return only boolean settings', () => { | |
| const booleanSettings = getSettingsByType('boolean'); | |
| expect(booleanSettings.length).toBeGreaterThan(0); | |
| booleanSettings.forEach((setting) => { | |
| expect(setting.type).toBe('boolean'); | |
| }); | |
| }); | |
| }); | |
| describe('getSettingsRequiringRestart', () => { | |
| it('should return only settings that require restart', () => { | |
| const restartSettings = getSettingsRequiringRestart(); | |
| expect(restartSettings.length).toBeGreaterThan(0); | |
| restartSettings.forEach((setting) => { | |
| expect(setting.requiresRestart).toBe(true); | |
| }); | |
| }); | |
| }); | |
| describe('isValidSettingKey', () => { | |
| it('should return true for valid setting keys', () => { | |
| expect(isValidSettingKey('ui.showMemoryUsage')).toBe(true); | |
| expect( | |
| isValidSettingKey('ui.accessibility.disableLoadingPhrases'), | |
| ).toBe(true); | |
| }); | |
| it('should return false for invalid setting keys', () => { | |
| expect(isValidSettingKey('invalidSetting')).toBe(false); | |
| expect(isValidSettingKey('')).toBe(false); | |
| }); | |
| }); | |
| describe('getSettingCategory', () => { | |
| it('should return correct category for valid settings', () => { | |
| expect(getSettingCategory('ui.showMemoryUsage')).toBe('UI'); | |
| expect( | |
| getSettingCategory('ui.accessibility.disableLoadingPhrases'), | |
| ).toBe('UI'); | |
| }); | |
| it('should return undefined for invalid settings', () => { | |
| expect(getSettingCategory('invalidSetting')).toBeUndefined(); | |
| }); | |
| }); | |
| describe('shouldShowInDialog', () => { | |
| it('should return true for settings marked to show in dialog', () => { | |
| expect(shouldShowInDialog('ui.showMemoryUsage')).toBe(true); | |
| expect(shouldShowInDialog('general.vimMode')).toBe(true); | |
| expect(shouldShowInDialog('ui.hideWindowTitle')).toBe(true); | |
| expect(shouldShowInDialog('privacy.usageStatisticsEnabled')).toBe( | |
| false, | |
| ); | |
| }); | |
| it('should return false for settings marked to hide from dialog', () => { | |
| expect(shouldShowInDialog('security.auth.selectedType')).toBe(false); | |
| expect(shouldShowInDialog('tools.core')).toBe(false); | |
| expect(shouldShowInDialog('ui.customThemes')).toBe(false); | |
| expect(shouldShowInDialog('ui.theme')).toBe(false); // Changed to false | |
| expect(shouldShowInDialog('general.preferredEditor')).toBe(false); // Changed to false | |
| }); | |
| it('should return true for invalid settings (default behavior)', () => { | |
| expect(shouldShowInDialog('invalidSetting')).toBe(true); | |
| }); | |
| }); | |
| describe('getDialogSettingsByCategory', () => { | |
| it('should only return settings marked for dialog display', async () => { | |
| const categories = getDialogSettingsByCategory(); | |
| // Should include UI settings that are marked for dialog | |
| expect(categories['UI']).toBeDefined(); | |
| const uiSettings = categories['UI']; | |
| const uiKeys = uiSettings.map((s) => s.key); | |
| expect(uiKeys).toContain('ui.showMemoryUsage'); | |
| expect(uiKeys).toContain('ui.hideWindowTitle'); | |
| expect(uiKeys).not.toContain('ui.customThemes'); // This is marked false | |
| expect(uiKeys).not.toContain('ui.theme'); // This is now marked false | |
| }); | |
| it('should not include Advanced category settings', () => { | |
| const categories = getDialogSettingsByCategory(); | |
| // Advanced settings should be filtered out | |
| expect(categories['Advanced']).toBeUndefined(); | |
| }); | |
| it('should include settings with showInDialog=true', () => { | |
| const categories = getDialogSettingsByCategory(); | |
| const allSettings = Object.values(categories).flat(); | |
| const allKeys = allSettings.map((s) => s.key); | |
| expect(allKeys).toContain('general.vimMode'); | |
| expect(allKeys).toContain('ide.enabled'); | |
| expect(allKeys).toContain('general.disableAutoUpdate'); | |
| expect(allKeys).toContain('ui.showMemoryUsage'); | |
| expect(allKeys).not.toContain('privacy.usageStatisticsEnabled'); | |
| expect(allKeys).not.toContain('security.auth.selectedType'); | |
| expect(allKeys).not.toContain('tools.core'); | |
| expect(allKeys).not.toContain('ui.theme'); // Now hidden | |
| expect(allKeys).not.toContain('general.preferredEditor'); // Now hidden | |
| }); | |
| }); | |
| describe('getDialogSettingsByType', () => { | |
| it('should return only boolean dialog settings', () => { | |
| const booleanSettings = getDialogSettingsByType('boolean'); | |
| const keys = booleanSettings.map((s) => s.key); | |
| expect(keys).toContain('ui.showMemoryUsage'); | |
| expect(keys).toContain('general.vimMode'); | |
| expect(keys).toContain('ui.hideWindowTitle'); | |
| expect(keys).not.toContain('privacy.usageStatisticsEnabled'); | |
| expect(keys).not.toContain('security.auth.selectedType'); // Advanced setting | |
| expect(keys).not.toContain('security.auth.useExternal'); // Advanced setting | |
| }); | |
| it('should return only string dialog settings', () => { | |
| const stringSettings = getDialogSettingsByType('string'); | |
| const keys = stringSettings.map((s) => s.key); | |
| // Note: theme and preferredEditor are now hidden from dialog | |
| expect(keys).not.toContain('ui.theme'); // Now marked false | |
| expect(keys).not.toContain('general.preferredEditor'); // Now marked false | |
| expect(keys).not.toContain('security.auth.selectedType'); // Advanced setting | |
| // Most string settings are now hidden, so let's just check they exclude advanced ones | |
| expect(keys.every((key) => !key.startsWith('tool'))).toBe(true); // No tool-related settings | |
| }); | |
| }); | |
| describe('getDialogSettingKeys', () => { | |
| it('should return only settings marked for dialog display', () => { | |
| const dialogKeys = getDialogSettingKeys(); | |
| // Should include settings marked for dialog | |
| expect(dialogKeys).toContain('ui.showMemoryUsage'); | |
| expect(dialogKeys).toContain('general.vimMode'); | |
| expect(dialogKeys).toContain('ui.hideWindowTitle'); | |
| expect(dialogKeys).not.toContain('privacy.usageStatisticsEnabled'); | |
| expect(dialogKeys).toContain('ide.enabled'); | |
| expect(dialogKeys).toContain('general.disableAutoUpdate'); | |
| // Should include nested settings marked for dialog | |
| expect(dialogKeys).toContain('context.fileFiltering.respectGitIgnore'); | |
| expect(dialogKeys).toContain( | |
| 'context.fileFiltering.respectGeminiIgnore', | |
| ); | |
| expect(dialogKeys).toContain( | |
| 'context.fileFiltering.enableRecursiveFileSearch', | |
| ); | |
| // Should NOT include settings marked as hidden | |
| expect(dialogKeys).not.toContain('ui.theme'); // Hidden | |
| expect(dialogKeys).not.toContain('ui.customThemes'); // Hidden | |
| expect(dialogKeys).not.toContain('general.preferredEditor'); // Hidden | |
| expect(dialogKeys).not.toContain('security.auth.selectedType'); // Advanced | |
| expect(dialogKeys).not.toContain('tools.core'); // Advanced | |
| expect(dialogKeys).not.toContain('mcpServers'); // Advanced | |
| expect(dialogKeys).not.toContain('telemetry'); // Advanced | |
| }); | |
| it('should return fewer keys than getAllSettingKeys', () => { | |
| const allKeys = getAllSettingKeys(); | |
| const dialogKeys = getDialogSettingKeys(); | |
| expect(dialogKeys.length).toBeLessThan(allKeys.length); | |
| expect(dialogKeys.length).toBeGreaterThan(0); | |
| }); | |
| it('should handle nested settings display correctly', () => { | |
| // Test the specific issue with fileFiltering.respectGitIgnore | |
| const key = 'context.fileFiltering.respectGitIgnore'; | |
| const initialSettings = {}; | |
| const pendingSettings = {}; | |
| // Set the nested setting to true | |
| const updatedPendingSettings = setPendingSettingValue( | |
| key, | |
| true, | |
| pendingSettings, | |
| ); | |
| // Check if the setting exists in pending settings | |
| const existsInPending = settingExistsInScope( | |
| key, | |
| updatedPendingSettings, | |
| ); | |
| expect(existsInPending).toBe(true); | |
| // Get the value from pending settings | |
| const valueFromPending = getSettingValue( | |
| key, | |
| updatedPendingSettings, | |
| {}, | |
| ); | |
| expect(valueFromPending).toBe(true); | |
| // Test getDisplayValue should show the pending change | |
| const displayValue = getDisplayValue( | |
| key, | |
| initialSettings, | |
| {}, | |
| new Set(), | |
| updatedPendingSettings, | |
| ); | |
| expect(displayValue).toBe('true'); // Should show true (no * since value matches default) | |
| // Test that modified settings also show the * indicator | |
| const modifiedSettings = new Set([key]); | |
| const displayValueWithModified = getDisplayValue( | |
| key, | |
| initialSettings, | |
| {}, | |
| modifiedSettings, | |
| {}, | |
| ); | |
| expect(displayValueWithModified).toBe('true*'); // Should show true* because it's in modified settings and default is true | |
| }); | |
| }); | |
| }); | |
| describe('Business Logic Utilities', () => { | |
| describe('getSettingValue', () => { | |
| it('should return value from settings when set', () => { | |
| const settings = { ui: { showMemoryUsage: true } }; | |
| const mergedSettings = { ui: { showMemoryUsage: false } }; | |
| const value = getSettingValue( | |
| 'ui.showMemoryUsage', | |
| settings, | |
| mergedSettings, | |
| ); | |
| expect(value).toBe(true); | |
| }); | |
| it('should return value from merged settings when not set in current scope', () => { | |
| const settings = {}; | |
| const mergedSettings = { ui: { showMemoryUsage: true } }; | |
| const value = getSettingValue( | |
| 'ui.showMemoryUsage', | |
| settings, | |
| mergedSettings, | |
| ); | |
| expect(value).toBe(true); | |
| }); | |
| it('should return default value for invalid setting', () => { | |
| const settings = {}; | |
| const mergedSettings = {}; | |
| const value = getSettingValue( | |
| 'invalidSetting', | |
| settings, | |
| mergedSettings, | |
| ); | |
| expect(value).toBe(false); // Default fallback | |
| }); | |
| }); | |
| describe('isSettingModified', () => { | |
| it('should return true when value differs from default', () => { | |
| expect(isSettingModified('ui.showMemoryUsage', true)).toBe(true); | |
| expect( | |
| isSettingModified( | |
| 'context.fileFiltering.enableRecursiveFileSearch', | |
| false, | |
| ), | |
| ).toBe(true); | |
| }); | |
| it('should return false when value matches default', () => { | |
| expect(isSettingModified('ui.showMemoryUsage', false)).toBe(false); | |
| expect( | |
| isSettingModified( | |
| 'context.fileFiltering.enableRecursiveFileSearch', | |
| true, | |
| ), | |
| ).toBe(false); | |
| }); | |
| }); | |
| describe('settingExistsInScope', () => { | |
| it('should return true for top-level settings that exist', () => { | |
| const settings = { ui: { showMemoryUsage: true } }; | |
| expect(settingExistsInScope('ui.showMemoryUsage', settings)).toBe(true); | |
| }); | |
| it('should return false for top-level settings that do not exist', () => { | |
| const settings = {}; | |
| expect(settingExistsInScope('ui.showMemoryUsage', settings)).toBe( | |
| false, | |
| ); | |
| }); | |
| it('should return true for nested settings that exist', () => { | |
| const settings = { | |
| ui: { accessibility: { disableLoadingPhrases: true } }, | |
| }; | |
| expect( | |
| settingExistsInScope( | |
| 'ui.accessibility.disableLoadingPhrases', | |
| settings, | |
| ), | |
| ).toBe(true); | |
| }); | |
| it('should return false for nested settings that do not exist', () => { | |
| const settings = {}; | |
| expect( | |
| settingExistsInScope( | |
| 'ui.accessibility.disableLoadingPhrases', | |
| settings, | |
| ), | |
| ).toBe(false); | |
| }); | |
| it('should return false when parent exists but child does not', () => { | |
| const settings = { ui: { accessibility: {} } }; | |
| expect( | |
| settingExistsInScope( | |
| 'ui.accessibility.disableLoadingPhrases', | |
| settings, | |
| ), | |
| ).toBe(false); | |
| }); | |
| }); | |
| describe('setPendingSettingValue', () => { | |
| it('should set top-level setting value', () => { | |
| const pendingSettings = {}; | |
| const result = setPendingSettingValue( | |
| 'ui.showMemoryUsage', | |
| true, | |
| pendingSettings, | |
| ); | |
| expect(result.ui?.showMemoryUsage).toBe(true); | |
| }); | |
| it('should set nested setting value', () => { | |
| const pendingSettings = {}; | |
| const result = setPendingSettingValue( | |
| 'ui.accessibility.disableLoadingPhrases', | |
| true, | |
| pendingSettings, | |
| ); | |
| expect(result.ui?.accessibility?.disableLoadingPhrases).toBe(true); | |
| }); | |
| it('should preserve existing nested settings', () => { | |
| const pendingSettings = { | |
| ui: { accessibility: { disableLoadingPhrases: false } }, | |
| }; | |
| const result = setPendingSettingValue( | |
| 'ui.accessibility.disableLoadingPhrases', | |
| true, | |
| pendingSettings, | |
| ); | |
| expect(result.ui?.accessibility?.disableLoadingPhrases).toBe(true); | |
| }); | |
| it('should not mutate original settings', () => { | |
| const pendingSettings = {}; | |
| setPendingSettingValue('ui.showMemoryUsage', true, pendingSettings); | |
| expect(pendingSettings).toEqual({}); | |
| }); | |
| }); | |
| describe('hasRestartRequiredSettings', () => { | |
| it('should return true when modified settings require restart', () => { | |
| const modifiedSettings = new Set<string>([ | |
| 'advanced.autoConfigureMemory', | |
| 'ui.showMemoryUsage', | |
| ]); | |
| expect(hasRestartRequiredSettings(modifiedSettings)).toBe(true); | |
| }); | |
| it('should return false when no modified settings require restart', () => { | |
| const modifiedSettings = new Set<string>([ | |
| 'ui.showMemoryUsage', | |
| 'ui.hideTips', | |
| ]); | |
| expect(hasRestartRequiredSettings(modifiedSettings)).toBe(false); | |
| }); | |
| it('should return false for empty set', () => { | |
| const modifiedSettings = new Set<string>(); | |
| expect(hasRestartRequiredSettings(modifiedSettings)).toBe(false); | |
| }); | |
| }); | |
| describe('getRestartRequiredFromModified', () => { | |
| it('should return only settings that require restart', () => { | |
| const modifiedSettings = new Set<string>([ | |
| 'advanced.autoConfigureMemory', | |
| 'ui.showMemoryUsage', | |
| 'general.checkpointing.enabled', | |
| ]); | |
| const result = getRestartRequiredFromModified(modifiedSettings); | |
| expect(result).toContain('advanced.autoConfigureMemory'); | |
| expect(result).toContain('general.checkpointing.enabled'); | |
| expect(result).not.toContain('ui.showMemoryUsage'); | |
| }); | |
| it('should return empty array when no settings require restart', () => { | |
| const modifiedSettings = new Set<string>([ | |
| 'showMemoryUsage', | |
| 'hideTips', | |
| ]); | |
| const result = getRestartRequiredFromModified(modifiedSettings); | |
| expect(result).toEqual([]); | |
| }); | |
| }); | |
| describe('getDisplayValue', () => { | |
| it('should show value without * when setting matches default', () => { | |
| const settings = { ui: { showMemoryUsage: false } }; // false matches default, so no * | |
| const mergedSettings = { ui: { showMemoryUsage: false } }; | |
| const modifiedSettings = new Set<string>(); | |
| const result = getDisplayValue( | |
| 'ui.showMemoryUsage', | |
| settings, | |
| mergedSettings, | |
| modifiedSettings, | |
| ); | |
| expect(result).toBe('false*'); | |
| }); | |
| it('should show default value when setting is not in scope', () => { | |
| const settings = {}; // no setting in scope | |
| const mergedSettings = { ui: { showMemoryUsage: false } }; | |
| const modifiedSettings = new Set<string>(); | |
| const result = getDisplayValue( | |
| 'ui.showMemoryUsage', | |
| settings, | |
| mergedSettings, | |
| modifiedSettings, | |
| ); | |
| expect(result).toBe('false'); // shows default value | |
| }); | |
| it('should show value with * when changed from default', () => { | |
| const settings = { ui: { showMemoryUsage: true } }; // true is different from default (false) | |
| const mergedSettings = { ui: { showMemoryUsage: true } }; | |
| const modifiedSettings = new Set<string>(); | |
| const result = getDisplayValue( | |
| 'ui.showMemoryUsage', | |
| settings, | |
| mergedSettings, | |
| modifiedSettings, | |
| ); | |
| expect(result).toBe('true*'); | |
| }); | |
| it('should show default value without * when setting does not exist in scope', () => { | |
| const settings = {}; // setting doesn't exist in scope, show default | |
| const mergedSettings = { ui: { showMemoryUsage: false } }; | |
| const modifiedSettings = new Set<string>(); | |
| const result = getDisplayValue( | |
| 'ui.showMemoryUsage', | |
| settings, | |
| mergedSettings, | |
| modifiedSettings, | |
| ); | |
| expect(result).toBe('false'); // default value (false) without * | |
| }); | |
| it('should show value with * when user changes from default', () => { | |
| const settings = {}; // setting doesn't exist in scope originally | |
| const mergedSettings = { ui: { showMemoryUsage: false } }; | |
| const modifiedSettings = new Set<string>(['ui.showMemoryUsage']); | |
| const pendingSettings = { ui: { showMemoryUsage: true } }; // user changed to true | |
| const result = getDisplayValue( | |
| 'ui.showMemoryUsage', | |
| settings, | |
| mergedSettings, | |
| modifiedSettings, | |
| pendingSettings, | |
| ); | |
| expect(result).toBe('true*'); // changed from default (false) to true | |
| }); | |
| }); | |
| describe('isDefaultValue', () => { | |
| it('should return true when setting does not exist in scope', () => { | |
| const settings = {}; // setting doesn't exist | |
| const result = isDefaultValue('ui.showMemoryUsage', settings); | |
| expect(result).toBe(true); | |
| }); | |
| it('should return false when setting exists in scope', () => { | |
| const settings = { ui: { showMemoryUsage: true } }; // setting exists | |
| const result = isDefaultValue('ui.showMemoryUsage', settings); | |
| expect(result).toBe(false); | |
| }); | |
| it('should return true when nested setting does not exist in scope', () => { | |
| const settings = {}; // nested setting doesn't exist | |
| const result = isDefaultValue( | |
| 'ui.accessibility.disableLoadingPhrases', | |
| settings, | |
| ); | |
| expect(result).toBe(true); | |
| }); | |
| it('should return false when nested setting exists in scope', () => { | |
| const settings = { | |
| ui: { accessibility: { disableLoadingPhrases: true } }, | |
| }; // nested setting exists | |
| const result = isDefaultValue( | |
| 'ui.accessibility.disableLoadingPhrases', | |
| settings, | |
| ); | |
| expect(result).toBe(false); | |
| }); | |
| }); | |
| describe('isValueInherited', () => { | |
| it('should return false for top-level settings that exist in scope', () => { | |
| const settings = { ui: { showMemoryUsage: true } }; | |
| const mergedSettings = { ui: { showMemoryUsage: true } }; | |
| const result = isValueInherited( | |
| 'ui.showMemoryUsage', | |
| settings, | |
| mergedSettings, | |
| ); | |
| expect(result).toBe(false); | |
| }); | |
| it('should return true for top-level settings that do not exist in scope', () => { | |
| const settings = {}; | |
| const mergedSettings = { ui: { showMemoryUsage: true } }; | |
| const result = isValueInherited( | |
| 'ui.showMemoryUsage', | |
| settings, | |
| mergedSettings, | |
| ); | |
| expect(result).toBe(true); | |
| }); | |
| it('should return false for nested settings that exist in scope', () => { | |
| const settings = { | |
| ui: { accessibility: { disableLoadingPhrases: true } }, | |
| }; | |
| const mergedSettings = { | |
| ui: { accessibility: { disableLoadingPhrases: true } }, | |
| }; | |
| const result = isValueInherited( | |
| 'ui.accessibility.disableLoadingPhrases', | |
| settings, | |
| mergedSettings, | |
| ); | |
| expect(result).toBe(false); | |
| }); | |
| it('should return true for nested settings that do not exist in scope', () => { | |
| const settings = {}; | |
| const mergedSettings = { | |
| ui: { accessibility: { disableLoadingPhrases: true } }, | |
| }; | |
| const result = isValueInherited( | |
| 'ui.accessibility.disableLoadingPhrases', | |
| settings, | |
| mergedSettings, | |
| ); | |
| expect(result).toBe(true); | |
| }); | |
| }); | |
| describe('getEffectiveDisplayValue', () => { | |
| it('should return value from settings when available', () => { | |
| const settings = { ui: { showMemoryUsage: true } }; | |
| const mergedSettings = { ui: { showMemoryUsage: false } }; | |
| const result = getEffectiveDisplayValue( | |
| 'ui.showMemoryUsage', | |
| settings, | |
| mergedSettings, | |
| ); | |
| expect(result).toBe(true); | |
| }); | |
| it('should return value from merged settings when not in scope', () => { | |
| const settings = {}; | |
| const mergedSettings = { ui: { showMemoryUsage: true } }; | |
| const result = getEffectiveDisplayValue( | |
| 'ui.showMemoryUsage', | |
| settings, | |
| mergedSettings, | |
| ); | |
| expect(result).toBe(true); | |
| }); | |
| it('should return default value for undefined values', () => { | |
| const settings = {}; | |
| const mergedSettings = {}; | |
| const result = getEffectiveDisplayValue( | |
| 'ui.showMemoryUsage', | |
| settings, | |
| mergedSettings, | |
| ); | |
| expect(result).toBe(false); // Default value | |
| }); | |
| }); | |
| }); | |
| }); | |