dont automatically inject PYTHONSTARTUP

src/client/common/terminal/service.ts

@@ -2,7 +2,6 @@
 // Licensed under the MIT License.
 
 import { inject, injectable } from 'inversify';
-import * as path from 'path';
 import { CancellationToken, Disposable, Event, EventEmitter, Terminal } from 'vscode';
 import '../../common/extensions';
 import { IInterpreterService } from '../../interpreter/contracts';
@@ -11,7 +10,6 @@ import { captureTelemetry } from '../../telemetry';
 import { EventName } from '../../telemetry/constants';
 import { ITerminalAutoActivation } from '../../terminals/types';
 import { ITerminalManager } from '../application/types';
-import { EXTENSION_ROOT_DIR } from '../constants';
 import { _SCRIPTS_DIR } from '../process/internal/scripts/constants';
 import { IConfigurationService, IDisposableRegistry } from '../types';
 import {
@@ -33,7 +31,6 @@ export class TerminalService implements ITerminalService, Disposable {
     private terminalHelper: ITerminalHelper;
     private terminalActivator: ITerminalActivator;
     private terminalAutoActivator: ITerminalAutoActivation;
-    private readonly envVarScript = path.join(EXTENSION_ROOT_DIR, 'python_files', 'pythonrc.py');
     private readonly executeCommandListeners: Set<Disposable> = new Set();
     public get onDidCloseTerminal(): Event<void> {
         return this.terminalClosed.event.bind(this.terminalClosed);
@@ -101,19 +98,31 @@ export class TerminalService implements ITerminalService, Disposable {
         }
 
         if (terminal.shellIntegration) {
+            // TODO: executeCommand would not execute command manually typed inside Python Terminal REPL.
+            // We only run executeCommand when user shift+enter in .py file, and hence run command in terminal on user's behalf.
             const execution = terminal.shellIntegration.executeCommand(commandLine);
-            return await new Promise((resolve) => {
-                const listener = this.terminalManager.onDidEndTerminalShellExecution((e) => {
-                    if (e.execution === execution) {
-                        this.executeCommandListeners.delete(listener);
-                        resolve({ execution, exitCode: e.exitCode });
+            traceVerbose(`Shell Integration is enabled, executeCommand: ${commandLine}`);
+            // exitCode as promise for the case:
+            // In the case where SI is enabled in zsh/pwsh in Windows but not inside Python REPL so Python command won't finish until user exit()
+            // This means OnDidEndTerminalShellExecution would not fire inside REPL launched once REPL is launched for above case.
+
+            return {
+                execution,
+                exitCode: new Promise((resolve) => {
+                    const listener = this.terminalManager.onDidEndTerminalShellExecution((e) => {
+                        if (e.execution === execution) {
+                            this.executeCommandListeners.delete(listener);
+                            resolve(e.exitCode);
+                            traceVerbose(
+                                `onDidEndTerminalShellExecution handler is called: Shell Integration exitCode: ${e.exitCode}`,
+                            );
+                        }
+                    });
+                    if (listener) {
+                        this.executeCommandListeners.add(listener);
                     }
-                });
-                if (listener) {
-                    this.executeCommandListeners.add(listener);
-                }
-                traceVerbose(`Shell Integration is enabled, executeCommand: ${commandLine}`);
-            });
+                }),
+            };
         } else {
             terminal.sendText(commandLine);
             traceVerbose(`Shell Integration is disabled, sendText: ${commandLine}`);
@@ -136,7 +145,6 @@ export class TerminalService implements ITerminalService, Disposable {
         this.terminalShellType = this.terminalHelper.identifyTerminalShell(this.terminal);
         this.terminal = this.terminalManager.createTerminal({
             name: this.options?.title || 'Python',
-            env: { PYTHONSTARTUP: this.envVarScript },
             hideFromUser: this.options?.hideFromUser,
         });
         this.terminalAutoActivator.disableAutoActivation(this.terminal);

src/client/common/terminal/types.ts

@@ -60,7 +60,7 @@ export interface ITerminalService extends IDisposable {
 
 export interface ITerminalExecutedCommand {
     execution: TerminalShellExecution;
-    exitCode: number | undefined;
+    exitCode: Promise<number | undefined>;
 }
 
 export const ITerminalServiceFactory = Symbol('ITerminalServiceFactory');

src/test/common/terminals/helper.unit.test.ts

@@ -96,6 +96,30 @@ suite('Terminal Service helpers', () => {
     teardown(() => shellDetectorIdentifyTerminalShell.restore());
     suite('Misc', () => {
         setup(doSetup);
+        test('Creating terminal should not automatically contain PYTHONSTARTUP', () => {
+            const theTitle = 'Hello';
+            const terminal = 'Terminal Created';
+            when(terminalManager.createTerminal(anything())).thenReturn(terminal as any);
+            const term = helper.createTerminal(theTitle);
+            const args = capture(terminalManager.createTerminal).first()[0];
+            expect(term).to.be.deep.equal(terminal);
+            const terminalOptions = args.env;
+            const safeTerminalOptions = terminalOptions || {};
+            expect(safeTerminalOptions).to.not.have.property('PYTHONSTARTUP');
+        });
+
+        test('Env should be undefined if not explicitly passed in ', () => {
+            const theTitle = 'Hello';
+            const terminal = 'Terminal Created';
+            when(terminalManager.createTerminal(anything())).thenReturn(terminal as any);
+
+            const term = helper.createTerminal(theTitle);
+
+            verify(terminalManager.createTerminal(anything())).once();
+            const args = capture(terminalManager.createTerminal).first()[0];
+            expect(term).to.be.deep.equal(terminal);
+            expect(args.env).to.be.deep.equal(undefined);
+        });
 
         test('Create terminal without a title', () => {
             const terminal = 'Terminal Created';

src/test/smoke/smartSend.smoke.test.ts

@@ -6,81 +6,95 @@ import { EXTENSION_ROOT_DIR_FOR_TESTS, IS_SMOKE_TEST } from '../constants';
 import { closeActiveWindows, initialize, initializeTest } from '../initialize';
 import { openFile, waitForCondition } from '../common';
 
-// TODO: This test is being flaky for windows, need to investigate why only fails on windows
-if (process.platform !== 'win32') {
-    suite('Smoke Test: Run Smart Selection and Advance Cursor', () => {
-        suiteSetup(async function () {
-            if (!IS_SMOKE_TEST) {
-                return this.skip();
-            }
-            await initialize();
-            return undefined;
-        });
+suite('Smoke Test: Run Smart Selection and Advance Cursor', async () => {
+    suiteSetup(async function () {
+        if (!IS_SMOKE_TEST) {
+            return this.skip();
+        }
+        await initialize();
+        return undefined;
+    });
+
+    setup(initializeTest);
+    suiteTeardown(closeActiveWindows);
+    teardown(closeActiveWindows);
 
-        setup(initializeTest);
-        suiteTeardown(closeActiveWindows);
-        teardown(closeActiveWindows);
+    test('Smart Send', async () => {
+        const configuration = vscode.workspace.getConfiguration('python');
+        await configuration.update('REPL.sendToNativeREPL', false, vscode.ConfigurationTarget.Global);
+        await configuration.update('REPL.enableREPLSmartSend', true, vscode.ConfigurationTarget.Global);
+        const configurationTerminal = vscode.workspace.getConfiguration('terminal');
+        // set terminal.integrated.shellIntegration.enabled to false
+        await configurationTerminal.update(
+            'integrated.shellIntegration.enabled',
+            false,
+            vscode.ConfigurationTarget.Global,
+        );
+        configurationTerminal.update(
+            'integrated.defaultProfile.windows',
+            'PowerShell',
+            vscode.ConfigurationTarget.Global,
+        );
+        configurationTerminal.update('integrated.defaultProfile.osx', 'PowerShell', vscode.ConfigurationTarget.Global);
 
-        test('Smart Send', async () => {
-            const file = path.join(
-                EXTENSION_ROOT_DIR_FOR_TESTS,
-                'src',
-                'testMultiRootWkspc',
-                'smokeTests',
-                'create_delete_file.py',
-            );
-            const outputFile = path.join(
-                EXTENSION_ROOT_DIR_FOR_TESTS,
-                'src',
-                'testMultiRootWkspc',
-                'smokeTests',
-                'smart_send_smoke.txt',
-            );
+        const file = path.join(
+            EXTENSION_ROOT_DIR_FOR_TESTS,
+            'src',
+            'testMultiRootWkspc',
+            'smokeTests',
+            'create_delete_file.py',
+        );
+        const outputFile = path.join(
+            EXTENSION_ROOT_DIR_FOR_TESTS,
+            'src',
+            'testMultiRootWkspc',
+            'smokeTests',
+            'smart_send_smoke.txt',
+        );
 
-            await fs.remove(outputFile);
+        await fs.remove(outputFile);
 
-            const textDocument = await openFile(file);
+        const textDocument = await openFile(file);
 
-            if (vscode.window.activeTextEditor) {
-                const myPos = new vscode.Position(0, 0);
-                vscode.window.activeTextEditor!.selections = [new vscode.Selection(myPos, myPos)];
-            }
-            await vscode.commands
-                .executeCommand<void>('python.execSelectionInTerminal', textDocument.uri)
-                .then(undefined, (err) => {
-                    assert.fail(`Something went wrong running the Python file in the terminal: ${err}`);
-                });
+        if (vscode.window.activeTextEditor) {
+            const myPos = new vscode.Position(0, 0);
+            vscode.window.activeTextEditor!.selections = [new vscode.Selection(myPos, myPos)];
+        }
+        await vscode.commands
+            .executeCommand<void>('python.execSelectionInTerminal', textDocument.uri)
+            .then(undefined, (err) => {
+                assert.fail(`Something went wrong running the Python file in the terminal: ${err}`);
+            });
 
-            const checkIfFileHasBeenCreated = () => fs.pathExists(outputFile);
-            await waitForCondition(checkIfFileHasBeenCreated, 10_000, `"${outputFile}" file not created`);
+        const checkIfFileHasBeenCreated = () => fs.pathExists(outputFile);
+        await waitForCondition(checkIfFileHasBeenCreated, 20_000, `"${outputFile}" file not created`);
 
-            await vscode.commands
-                .executeCommand<void>('python.execSelectionInTerminal', textDocument.uri)
-                .then(undefined, (err) => {
-                    assert.fail(`Something went wrong running the Python file in the terminal: ${err}`);
-                });
-            await vscode.commands
-                .executeCommand<void>('python.execSelectionInTerminal', textDocument.uri)
-                .then(undefined, (err) => {
-                    assert.fail(`Something went wrong running the Python file in the terminal: ${err}`);
-                });
+        await vscode.commands
+            .executeCommand<void>('python.execSelectionInTerminal', textDocument.uri)
+            .then(undefined, (err) => {
+                assert.fail(`Something went wrong running the Python file in the terminal: ${err}`);
+            });
+        await vscode.commands
+            .executeCommand<void>('python.execSelectionInTerminal', textDocument.uri)
+            .then(undefined, (err) => {
+                assert.fail(`Something went wrong running the Python file in the terminal: ${err}`);
+            });
 
-            async function wait() {
-                return new Promise<void>((resolve) => {
-                    setTimeout(() => {
-                        resolve();
-                    }, 10000);
-                });
-            }
+        async function wait() {
+            return new Promise<void>((resolve) => {
+                setTimeout(() => {
+                    resolve();
+                }, 10000);
+            });
+        }
 
-            await wait();
+        await wait();
 
-            const deletedFile = !(await fs.pathExists(outputFile));
-            if (deletedFile) {
-                assert.ok(true, `"${outputFile}" file has been deleted`);
-            } else {
-                assert.fail(`"${outputFile}" file still exists`);
-            }
-        });
+        const deletedFile = !(await fs.pathExists(outputFile));
+        if (deletedFile) {
+            assert.ok(true, `"${outputFile}" file has been deleted`);
+        } else {
+            assert.fail(`"${outputFile}" file still exists`);
+        }
     });
-}
+});