Add "Don't show again" button to env file notification

Copilot · eleanorjboyd · Copilot · commit 70a00870d2af · 2026-01-12T16:21:19.000Z
- Added localized string 'dontShowAgain' in Common namespace
- Modified TerminalEnvVarInjector to check persistent state before showing notification
- Added showEnvFileNotification method with "Don't Show Again" button
- Created comprehensive unit tests for the notification functionality

Co-authored-by: eleanorjboyd &lt;26030610+eleanorjboyd@users.noreply.github.com&gt;
diff --git a/src/common/localize.ts b/src/common/localize.ts
@@ -15,6 +15,7 @@ export namespace Common {
     export const ok = l10n.t('Ok');
     export const quickCreate = l10n.t('Quick Create');
     export const installPython = l10n.t('Install Python');
+    export const dontShowAgain = l10n.t("Don't Show Again");
 }
 
 export namespace WorkbenchStrings {
diff --git a/src/features/terminal/terminalEnvVarInjector.ts b/src/features/terminal/terminalEnvVarInjector.ts
@@ -15,13 +15,16 @@ import { traceError, traceVerbose } from '../../common/logging';
 import { resolveVariables } from '../../common/utils/internalVariables';
 import { getConfiguration, getWorkspaceFolder } from '../../common/workspace.apis';
 import { EnvVarManager } from '../execution/envVariableManager';
+import { getGlobalPersistentState } from '../../common/persistentState';
+import { Common } from '../../common/localize';
 
 /**
  * Manages injection of workspace-specific environment variables into VS Code terminals
  * using the GlobalEnvironmentVariableCollection API.
  */
 export class TerminalEnvVarInjector implements Disposable {
     private disposables: Disposable[] = [];
+    private static readonly DONT_SHOW_ENV_FILE_NOTIFICATION_KEY = 'dontShowEnvFileNotification';
 
     constructor(
         private readonly envVarCollection: GlobalEnvironmentVariableCollection,
@@ -63,9 +66,9 @@ export class TerminalEnvVarInjector implements Disposable {
 
                 // Only show notification when env vars change and we have an env file but injection is disabled
                 if (!useEnvFile && envFilePath) {
-                    window.showInformationMessage(
-                        'An environment file is configured but terminal environment injection is disabled. Enable "python.terminal.useEnvFile" to use environment variables from .env files in terminals.',
-                    );
+                    this.showEnvFileNotification().catch((error) => {
+                        traceError('Failed to show environment file notification:', error);
+                    });
                 }
 
                 if (args.changeType === 2) {
@@ -184,6 +187,29 @@ export class TerminalEnvVarInjector implements Disposable {
         }
     }
 
+    /**
+     * Show notification about environment file configuration with "Don't show again" option.
+     */
+    private async showEnvFileNotification(): Promise<void> {
+        const state = await getGlobalPersistentState();
+        const dontShowAgain = await state.get<boolean>(TerminalEnvVarInjector.DONT_SHOW_ENV_FILE_NOTIFICATION_KEY, false);
+
+        if (dontShowAgain) {
+            traceVerbose('TerminalEnvVarInjector: Env file notification suppressed by user preference');
+            return;
+        }
+
+        const result = await window.showInformationMessage(
+            'An environment file is configured but terminal environment injection is disabled. Enable "python.terminal.useEnvFile" to use environment variables from .env files in terminals.',
+            Common.dontShowAgain,
+        );
+
+        if (result === Common.dontShowAgain) {
+            await state.set(TerminalEnvVarInjector.DONT_SHOW_ENV_FILE_NOTIFICATION_KEY, true);
+            traceVerbose('TerminalEnvVarInjector: User chose to not show env file notification again');
+        }
+    }
+
     /**
      * Dispose of the injector and clean up resources.
      */
diff --git a/src/test/features/terminalEnvVarInjectorNotification.unit.test.ts b/src/test/features/terminalEnvVarInjectorNotification.unit.test.ts
@@ -0,0 +1,228 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import * as assert from 'node:assert';
+import * as sinon from 'sinon';
+import * as typeMoq from 'typemoq';
+import { GlobalEnvironmentVariableCollection, Uri, window, workspace } from 'vscode';
+import { EnvVarManager } from '../../features/execution/envVariableManager';
+import { TerminalEnvVarInjector } from '../../features/terminal/terminalEnvVarInjector';
+import * as persistentState from '../../common/persistentState';
+import * as workspaceApis from '../../common/workspace.apis';
+import { Common } from '../../common/localize';
+
+interface MockScopedCollection {
+    clear: sinon.SinonStub;
+    replace: sinon.SinonStub;
+    delete: sinon.SinonStub;
+}
+
+suite('TerminalEnvVarInjector Notification Tests', () => {
+    let envVarCollection: typeMoq.IMock<GlobalEnvironmentVariableCollection>;
+    let envVarManager: typeMoq.IMock<EnvVarManager>;
+    let injector: TerminalEnvVarInjector;
+    let mockScopedCollection: MockScopedCollection;
+    let mockGetGlobalPersistentState: sinon.SinonStub;
+    let mockState: { get: sinon.SinonStub; set: sinon.SinonStub; clear: sinon.SinonStub };
+    let mockGetConfiguration: sinon.SinonStub;
+    let mockGetWorkspaceFolder: sinon.SinonStub;
+    let mockShowInformationMessage: sinon.SinonStub;
+    let envVarChangeHandler: (args: { uri?: Uri; changeType?: number }) => void;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let workspaceFoldersStub: any;
+
+    setup(() => {
+        envVarCollection = typeMoq.Mock.ofType<GlobalEnvironmentVariableCollection>();
+        envVarManager = typeMoq.Mock.ofType<EnvVarManager>();
+
+        // Mock workspace.workspaceFolders property
+        workspaceFoldersStub = [];
+        Object.defineProperty(workspace, 'workspaceFolders', {
+            get: () => workspaceFoldersStub,
+            configurable: true,
+        });
+
+        // Setup scoped collection mock
+        mockScopedCollection = {
+            clear: sinon.stub(),
+            replace: sinon.stub(),
+            delete: sinon.stub(),
+        };
+
+        // Setup environment variable collection to return scoped collection
+        envVarCollection
+            .setup((x) => x.getScoped(typeMoq.It.isAny()))
+            .returns(
+                () => mockScopedCollection as unknown as ReturnType<GlobalEnvironmentVariableCollection['getScoped']>,
+            );
+        envVarCollection.setup((x) => x.clear()).returns(() => {});
+
+        // Setup persistent state mocks
+        mockState = {
+            get: sinon.stub(),
+            set: sinon.stub().resolves(),
+            clear: sinon.stub().resolves(),
+        };
+        mockGetGlobalPersistentState = sinon.stub(persistentState, 'getGlobalPersistentState').resolves(mockState);
+
+        // Setup workspace API mocks
+        mockGetConfiguration = sinon.stub(workspaceApis, 'getConfiguration');
+        mockGetWorkspaceFolder = sinon.stub(workspaceApis, 'getWorkspaceFolder');
+
+        // Setup window.showInformationMessage mock
+        mockShowInformationMessage = sinon.stub(window, 'showInformationMessage').resolves(undefined);
+
+        // Setup environment variable change event handler
+        envVarManager
+            .setup((m) => m.onDidChangeEnvironmentVariables)
+            .returns((handler) => {
+                envVarChangeHandler = handler;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return { dispose: () => {} } as any;
+            });
+    });
+
+    teardown(() => {
+        sinon.restore();
+        injector?.dispose();
+    });
+
+    test('should show notification when env file exists and useEnvFile is false (first time)', async () => {
+        // Arrange - user has not dismissed the notification before
+        mockState.get.resolves(false);
+
+        const mockConfig = {
+            get: sinon.stub(),
+        };
+        mockConfig.get.withArgs('terminal.useEnvFile', false).returns(false);
+        mockConfig.get.withArgs('envFile').returns('.env');
+        mockGetConfiguration.returns(mockConfig);
+
+        const testUri = Uri.file('/workspace');
+        mockGetWorkspaceFolder.returns({ uri: testUri });
+
+        // Act - create injector and trigger env var change
+        injector = new TerminalEnvVarInjector(envVarCollection.object, envVarManager.object);
+        await new Promise((resolve) => setTimeout(resolve, 10)); // Allow async initialization
+
+        envVarChangeHandler({ uri: testUri });
+        await new Promise((resolve) => setTimeout(resolve, 10)); // Allow async notification
+
+        // Assert - notification should be shown
+        assert(mockShowInformationMessage.called, 'showInformationMessage should be called');
+        const notificationCall = mockShowInformationMessage.getCall(0);
+        assert(
+            notificationCall.args[0].includes('environment file is configured'),
+            'Notification should mention environment file',
+        );
+        assert.strictEqual(
+            notificationCall.args[1],
+            Common.dontShowAgain,
+            'Notification should have "Don\'t Show Again" button',
+        );
+    });
+
+    test('should not show notification when user has clicked "Don\'t Show Again"', async () => {
+        // Arrange - user has previously dismissed the notification
+        mockState.get.resolves(true);
+
+        const mockConfig = {
+            get: sinon.stub(),
+        };
+        mockConfig.get.withArgs('terminal.useEnvFile', false).returns(false);
+        mockConfig.get.withArgs('envFile').returns('.env');
+        mockGetConfiguration.returns(mockConfig);
+
+        const testUri = Uri.file('/workspace');
+        mockGetWorkspaceFolder.returns({ uri: testUri });
+
+        // Act - create injector and trigger env var change
+        injector = new TerminalEnvVarInjector(envVarCollection.object, envVarManager.object);
+        await new Promise((resolve) => setTimeout(resolve, 10)); // Allow async initialization
+
+        envVarChangeHandler({ uri: testUri });
+        await new Promise((resolve) => setTimeout(resolve, 10)); // Allow async notification
+
+        // Assert - notification should NOT be shown
+        assert(!mockShowInformationMessage.called, 'showInformationMessage should not be called');
+    });
+
+    test('should store preference when user clicks "Don\'t Show Again"', async () => {
+        // Arrange - user clicks the "Don't Show Again" button
+        mockState.get.resolves(false);
+        mockShowInformationMessage.resolves(Common.dontShowAgain);
+
+        const mockConfig = {
+            get: sinon.stub(),
+        };
+        mockConfig.get.withArgs('terminal.useEnvFile', false).returns(false);
+        mockConfig.get.withArgs('envFile').returns('.env');
+        mockGetConfiguration.returns(mockConfig);
+
+        const testUri = Uri.file('/workspace');
+        mockGetWorkspaceFolder.returns({ uri: testUri });
+
+        // Act - create injector and trigger env var change
+        injector = new TerminalEnvVarInjector(envVarCollection.object, envVarManager.object);
+        await new Promise((resolve) => setTimeout(resolve, 10)); // Allow async initialization
+
+        envVarChangeHandler({ uri: testUri });
+        await new Promise((resolve) => setTimeout(resolve, 50)); // Allow async notification and state update
+
+        // Assert - state should be set to true
+        assert(mockState.set.called, 'state.set should be called');
+        const setCall = mockState.set.getCall(0);
+        assert.strictEqual(setCall.args[0], 'dontShowEnvFileNotification', 'Should use correct state key');
+        assert.strictEqual(setCall.args[1], true, 'Should set state to true');
+    });
+
+    test('should not show notification when useEnvFile is true', async () => {
+        // Arrange - useEnvFile is enabled
+        mockState.get.resolves(false);
+
+        const mockConfig = {
+            get: sinon.stub(),
+        };
+        mockConfig.get.withArgs('terminal.useEnvFile', false).returns(true); // enabled
+        mockConfig.get.withArgs('envFile').returns('.env');
+        mockGetConfiguration.returns(mockConfig);
+
+        const testUri = Uri.file('/workspace');
+        mockGetWorkspaceFolder.returns({ uri: testUri });
+
+        // Act - create injector and trigger env var change
+        injector = new TerminalEnvVarInjector(envVarCollection.object, envVarManager.object);
+        await new Promise((resolve) => setTimeout(resolve, 10)); // Allow async initialization
+
+        envVarChangeHandler({ uri: testUri });
+        await new Promise((resolve) => setTimeout(resolve, 10)); // Allow async notification
+
+        // Assert - notification should NOT be shown
+        assert(!mockShowInformationMessage.called, 'showInformationMessage should not be called');
+    });
+
+    test('should not show notification when envFile is not configured', async () => {
+        // Arrange - no envFile configured
+        mockState.get.resolves(false);
+
+        const mockConfig = {
+            get: sinon.stub(),
+        };
+        mockConfig.get.withArgs('terminal.useEnvFile', false).returns(false);
+        mockConfig.get.withArgs('envFile').returns(undefined); // no env file
+        mockGetConfiguration.returns(mockConfig);
+
+        const testUri = Uri.file('/workspace');
+        mockGetWorkspaceFolder.returns({ uri: testUri });
+
+        // Act - create injector and trigger env var change
+        injector = new TerminalEnvVarInjector(envVarCollection.object, envVarManager.object);
+        await new Promise((resolve) => setTimeout(resolve, 10)); // Allow async initialization
+
+        envVarChangeHandler({ uri: testUri });
+        await new Promise((resolve) => setTimeout(resolve, 10)); // Allow async notification
+
+        // Assert - notification should NOT be shown
+        assert(!mockShowInformationMessage.called, 'showInformationMessage should not be called');
+    });
+});

Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@ export namespace Common {`
`15`	`15`	`export const ok = l10n.t('Ok');`
`16`	`16`	`export const quickCreate = l10n.t('Quick Create');`
`17`	`17`	`export const installPython = l10n.t('Install Python');`
	`18`	`+ export const dontShowAgain = l10n.t("Don't Show Again");`
`18`	`19`	`}`
`19`	`20`
`20`	`21`	`export namespace WorkbenchStrings {`