Honor effective environment extension enablement consistently

Co-authored-by: eleanorjboyd <26030610+eleanorjboyd@users.noreply.github.com>

Author: Copilot

README.md

@@ -22,7 +22,9 @@ These extensions are optional dependencies, meaning the Python extension will re
 You may now see that the **Python Environments Extension** is installed for you, but it may or may not be "enabled" in your VS Code experience. Enablement is controlled by the setting `"python.useEnvironmentsExtension": true` (or `false`).
 
 - If you set this setting to `true`, you will manually opt in to using the Python Environments Extension for environment management.
-- If you do not have this setting specified, you may be randomly assigned to have it turned on as we roll it out until it becomes the default experience for all users.
+- If you set this setting to `false`, you will opt out. Explicit settings take precedence over experiment assignments, with folder settings overriding workspace settings and workspace settings overriding user settings.
+- If you do not have this setting specified, an experiment assignment can enable or disable it. Without an assignment (including when experiments or telemetry are disabled), it defaults to enabled.
+- In multi-root workspaces, an effectively disabled folder disables Python Environments integration for the entire window. Reload the window after changing this setting.
 
 The Python Environments Extension is still under active development and experimentation. Its goal is to provide a dedicated view and improved workflows for creating, deleting, and switching between Python environments, as well as managing packages. If you have feedback, please let us know via [issues](https://github.com/microsoft/vscode-python/issues).
 

package.json

@@ -447,7 +447,7 @@
                     "type": "string"
                 },
                 "python.useEnvironmentsExtension": {
-                    "default": false,
+                    "default": true,
                     "description": "%python.useEnvironmentsExtension.description%",
                     "scope": "machine-overridable",
                     "type": "boolean",

src/client/envExt/api.internal.ts

@@ -24,45 +24,26 @@ export function isEnvExtensionInstalled(): boolean {
 }
 
 /**
- * Returns true if the Python Environments extension is installed and not explicitly
- * disabled by the user. Mirrors the envs extension's own activation logic: it
- * deactivates only when `python.useEnvironmentsExtension` is explicitly set to false
- * at the global, workspace, or workspace-folder level.
+ * Uses the same window-wide decision for terminal activation and UI ownership as
+ * environment discovery and API routing.
  */
 export function shouldEnvExtHandleActivation(): boolean {
-    if (!isEnvExtensionInstalled()) {
-        return false;
-    }
-    const config = getConfiguration('python');
-    const inspection = config.inspect<boolean>('useEnvironmentsExtension');
-    if (inspection?.globalValue === false || inspection?.workspaceValue === false) {
-        return false;
-    }
-    // The envs extension also checks folder-scoped settings in multi-root workspaces.
-    // Any single folder with the setting set to false causes the envs extension to
-    // deactivate entirely (window-wide), so we must mirror that here.
-    const workspaceFolders = getWorkspaceFolders();
-    if (workspaceFolders) {
-        for (const folder of workspaceFolders) {
-            const folderConfig = getConfiguration('python', folder.uri);
-            const folderInspection = folderConfig.inspect<boolean>('useEnvironmentsExtension');
-            if (folderInspection?.workspaceFolderValue === false) {
-                return false;
-            }
-        }
-    }
-    return true;
+    return useEnvExtension();
 }
 
 let _useExt: boolean | undefined;
 export function useEnvExtension(): boolean {
     if (_useExt !== undefined) {
         return _useExt;
     }
-    const config = getConfiguration('python');
-    const inExpSetting = config?.get<boolean>('useEnvironmentsExtension', false) ?? false;
-    // If extension is installed and in experiment, then use it.
-    _useExt = !!getExtension(ENVS_EXTENSION_ID) && inExpSetting;
+    // Configuration.get resolves folder > workspace > user > experiment/manifest default.
+    // Any effectively disabled folder disables environment management for the window.
+    const isEnabled = (resource?: Uri) =>
+        getConfiguration('python', resource).get<boolean>('useEnvironmentsExtension') ?? true;
+    const folders = getWorkspaceFolders();
+    // Keep all consumers on the same decision until reload, as required by the setting.
+    _useExt =
+        isEnvExtensionInstalled() && (folders?.length ? folders.every((folder) => isEnabled(folder.uri)) : isEnabled());
     return _useExt;
 }
 

src/test/common/terminals/activator/index.unit.test.ts

@@ -4,6 +4,7 @@
 'use strict';
 
 import { assert } from 'chai';
+import rewiremock from 'rewiremock';
 import * as sinon from 'sinon';
 import * as TypeMoq from 'typemoq';
 import { Terminal, Uri } from 'vscode';
@@ -138,15 +139,46 @@ suite('Terminal Activator', () => {
 });
 
 suite('shouldEnvExtHandleActivation', () => {
+    let api: typeof extapi;
     let getExtensionStub: sinon.SinonStub;
     let getConfigurationStub: sinon.SinonStub;
     let getWorkspaceFoldersStub: sinon.SinonStub;
 
+    type SettingValues = {
+        defaultValue?: boolean;
+        globalValue?: boolean;
+        workspaceValue?: boolean;
+        workspaceFolderValue?: boolean;
+    };
+
+    function configuration(values: SettingValues = {}) {
+        return {
+            get: sinon
+                .stub()
+                .withArgs('useEnvironmentsExtension')
+                .returns(
+                    values.workspaceFolderValue ?? values.workspaceValue ?? values.globalValue ?? values.defaultValue,
+                ),
+            inspect: sinon.stub().returns(values),
+        };
+    }
+
+    function assertOwnership(expected: boolean) {
+        assert.strictEqual(api.shouldEnvExtHandleActivation(), expected);
+        assert.strictEqual(api.useEnvExtension(), expected);
+    }
+
     setup(() => {
         getExtensionStub = sinon.stub(extensionsApi, 'getExtension');
+        getExtensionStub.returns({ id: extapi.ENVS_EXTENSION_ID });
         getConfigurationStub = sinon.stub(workspaceApis, 'getConfiguration');
-        getWorkspaceFoldersStub = sinon.stub(workspaceApis, 'getWorkspaceFolders');
-        getWorkspaceFoldersStub.returns(undefined);
+        getConfigurationStub.returns(configuration());
+        getWorkspaceFoldersStub = sinon.stub(workspaceApis, 'getWorkspaceFolders').returns(undefined);
+        // A fresh module represents a new window, including its cached ownership decision.
+        api = rewiremock.proxy(() => require('../../../../client/envExt/api.internal'), {
+            [require.resolve('../../../../client/common/vscodeApis/extensionsApi')]: extensionsApi,
+            [require.resolve('../../../../client/common/vscodeApis/workspaceApis')]: workspaceApis,
+        });
     });
 
     teardown(() => {
@@ -155,55 +187,115 @@ suite('shouldEnvExtHandleActivation', () => {
 
     test('Returns false when envs extension is not installed', () => {
         getExtensionStub.returns(undefined);
-        assert.strictEqual(extapi.shouldEnvExtHandleActivation(), false);
+        assertOwnership(false);
     });
 
-    test('Returns true when envs extension is installed and setting is not explicitly set', () => {
-        getExtensionStub.returns({ id: extapi.ENVS_EXTENSION_ID });
-        getConfigurationStub.returns({
-            inspect: () => ({ globalValue: undefined, workspaceValue: undefined }),
-        });
-        assert.strictEqual(extapi.shouldEnvExtHandleActivation(), true);
+    test('Registers an enabled fallback that experiments can override', () => {
+        const manifest = require('../../../../../package.json');
+        const setting = manifest.contributes.configuration.properties['python.useEnvironmentsExtension'];
+        assert.strictEqual(setting.default, true);
+        assert.include(setting.tags, 'onExP');
     });
 
-    test('Returns false when envs extension is installed but globalValue is false', () => {
-        getExtensionStub.returns({ id: extapi.ENVS_EXTENSION_ID });
-        getConfigurationStub.returns({
-            inspect: () => ({ globalValue: false, workspaceValue: undefined }),
+    [undefined, true, false].forEach((defaultValue) => {
+        [undefined, true, false].forEach((globalValue) => {
+            [undefined, true, false].forEach((workspaceValue) => {
+                test(`Uses effective value: default=${defaultValue}, user=${globalValue}, workspace=${workspaceValue}`, () => {
+                    const config = configuration({ defaultValue, globalValue, workspaceValue });
+                    getConfigurationStub.returns(config);
+
+                    assertOwnership(workspaceValue ?? globalValue ?? defaultValue ?? true);
+                    sinon.assert.calledWithExactly(config.get, 'useEnvironmentsExtension');
+                    sinon.assert.notCalled(config.inspect);
+                });
+            });
         });
-        assert.strictEqual(extapi.shouldEnvExtHandleActivation(), false);
     });
 
-    test('Returns false when envs extension is installed but workspaceValue is false', () => {
-        getExtensionStub.returns({ id: extapi.ENVS_EXTENSION_ID });
-        getConfigurationStub.returns({
-            inspect: () => ({ globalValue: undefined, workspaceValue: false }),
+    [undefined, []].forEach((folders) => {
+        test(`Uses window configuration when workspace folders are ${JSON.stringify(folders)}`, () => {
+            getWorkspaceFoldersStub.returns(folders);
+            getConfigurationStub.returns(configuration({ defaultValue: false }));
+
+            assertOwnership(false);
+            sinon.assert.calledWithExactly(getConfigurationStub, 'python', undefined);
         });
-        assert.strictEqual(extapi.shouldEnvExtHandleActivation(), false);
     });
 
-    test('Returns true when envs extension is installed and setting is explicitly true', () => {
-        getExtensionStub.returns({ id: extapi.ENVS_EXTENSION_ID });
-        getConfigurationStub.returns({
-            inspect: () => ({ globalValue: true, workspaceValue: undefined }),
+    const folderCases: {
+        name: string;
+        inherited: SettingValues;
+        folders: (boolean | undefined)[];
+        expected: boolean;
+    }[] = [
+        {
+            name: 'a single folder true overrides workspace and user false',
+            inherited: { globalValue: false, workspaceValue: false },
+            folders: [true],
+            expected: true,
+        },
+        {
+            name: 'all folders true override workspace false',
+            inherited: { workspaceValue: false },
+            folders: [true, true],
+            expected: true,
+        },
+        {
+            name: 'one folder false disables the whole window',
+            inherited: { globalValue: true },
+            folders: [true, false],
+            expected: false,
+        },
+        {
+            name: 'an unset folder inherits workspace false',
+            inherited: { workspaceValue: false },
+            folders: [true, undefined],
+            expected: false,
+        },
+        {
+            name: 'workspace true overrides user and experiment false in every folder',
+            inherited: { defaultValue: false, globalValue: false, workspaceValue: true },
+            folders: [undefined, undefined],
+            expected: true,
+        },
+        {
+            name: 'an unset folder inherits experiment false',
+            inherited: { defaultValue: false },
+            folders: [true, undefined],
+            expected: false,
+        },
+        {
+            name: 'unset folders without a treatment default to enabled',
+            inherited: {},
+            folders: [undefined, undefined],
+            expected: true,
+        },
+    ];
+    folderCases.forEach(({ name, inherited, folders, expected }) => {
+        test(`Uses folder precedence: ${name}`, () => {
+            const workspaceFolders = folders.map((workspaceFolderValue, index) => {
+                const uri = Uri.parse(`file:///workspace/folder${index}`);
+                getConfigurationStub
+                    .withArgs('python', uri)
+                    .returns(configuration({ ...inherited, workspaceFolderValue }));
+                return { uri, name: `folder${index}`, index };
+            });
+            getWorkspaceFoldersStub.returns(workspaceFolders);
+            getConfigurationStub.withArgs('python', undefined).returns(configuration(inherited));
+
+            assertOwnership(expected);
+            assert.isTrue(getConfigurationStub.firstCall.args[1] instanceof Uri);
         });
-        assert.strictEqual(extapi.shouldEnvExtHandleActivation(), true);
     });
 
-    test('Returns false when a workspace folder has workspaceFolderValue set to false', () => {
-        getExtensionStub.returns({ id: extapi.ENVS_EXTENSION_ID });
-        const folderUri = Uri.parse('file:///workspace/folder1');
-        getWorkspaceFoldersStub.returns([{ uri: folderUri, name: 'folder1', index: 0 }]);
-        getConfigurationStub.callsFake((_section: string, scope?: Uri) => {
-            if (scope) {
-                return {
-                    inspect: () => ({ workspaceFolderValue: false }),
-                };
-            }
-            return {
-                inspect: () => ({ globalValue: undefined, workspaceValue: undefined }),
-            };
+    [false, true].forEach((enabled) => {
+        test(`Keeps ownership aligned until reload after an initial ${enabled} decision`, () => {
+            getConfigurationStub.returns(configuration({ defaultValue: enabled }));
+            assert.strictEqual(api.useEnvExtension(), enabled);
+
+            getConfigurationStub.returns(configuration({ globalValue: !enabled }));
+
+            assertOwnership(enabled);
         });
-        assert.strictEqual(extapi.shouldEnvExtHandleActivation(), false);
     });
 });