From 5a1ed400e71c44f83dee1debc6891aa374c11dd1 Mon Sep 17 00:00:00 2001 From: eleanorjboyd <26030610+eleanorjboyd@users.noreply.github.com> Date: Sun, 25 Jan 2026 16:20:34 -0800 Subject: [PATCH 1/2] Enhance environment manager settings updates to avoid unnecessary writes for default values --- src/features/settings/settingHelpers.ts | 134 ++++++++++++++++++++---- 1 file changed, 115 insertions(+), 19 deletions(-) diff --git a/src/features/settings/settingHelpers.ts b/src/features/settings/settingHelpers.ts index bad55368..0566953b 100644 --- a/src/features/settings/settingHelpers.ts +++ b/src/features/settings/settingHelpers.ts @@ -129,6 +129,11 @@ export async function setAllManagerSettings(edits: EditAllManagerSettings[]): Pr workspaces.forEach((es, w) => { const config = workspace.getConfiguration('python-envs', w); const overrides = config.get('pythonProjects', []); + const projectsInspect = config.inspect('pythonProjects'); + const existingProjectsSetting = + projectsInspect?.workspaceFolderValue ?? projectsInspect?.workspaceValue ?? undefined; + const originalOverridesLength = overrides.length; + es.forEach((e) => { const pwPath = path.normalize(e.project.uri.fsPath); const index = overrides.findIndex((s) => path.resolve(w.uri.fsPath, s.path) === pwPath); @@ -142,33 +147,72 @@ export async function setAllManagerSettings(edits: EditAllManagerSettings[]): Pr packageManager: e.packageManager, }); } else { - if (config.get('defaultEnvManager') !== e.envManager) { + // Only write settings if: + // 1. There's already an explicit setting (we're updating it), OR + // 2. The new value is not the implicit fallback (system manager is the fallback) + const isSystemManager = e.envManager === 'ms-python.python:system'; + const envManagerInspect = config.inspect('defaultEnvManager'); + const hasExplicitEnvManager = + envManagerInspect?.workspaceFolderValue !== undefined || + envManagerInspect?.workspaceValue !== undefined; + + // Write if changing an existing setting, OR if setting to non-system manager + if ((hasExplicitEnvManager || !isSystemManager) && config.get('defaultEnvManager') !== e.envManager) { promises.push(config.update('defaultEnvManager', e.envManager, ConfigurationTarget.Workspace)); } - if (config.get('defaultPackageManager') !== e.packageManager) { + + const pkgManagerInspect = config.inspect('defaultPackageManager'); + const hasExplicitPkgManager = + pkgManagerInspect?.workspaceFolderValue !== undefined || + pkgManagerInspect?.workspaceValue !== undefined; + // For package manager, write if there's an explicit setting OR if env manager is being written + if ( + (hasExplicitPkgManager || !isSystemManager) && + config.get('defaultPackageManager') !== e.packageManager + ) { promises.push( config.update('defaultPackageManager', e.packageManager, ConfigurationTarget.Workspace), ); } } }); - promises.push( - config.update( - 'pythonProjects', - overrides, - workspaceFile ? ConfigurationTarget.WorkspaceFolder : ConfigurationTarget.Workspace, - ), - ); + + // Only write pythonProjects if: + // 1. There was already an explicit setting OR + // 2. adding new project entries + const shouldWriteProjects = existingProjectsSetting !== undefined || overrides.length > originalOverridesLength; + if (shouldWriteProjects) { + promises.push( + config.update( + 'pythonProjects', + overrides, + workspaceFile ? ConfigurationTarget.WorkspaceFolder : ConfigurationTarget.Workspace, + ), + ); + } }); const config = workspace.getConfiguration('python-envs', undefined); edits .filter((e) => !e.project) .forEach((e) => { - if (config.get('defaultEnvManager') !== e.envManager) { + // Only write global settings if: + // 1. There's already an explicit global setting (we're updating it), OR + // 2. The new value is not the implicit fallback (system manager) + const isSystemManager = e.envManager === 'ms-python.python:system'; + const envManagerInspect = config.inspect('defaultEnvManager'); + const hasExplicitGlobalEnvManager = envManagerInspect?.globalValue !== undefined; + + if ((hasExplicitGlobalEnvManager || !isSystemManager) && config.get('defaultEnvManager') !== e.envManager) { promises.push(config.update('defaultEnvManager', e.envManager, ConfigurationTarget.Global)); } - if (config.get('defaultPackageManager') !== e.packageManager) { + + const pkgManagerInspect = config.inspect('defaultPackageManager'); + const hasExplicitGlobalPkgManager = pkgManagerInspect?.globalValue !== undefined; + if ( + (hasExplicitGlobalPkgManager || !isSystemManager) && + config.get('defaultPackageManager') !== e.packageManager + ) { promises.push(config.update('defaultPackageManager', e.packageManager, ConfigurationTarget.Global)); } }); @@ -211,23 +255,45 @@ export async function setEnvironmentManager(edits: EditEnvManagerSettings[]): Pr workspaces.forEach((es, w) => { const config = workspace.getConfiguration('python-envs', w.uri); const overrides = config.get('pythonProjects', []); + const projectsInspect = config.inspect('pythonProjects'); + const existingProjectsSetting = projectsInspect?.workspaceValue ?? undefined; + const originalOverridesLength = overrides.length; + let projectsModified = false; + es.forEach((e) => { const pwPath = path.normalize(e.project.uri.fsPath); const index = overrides.findIndex((s) => path.resolve(w.uri.fsPath, s.path) === pwPath); if (index >= 0) { overrides[index].envManager = e.envManager; - } else if (config.get('defaultEnvManager') !== e.envManager) { - promises.push(config.update('defaultEnvManager', e.envManager, ConfigurationTarget.Workspace)); + projectsModified = true; + } else { + // Only write settings if updating existing OR setting non-system manager + const isSystemManager = e.envManager === 'ms-python.python:system'; + const envManagerInspect = config.inspect('defaultEnvManager'); + const hasExplicitEnvManager = envManagerInspect?.workspaceValue !== undefined; + if ((hasExplicitEnvManager || !isSystemManager) && config.get('defaultEnvManager') !== e.envManager) { + promises.push(config.update('defaultEnvManager', e.envManager, ConfigurationTarget.Workspace)); + } } }); - promises.push(config.update('pythonProjects', overrides, ConfigurationTarget.Workspace)); + + // Only write pythonProjects if there was an explicit setting or we modified entries + const shouldWriteProjects = + existingProjectsSetting !== undefined || overrides.length > originalOverridesLength || projectsModified; + if (shouldWriteProjects) { + promises.push(config.update('pythonProjects', overrides, ConfigurationTarget.Workspace)); + } }); const config = workspace.getConfiguration('python-envs', undefined); edits .filter((e) => !e.project) .forEach((e) => { - if (config.get('defaultEnvManager') !== e.envManager) { + // Only write global settings if updating existing OR setting non-system manager + const isSystemManager = e.envManager === 'ms-python.python:system'; + const envManagerInspect = config.inspect('defaultEnvManager'); + const hasExplicitGlobalEnvManager = envManagerInspect?.globalValue !== undefined; + if ((hasExplicitGlobalEnvManager || !isSystemManager) && config.get('defaultEnvManager') !== e.envManager) { promises.push(config.update('defaultEnvManager', e.envManager, ConfigurationTarget.Global)); } }); @@ -273,23 +339,53 @@ export async function setPackageManager(edits: EditPackageManagerSettings[]): Pr workspaces.forEach((es, w) => { const config = workspace.getConfiguration('python-envs', w.uri); const overrides = config.get('pythonProjects', []); + const projectsInspect = config.inspect('pythonProjects'); + const existingProjectsSetting = projectsInspect?.workspaceValue ?? undefined; + const originalOverridesLength = overrides.length; + let projectsModified = false; + es.forEach((e) => { const pwPath = path.normalize(e.project.uri.fsPath); const index = overrides.findIndex((s) => path.resolve(w.uri.fsPath, s.path) === pwPath); if (index >= 0) { overrides[index].packageManager = e.packageManager; - } else if (config.get('defaultPackageManager') !== e.packageManager) { - promises.push(config.update('defaultPackageManager', e.packageManager, ConfigurationTarget.Workspace)); + projectsModified = true; + } else { + // Only write settings if updating existing OR setting non-default package manager + const isPipManager = e.packageManager === 'ms-python.python:pip'; + const pkgManagerInspect = config.inspect('defaultPackageManager'); + const hasExplicitPkgManager = pkgManagerInspect?.workspaceValue !== undefined; + if ( + (hasExplicitPkgManager || !isPipManager) && + config.get('defaultPackageManager') !== e.packageManager + ) { + promises.push( + config.update('defaultPackageManager', e.packageManager, ConfigurationTarget.Workspace), + ); + } } }); - promises.push(config.update('pythonProjects', overrides, ConfigurationTarget.Workspace)); + + // Only write pythonProjects if there was an explicit setting or we modified entries + const shouldWriteProjects = + existingProjectsSetting !== undefined || overrides.length > originalOverridesLength || projectsModified; + if (shouldWriteProjects) { + promises.push(config.update('pythonProjects', overrides, ConfigurationTarget.Workspace)); + } }); const config = workspace.getConfiguration('python-envs', undefined); edits .filter((e) => !e.project) .forEach((e) => { - if (config.get('defaultPackageManager') !== e.packageManager) { + // Only write global settings if updating existing OR setting non-default package manager + const isPipManager = e.packageManager === 'ms-python.python:pip'; + const pkgManagerInspect = config.inspect('defaultPackageManager'); + const hasExplicitGlobalPkgManager = pkgManagerInspect?.globalValue !== undefined; + if ( + (hasExplicitGlobalPkgManager || !isPipManager) && + config.get('defaultPackageManager') !== e.packageManager + ) { promises.push(config.update('defaultPackageManager', e.packageManager, ConfigurationTarget.Global)); } }); From 9c1104f865bea7b9b92f90d4119cdfa05550d20b Mon Sep 17 00:00:00 2001 From: eleanorjboyd <26030610+eleanorjboyd@users.noreply.github.com> Date: Sun, 25 Jan 2026 16:43:00 -0800 Subject: [PATCH 2/2] add testing --- src/features/settings/settingHelpers.ts | 22 +- .../settings/settingHelpers.unit.test.ts | 331 ++++++++++++++++++ 2 files changed, 342 insertions(+), 11 deletions(-) create mode 100644 src/test/features/settings/settingHelpers.unit.test.ts diff --git a/src/features/settings/settingHelpers.ts b/src/features/settings/settingHelpers.ts index 0566953b..4f571c42 100644 --- a/src/features/settings/settingHelpers.ts +++ b/src/features/settings/settingHelpers.ts @@ -42,7 +42,7 @@ export function isDefaultEnvManagerBroken(): boolean { } export function getDefaultEnvManagerSetting(wm: PythonProjectManager, scope?: Uri): string { - const config = workspace.getConfiguration('python-envs', scope); + const config = getConfiguration('python-envs', scope); const settings = getSettings(wm, config, scope); if (settings && settings.envManager.length > 0) { return settings.envManager; @@ -69,7 +69,7 @@ export function getDefaultPkgManagerSetting( scope?: ConfigurationScope | null, defaultId?: string, ): string { - const config = workspace.getConfiguration('python-envs', scope); + const config = getConfiguration('python-envs', scope); const settings = getSettings(wm, config, scope); if (settings && settings.packageManager.length > 0) { @@ -127,7 +127,7 @@ export async function setAllManagerSettings(edits: EditAllManagerSettings[]): Pr const promises: Thenable[] = []; workspaces.forEach((es, w) => { - const config = workspace.getConfiguration('python-envs', w); + const config = getConfiguration('python-envs', w); const overrides = config.get('pythonProjects', []); const projectsInspect = config.inspect('pythonProjects'); const existingProjectsSetting = @@ -192,7 +192,7 @@ export async function setAllManagerSettings(edits: EditAllManagerSettings[]): Pr } }); - const config = workspace.getConfiguration('python-envs', undefined); + const config = getConfiguration('python-envs', undefined); edits .filter((e) => !e.project) .forEach((e) => { @@ -253,7 +253,7 @@ export async function setEnvironmentManager(edits: EditEnvManagerSettings[]): Pr const promises: Thenable[] = []; workspaces.forEach((es, w) => { - const config = workspace.getConfiguration('python-envs', w.uri); + const config = getConfiguration('python-envs', w.uri); const overrides = config.get('pythonProjects', []); const projectsInspect = config.inspect('pythonProjects'); const existingProjectsSetting = projectsInspect?.workspaceValue ?? undefined; @@ -285,7 +285,7 @@ export async function setEnvironmentManager(edits: EditEnvManagerSettings[]): Pr } }); - const config = workspace.getConfiguration('python-envs', undefined); + const config = getConfiguration('python-envs', undefined); edits .filter((e) => !e.project) .forEach((e) => { @@ -337,7 +337,7 @@ export async function setPackageManager(edits: EditPackageManagerSettings[]): Pr const promises: Thenable[] = []; workspaces.forEach((es, w) => { - const config = workspace.getConfiguration('python-envs', w.uri); + const config = getConfiguration('python-envs', w.uri); const overrides = config.get('pythonProjects', []); const projectsInspect = config.inspect('pythonProjects'); const existingProjectsSetting = projectsInspect?.workspaceValue ?? undefined; @@ -374,7 +374,7 @@ export async function setPackageManager(edits: EditPackageManagerSettings[]): Pr } }); - const config = workspace.getConfiguration('python-envs', undefined); + const config = getConfiguration('python-envs', undefined); edits .filter((e) => !e.project) .forEach((e) => { @@ -403,7 +403,7 @@ export interface EditProjectSettings { export async function addPythonProjectSetting(edits: EditProjectSettings[]): Promise { const noWorkspace: EditProjectSettings[] = []; const workspaces = new Map(); - const globalConfig = workspace.getConfiguration('python-envs', undefined); + const globalConfig = getConfiguration('python-envs', undefined); const envManager = globalConfig.get('defaultEnvManager', DEFAULT_ENV_MANAGER_ID); const pkgManager = globalConfig.get('defaultPackageManager', DEFAULT_PACKAGE_MANAGER_ID); @@ -424,7 +424,7 @@ export async function addPythonProjectSetting(edits: EditProjectSettings[]): Pro const promises: Thenable[] = []; workspaces.forEach((es, w) => { - const config = workspace.getConfiguration('python-envs', w.uri); + const config = getConfiguration('python-envs', w.uri); const overrides = config.get('pythonProjects', []); es.forEach((e) => { if (isMultiroot) { @@ -472,7 +472,7 @@ export async function removePythonProjectSetting(edits: EditProjectSettings[]): const promises: Thenable[] = []; workspaces.forEach((es, w) => { - const config = workspace.getConfiguration('python-envs', w.uri); + const config = getConfiguration('python-envs', w.uri); const overrides = config.get('pythonProjects', []); es.forEach((e) => { const pwPath = path.normalize(e.project.uri.fsPath); diff --git a/src/test/features/settings/settingHelpers.unit.test.ts b/src/test/features/settings/settingHelpers.unit.test.ts new file mode 100644 index 00000000..632c818b --- /dev/null +++ b/src/test/features/settings/settingHelpers.unit.test.ts @@ -0,0 +1,331 @@ +/* eslint-disable @typescript-eslint/no-explicit-any */ +import * as assert from 'assert'; +import * as sinon from 'sinon'; +import { ConfigurationTarget } from 'vscode'; +import * as workspaceApis from '../../../common/workspace.apis'; +import { setAllManagerSettings, setEnvironmentManager, setPackageManager } from '../../../features/settings/settingHelpers'; +import { MockWorkspaceConfiguration } from '../../mocks/mockWorkspaceConfig'; + +/** + * These tests verify that settings are NOT written unnecessarily when: + * 1. Setting the system manager (which is the implicit default/fallback) + * 2. Setting pip package manager (the default) + * + * This prevents the bug where opening a non-Python repo with defaultInterpreterPath + * set would write unwanted settings like "defaultEnvManager: system" to global settings. + * + * Note: These tests focus on the global settings path (project=undefined) because + * workspace-scoped tests would require mocking workspace.getWorkspaceFolder which + * cannot be easily stubbed in unit tests. + */ +suite('Setting Helpers - Avoid Unnecessary Settings Writes', () => { + const SYSTEM_MANAGER_ID = 'ms-python.python:system'; + const VENV_MANAGER_ID = 'ms-python.python:venv'; + const PIP_MANAGER_ID = 'ms-python.python:pip'; + const CONDA_MANAGER_ID = 'ms-python.python:conda'; + + let updateCalls: Array<{ key: string; value: unknown; target: ConfigurationTarget }>; + + setup(() => { + updateCalls = []; + }); + + teardown(() => { + sinon.restore(); + }); + + /** + * Creates a mock WorkspaceConfiguration that tracks update calls + */ + function createMockConfig(options: { + defaultEnvManagerGlobalValue?: string; + defaultPackageManagerGlobalValue?: string; + }): MockWorkspaceConfiguration { + const mockConfig = new MockWorkspaceConfiguration(); + + // Override inspect to return proper inspection results + (mockConfig as any).inspect = (section: string) => { + if (section === 'defaultEnvManager') { + return { + key: 'python-envs.defaultEnvManager', + defaultValue: VENV_MANAGER_ID, + globalValue: options.defaultEnvManagerGlobalValue, + workspaceValue: undefined, + workspaceFolderValue: undefined, + }; + } + if (section === 'defaultPackageManager') { + return { + key: 'python-envs.defaultPackageManager', + defaultValue: PIP_MANAGER_ID, + globalValue: options.defaultPackageManagerGlobalValue, + workspaceValue: undefined, + workspaceFolderValue: undefined, + }; + } + return undefined; + }; + + // Override get to return effective values + (mockConfig as any).get = (key: string, defaultValue?: T): T | undefined => { + if (key === 'defaultEnvManager') { + return (options.defaultEnvManagerGlobalValue ?? VENV_MANAGER_ID) as T; + } + if (key === 'defaultPackageManager') { + return (options.defaultPackageManagerGlobalValue ?? PIP_MANAGER_ID) as T; + } + return defaultValue; + }; + + // Override update to track calls + mockConfig.update = ( + section: string, + value: unknown, + configurationTarget?: boolean | ConfigurationTarget, + ): Promise => { + updateCalls.push({ + key: section, + value, + target: configurationTarget as ConfigurationTarget, + }); + return Promise.resolve(); + }; + + return mockConfig; + } + + suite('setAllManagerSettings - Global Settings', () => { + test('should NOT write global defaultEnvManager when setting system manager with no existing setting', async () => { + const mockConfig = createMockConfig({ + // No explicit global settings + }); + sinon.stub(workspaceApis, 'getConfiguration').returns(mockConfig); + + await setAllManagerSettings([ + { + project: undefined, // Global scope + envManager: SYSTEM_MANAGER_ID, + packageManager: PIP_MANAGER_ID, + }, + ]); + + const envManagerUpdates = updateCalls.filter( + (c) => c.key === 'defaultEnvManager' && c.target === ConfigurationTarget.Global, + ); + assert.strictEqual( + envManagerUpdates.length, + 0, + 'Should NOT write global defaultEnvManager when setting system manager with no existing setting', + ); + }); + + test('should NOT write global defaultPackageManager when setting pip with no existing setting', async () => { + const mockConfig = createMockConfig({ + // No explicit global settings + }); + sinon.stub(workspaceApis, 'getConfiguration').returns(mockConfig); + + await setAllManagerSettings([ + { + project: undefined, // Global scope + envManager: SYSTEM_MANAGER_ID, + packageManager: PIP_MANAGER_ID, + }, + ]); + + const pkgManagerUpdates = updateCalls.filter( + (c) => c.key === 'defaultPackageManager' && c.target === ConfigurationTarget.Global, + ); + assert.strictEqual( + pkgManagerUpdates.length, + 0, + 'Should NOT write global defaultPackageManager when setting pip with no existing setting', + ); + }); + + test('should write global defaultEnvManager when there is an existing global setting', async () => { + const mockConfig = createMockConfig({ + defaultEnvManagerGlobalValue: VENV_MANAGER_ID, // Existing global setting + defaultPackageManagerGlobalValue: PIP_MANAGER_ID, + }); + sinon.stub(workspaceApis, 'getConfiguration').returns(mockConfig); + + await setAllManagerSettings([ + { + project: undefined, + envManager: SYSTEM_MANAGER_ID, + packageManager: PIP_MANAGER_ID, + }, + ]); + + const envManagerUpdates = updateCalls.filter( + (c) => c.key === 'defaultEnvManager' && c.target === ConfigurationTarget.Global, + ); + assert.strictEqual( + envManagerUpdates.length, + 1, + 'Should write global defaultEnvManager when there is an existing global setting', + ); + assert.strictEqual(envManagerUpdates[0].value, SYSTEM_MANAGER_ID); + }); + + test('should write global defaultEnvManager when setting NON-system manager (venv) with no existing setting', async () => { + const mockConfig = createMockConfig({ + // No explicit global settings, but mock get to return system + }); + // Override get to return system (so setting venv would be a change) + (mockConfig as any).get = (key: string): T | undefined => { + if (key === 'defaultEnvManager') { + return SYSTEM_MANAGER_ID as T; + } + if (key === 'defaultPackageManager') { + return PIP_MANAGER_ID as T; + } + return undefined; + }; + sinon.stub(workspaceApis, 'getConfiguration').returns(mockConfig); + + await setAllManagerSettings([ + { + project: undefined, + envManager: VENV_MANAGER_ID, // Non-system manager + packageManager: PIP_MANAGER_ID, + }, + ]); + + const envManagerUpdates = updateCalls.filter( + (c) => c.key === 'defaultEnvManager' && c.target === ConfigurationTarget.Global, + ); + assert.strictEqual( + envManagerUpdates.length, + 1, + 'Should write global defaultEnvManager when setting venv (non-system) manager', + ); + assert.strictEqual(envManagerUpdates[0].value, VENV_MANAGER_ID); + }); + + test('should write global defaultPackageManager when setting NON-pip manager (conda) with no existing setting', async () => { + const mockConfig = createMockConfig({ + // No explicit global settings + }); + // Override get to return current pip value + (mockConfig as any).get = (key: string): T | undefined => { + if (key === 'defaultEnvManager') { + return VENV_MANAGER_ID as T; + } + if (key === 'defaultPackageManager') { + return PIP_MANAGER_ID as T; + } + return undefined; + }; + sinon.stub(workspaceApis, 'getConfiguration').returns(mockConfig); + + await setAllManagerSettings([ + { + project: undefined, + envManager: VENV_MANAGER_ID, // Non-system manager to trigger pkg manager write + packageManager: CONDA_MANAGER_ID, // Non-pip manager + }, + ]); + + const pkgManagerUpdates = updateCalls.filter( + (c) => c.key === 'defaultPackageManager' && c.target === ConfigurationTarget.Global, + ); + assert.strictEqual( + pkgManagerUpdates.length, + 1, + 'Should write global defaultPackageManager when setting non-pip manager', + ); + assert.strictEqual(pkgManagerUpdates[0].value, CONDA_MANAGER_ID); + }); + }); + + suite('setEnvironmentManager - Global Settings', () => { + test('should NOT write when setting system manager with no existing global setting', async () => { + const mockConfig = createMockConfig({ + // No existing settings + }); + sinon.stub(workspaceApis, 'getConfiguration').returns(mockConfig); + + await setEnvironmentManager([ + { + project: undefined, // Global scope + envManager: SYSTEM_MANAGER_ID, + }, + ]); + + const envManagerUpdates = updateCalls.filter( + (c) => c.key === 'defaultEnvManager' && c.target === ConfigurationTarget.Global, + ); + assert.strictEqual( + envManagerUpdates.length, + 0, + 'Should NOT write global defaultEnvManager for system manager with no existing setting', + ); + }); + + test('should write when there is an existing global setting', async () => { + const mockConfig = createMockConfig({ + defaultEnvManagerGlobalValue: VENV_MANAGER_ID, + }); + sinon.stub(workspaceApis, 'getConfiguration').returns(mockConfig); + + await setEnvironmentManager([ + { + project: undefined, + envManager: SYSTEM_MANAGER_ID, + }, + ]); + + const envManagerUpdates = updateCalls.filter( + (c) => c.key === 'defaultEnvManager' && c.target === ConfigurationTarget.Global, + ); + assert.strictEqual(envManagerUpdates.length, 1, 'Should write when updating existing global setting'); + }); + }); + + suite('setPackageManager - Global Settings', () => { + test('should NOT write when setting pip manager with no existing global setting', async () => { + const mockConfig = createMockConfig({ + // No existing settings + }); + sinon.stub(workspaceApis, 'getConfiguration').returns(mockConfig); + + await setPackageManager([ + { + project: undefined, // Global scope + packageManager: PIP_MANAGER_ID, + }, + ]); + + const pkgManagerUpdates = updateCalls.filter( + (c) => c.key === 'defaultPackageManager' && c.target === ConfigurationTarget.Global, + ); + assert.strictEqual( + pkgManagerUpdates.length, + 0, + 'Should NOT write global defaultPackageManager for pip manager with no existing setting', + ); + }); + + test('should write when there is an existing global setting', async () => { + const mockConfig = createMockConfig({ + defaultPackageManagerGlobalValue: CONDA_MANAGER_ID, + }); + sinon.stub(workspaceApis, 'getConfiguration').returns(mockConfig); + + await setPackageManager([ + { + project: undefined, + packageManager: PIP_MANAGER_ID, + }, + ]); + + const pkgManagerUpdates = updateCalls.filter( + (c) => c.key === 'defaultPackageManager' && c.target === ConfigurationTarget.Global, + ); + assert.strictEqual(pkgManagerUpdates.length, 1, 'Should write when updating existing global setting'); + }); + }); +}); +