From 4d58d74fcd185890f9e5cf1d4b6ac59e53e4ec44 Mon Sep 17 00:00:00 2001 From: Anthony Kim Date: Thu, 29 Jan 2026 14:43:45 -0800 Subject: [PATCH 1/5] Ensure to show terminal on run Python file with command activated terminals --- src/features/terminal/terminalManager.ts | 5 + .../terminal/terminalManager.unit.test.ts | 179 ++++++++++++++++++ 2 files changed, 184 insertions(+) create mode 100644 src/test/features/terminal/terminalManager.unit.test.ts diff --git a/src/features/terminal/terminalManager.ts b/src/features/terminal/terminalManager.ts index 425c851b..6b9a6686 100644 --- a/src/features/terminal/terminalManager.ts +++ b/src/features/terminal/terminalManager.ts @@ -306,6 +306,11 @@ export class TerminalManagerImpl implements TerminalManager { // We add it to skip activation on open to prevent double activation. // We can activate it ourselves since we are creating it. this.skipActivationOnOpen.add(newTerminal); + + // Show terminal before activation so users can see the activation happening, requested script running. + // Necessary for scenarios such as when terminal is awaiting user input, etc. + newTerminal.show(); + await this.autoActivateOnTerminalOpen(newTerminal, environment); } diff --git a/src/test/features/terminal/terminalManager.unit.test.ts b/src/test/features/terminal/terminalManager.unit.test.ts new file mode 100644 index 00000000..89663665 --- /dev/null +++ b/src/test/features/terminal/terminalManager.unit.test.ts @@ -0,0 +1,179 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +import * as assert from 'assert'; +import * as sinon from 'sinon'; +import { EventEmitter, Progress, Terminal, TerminalOptions } from 'vscode'; +import { PythonEnvironment } from '../../../api'; +import * as windowApis from '../../../common/window.apis'; +import * as workspaceApis from '../../../common/workspace.apis'; +import { TerminalActivationInternal } from '../../../features/terminal/terminalActivationState'; +import { TerminalManagerImpl } from '../../../features/terminal/terminalManager'; +import { + ShellEnvsProvider, + ShellStartupScriptProvider, +} from '../../../features/terminal/shells/startupProvider'; +import * as terminalUtils from '../../../features/terminal/utils'; +import * as activationUtils from '../../../features/common/activation'; + +suite('TerminalManager - create()', () => { + let terminalActivation: TerminalActivationInternal; + let mockGetAutoActivationType: sinon.SinonStub; + let terminalManager: TerminalManagerImpl; + + // Tracking variables for show() and activate() call order + let callOrder: string[]; + let mockTerminal: Partial & { show: sinon.SinonStub }; + + const createMockEnvironment = (): PythonEnvironment => + ({ + envId: { id: 'test-env-id', managerId: 'test-manager' }, + environmentPath: { fsPath: '/path/to/python' }, + displayName: 'Test Environment', + execInfo: { + activation: { executable: 'source', args: ['/path/to/activate'] }, + }, + } as unknown as PythonEnvironment); + + setup(() => { + callOrder = []; + + // Create mock terminal with tracking + mockTerminal = { + name: 'Test Terminal', + creationOptions: {} as TerminalOptions, + shellIntegration: undefined, + show: sinon.stub().callsFake(() => { + callOrder.push('show'); + }), + sendText: sinon.stub(), + }; + + // Mock terminal activation using unknown cast for simpler typing + const onDidChangeEmitter = new EventEmitter(); + terminalActivation = { + isActivated: sinon.stub().returns(false), + activate: sinon.stub().callsFake(async () => { + callOrder.push('activate'); + }), + deactivate: sinon.stub().resolves(), + getEnvironment: sinon.stub().returns(undefined), + updateActivationState: sinon.stub(), + onDidChangeTerminalActivationState: onDidChangeEmitter.event, + dispose: sinon.stub(), + } as unknown as TerminalActivationInternal; + + // Stub terminalUtils + mockGetAutoActivationType = sinon.stub(terminalUtils, 'getAutoActivationType'); + sinon.stub(terminalUtils, 'waitForShellIntegration').resolves(false); + + // Stub isActivatableEnvironment to return true + sinon.stub(activationUtils, 'isActivatableEnvironment').returns(true); + + // Stub window APIs + sinon.stub(windowApis, 'createTerminal').returns(mockTerminal as unknown as Terminal); + sinon.stub(windowApis, 'onDidOpenTerminal').returns({ dispose: sinon.stub() }); + sinon.stub(windowApis, 'onDidCloseTerminal').returns({ dispose: sinon.stub() }); + sinon.stub(windowApis, 'onDidChangeWindowState').returns({ dispose: sinon.stub() }); + sinon.stub(windowApis, 'terminals').returns([]); + + // Stub withProgress to execute the callback directly + sinon.stub(windowApis, 'withProgress').callsFake(async (_options, task) => { + const mockProgress: Progress<{ message?: string; increment?: number }> = { report: () => {} }; + const mockCancellationToken = { + isCancellationRequested: false, + onCancellationRequested: () => ({ dispose: () => {} }), + }; + return task(mockProgress, mockCancellationToken as never); + }); + + // Stub workspace APIs + sinon.stub(workspaceApis, 'onDidChangeConfiguration').returns({ dispose: sinon.stub() }); + }); + + teardown(() => { + sinon.restore(); + }); + + function createTerminalManager(): TerminalManagerImpl { + const emptyEnvProviders: ShellEnvsProvider[] = []; + const emptyScriptProviders: ShellStartupScriptProvider[] = []; + return new TerminalManagerImpl( + terminalActivation as TerminalActivationInternal, + emptyEnvProviders, + emptyScriptProviders, + ); + } + + // Regression test for https://github.com/microsoft/vscode-python-environments/issues/640 + // With ACT_TYPE_COMMAND, create() awaits activation which blocks returning the terminal. + // Without showing the terminal early, users wouldn't see it until activation completes (2-5 seconds). + test('ACT_TYPE_COMMAND: shows terminal before awaiting activation to prevent hidden terminal during activation', async () => { + // Mock + mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_COMMAND); + terminalManager = createTerminalManager(); + + // Run + const env = createMockEnvironment(); + await terminalManager.create(env, { cwd: '/workspace' }); + + // Assert - show() must be called before activate() so terminal is visible during activation + assert.ok(callOrder.includes('show'), 'Terminal show() should be called'); + assert.ok(callOrder.includes('activate'), 'Terminal activate() should be called'); + const showIndex = callOrder.indexOf('show'); + const activateIndex = callOrder.indexOf('activate'); + assert.ok( + showIndex < activateIndex, + `show() at index ${showIndex} must precede activate() at index ${activateIndex}`, + ); + }); + + // With ACT_TYPE_SHELL/OFF, create() returns immediately without blocking. + // The caller (runInTerminal) handles showing the terminal, so create() shouldn't call show(). + test('ACT_TYPE_SHELL: does not call show() since create() returns immediately and caller handles visibility', async () => { + // Mock + mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_SHELL); + terminalManager = createTerminalManager(); + + // Run + const env = createMockEnvironment(); + await terminalManager.create(env, { cwd: '/workspace' }); + + // Assert - no blocking activation means caller (runInTerminal) will show terminal + assert.strictEqual(callOrder.includes('show'), false, 'show() deferred to caller'); + assert.strictEqual(callOrder.includes('activate'), false, 'No command activation for shell startup mode'); + }); + + test('ACT_TYPE_OFF: does not call show() since create() returns immediately and caller handles visibility', async () => { + // Mock + mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_OFF); + terminalManager = createTerminalManager(); + + // Run + const env = createMockEnvironment(); + await terminalManager.create(env, { cwd: '/workspace' }); + + // Assert - no activation means caller (runInTerminal) will show terminal + assert.strictEqual(callOrder.includes('show'), false, 'show() deferred to caller'); + assert.strictEqual(callOrder.includes('activate'), false, 'Activation disabled'); + }); + + test('disableActivation option: skips both show() and activation, returns terminal immediately', async () => { + // Mock + mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_COMMAND); + terminalManager = createTerminalManager(); + + // Run + const env = createMockEnvironment(); + const terminal = await terminalManager.create(env, { cwd: '/workspace', disableActivation: true }); + + // Assert - terminal returned without any activation logic + assert.ok(terminal, 'Terminal should be returned'); + assert.strictEqual(callOrder.includes('show'), false, 'No show() when activation skipped'); + assert.strictEqual( + (terminalActivation.activate as sinon.SinonStub).called, + false, + 'No activate() when disableActivation is true', + ); + }); +}); From 58e97c14f4b8e41b1ed08493b732a6023786af76 Mon Sep 17 00:00:00 2001 From: Anthony Kim Date: Thu, 29 Jan 2026 14:46:13 -0800 Subject: [PATCH 2/5] types --- .../terminal/terminalManager.unit.test.ts | 126 +++++++++++------- 1 file changed, 76 insertions(+), 50 deletions(-) diff --git a/src/test/features/terminal/terminalManager.unit.test.ts b/src/test/features/terminal/terminalManager.unit.test.ts index 89663665..acc0fac5 100644 --- a/src/test/features/terminal/terminalManager.unit.test.ts +++ b/src/test/features/terminal/terminalManager.unit.test.ts @@ -3,66 +3,95 @@ import * as assert from 'assert'; import * as sinon from 'sinon'; -import { EventEmitter, Progress, Terminal, TerminalOptions } from 'vscode'; +import { Disposable, Event, EventEmitter, Progress, Terminal, TerminalOptions, Uri } from 'vscode'; import { PythonEnvironment } from '../../../api'; import * as windowApis from '../../../common/window.apis'; import * as workspaceApis from '../../../common/workspace.apis'; -import { TerminalActivationInternal } from '../../../features/terminal/terminalActivationState'; -import { TerminalManagerImpl } from '../../../features/terminal/terminalManager'; +import * as activationUtils from '../../../features/common/activation'; import { ShellEnvsProvider, ShellStartupScriptProvider, } from '../../../features/terminal/shells/startupProvider'; +import { + DidChangeTerminalActivationStateEvent, + TerminalActivationInternal, +} from '../../../features/terminal/terminalActivationState'; +import { TerminalManagerImpl } from '../../../features/terminal/terminalManager'; import * as terminalUtils from '../../../features/terminal/utils'; -import * as activationUtils from '../../../features/common/activation'; + +/** + * Test implementation of TerminalActivationInternal that tracks method calls. + */ +class TestTerminalActivation implements TerminalActivationInternal { + public callOrder: string[] = []; + public activateCalls = 0; + public deactivateCalls = 0; + + private onDidChangeEmitter = new EventEmitter(); + public onDidChangeTerminalActivationState: Event = + this.onDidChangeEmitter.event; + + isActivated(_terminal: Terminal, _environment?: PythonEnvironment): boolean { + return false; + } + + async activate(_terminal: Terminal, _environment: PythonEnvironment): Promise { + this.activateCalls += 1; + this.callOrder.push('activate'); + } + + async deactivate(_terminal: Terminal): Promise { + this.deactivateCalls += 1; + } + + getEnvironment(_terminal: Terminal): PythonEnvironment | undefined { + return undefined; + } + + updateActivationState(_terminal: Terminal, _environment: PythonEnvironment, _activated: boolean): void { + // Not used in these tests + } + + dispose(): void { + this.onDidChangeEmitter.dispose(); + } +} suite('TerminalManager - create()', () => { - let terminalActivation: TerminalActivationInternal; + let terminalActivation: TestTerminalActivation; let mockGetAutoActivationType: sinon.SinonStub; let terminalManager: TerminalManagerImpl; - - // Tracking variables for show() and activate() call order - let callOrder: string[]; let mockTerminal: Partial & { show: sinon.SinonStub }; - const createMockEnvironment = (): PythonEnvironment => - ({ - envId: { id: 'test-env-id', managerId: 'test-manager' }, - environmentPath: { fsPath: '/path/to/python' }, - displayName: 'Test Environment', - execInfo: { - activation: { executable: 'source', args: ['/path/to/activate'] }, - }, - } as unknown as PythonEnvironment); + const createMockEnvironment = (): PythonEnvironment => ({ + envId: { id: 'test-env-id', managerId: 'test-manager' }, + name: 'Test Environment', + displayName: 'Test Environment', + shortDisplayName: 'TestEnv', + displayPath: '/path/to/env', + version: '3.9.0', + environmentPath: Uri.file('/path/to/python'), + sysPrefix: '/path/to/env', + execInfo: { + run: { executable: '/path/to/python' }, + activation: [{ executable: '/path/to/activate' }], + }, + }); setup(() => { - callOrder = []; + terminalActivation = new TestTerminalActivation(); - // Create mock terminal with tracking + // Create mock terminal with tracking - shares callOrder with terminalActivation mockTerminal = { name: 'Test Terminal', creationOptions: {} as TerminalOptions, shellIntegration: undefined, show: sinon.stub().callsFake(() => { - callOrder.push('show'); + terminalActivation.callOrder.push('show'); }), sendText: sinon.stub(), }; - // Mock terminal activation using unknown cast for simpler typing - const onDidChangeEmitter = new EventEmitter(); - terminalActivation = { - isActivated: sinon.stub().returns(false), - activate: sinon.stub().callsFake(async () => { - callOrder.push('activate'); - }), - deactivate: sinon.stub().resolves(), - getEnvironment: sinon.stub().returns(undefined), - updateActivationState: sinon.stub(), - onDidChangeTerminalActivationState: onDidChangeEmitter.event, - dispose: sinon.stub(), - } as unknown as TerminalActivationInternal; - // Stub terminalUtils mockGetAutoActivationType = sinon.stub(terminalUtils, 'getAutoActivationType'); sinon.stub(terminalUtils, 'waitForShellIntegration').resolves(false); @@ -71,10 +100,10 @@ suite('TerminalManager - create()', () => { sinon.stub(activationUtils, 'isActivatableEnvironment').returns(true); // Stub window APIs - sinon.stub(windowApis, 'createTerminal').returns(mockTerminal as unknown as Terminal); - sinon.stub(windowApis, 'onDidOpenTerminal').returns({ dispose: sinon.stub() }); - sinon.stub(windowApis, 'onDidCloseTerminal').returns({ dispose: sinon.stub() }); - sinon.stub(windowApis, 'onDidChangeWindowState').returns({ dispose: sinon.stub() }); + sinon.stub(windowApis, 'createTerminal').returns(mockTerminal as Terminal); + sinon.stub(windowApis, 'onDidOpenTerminal').returns(new Disposable(() => {})); + sinon.stub(windowApis, 'onDidCloseTerminal').returns(new Disposable(() => {})); + sinon.stub(windowApis, 'onDidChangeWindowState').returns(new Disposable(() => {})); sinon.stub(windowApis, 'terminals').returns([]); // Stub withProgress to execute the callback directly @@ -82,27 +111,24 @@ suite('TerminalManager - create()', () => { const mockProgress: Progress<{ message?: string; increment?: number }> = { report: () => {} }; const mockCancellationToken = { isCancellationRequested: false, - onCancellationRequested: () => ({ dispose: () => {} }), + onCancellationRequested: () => new Disposable(() => {}), }; return task(mockProgress, mockCancellationToken as never); }); // Stub workspace APIs - sinon.stub(workspaceApis, 'onDidChangeConfiguration').returns({ dispose: sinon.stub() }); + sinon.stub(workspaceApis, 'onDidChangeConfiguration').returns(new Disposable(() => {})); }); teardown(() => { sinon.restore(); + terminalActivation.dispose(); }); function createTerminalManager(): TerminalManagerImpl { const emptyEnvProviders: ShellEnvsProvider[] = []; const emptyScriptProviders: ShellStartupScriptProvider[] = []; - return new TerminalManagerImpl( - terminalActivation as TerminalActivationInternal, - emptyEnvProviders, - emptyScriptProviders, - ); + return new TerminalManagerImpl(terminalActivation, emptyEnvProviders, emptyScriptProviders); } // Regression test for https://github.com/microsoft/vscode-python-environments/issues/640 @@ -118,6 +144,7 @@ suite('TerminalManager - create()', () => { await terminalManager.create(env, { cwd: '/workspace' }); // Assert - show() must be called before activate() so terminal is visible during activation + const { callOrder } = terminalActivation; assert.ok(callOrder.includes('show'), 'Terminal show() should be called'); assert.ok(callOrder.includes('activate'), 'Terminal activate() should be called'); const showIndex = callOrder.indexOf('show'); @@ -140,6 +167,7 @@ suite('TerminalManager - create()', () => { await terminalManager.create(env, { cwd: '/workspace' }); // Assert - no blocking activation means caller (runInTerminal) will show terminal + const { callOrder } = terminalActivation; assert.strictEqual(callOrder.includes('show'), false, 'show() deferred to caller'); assert.strictEqual(callOrder.includes('activate'), false, 'No command activation for shell startup mode'); }); @@ -154,6 +182,7 @@ suite('TerminalManager - create()', () => { await terminalManager.create(env, { cwd: '/workspace' }); // Assert - no activation means caller (runInTerminal) will show terminal + const { callOrder } = terminalActivation; assert.strictEqual(callOrder.includes('show'), false, 'show() deferred to caller'); assert.strictEqual(callOrder.includes('activate'), false, 'Activation disabled'); }); @@ -168,12 +197,9 @@ suite('TerminalManager - create()', () => { const terminal = await terminalManager.create(env, { cwd: '/workspace', disableActivation: true }); // Assert - terminal returned without any activation logic + const { callOrder } = terminalActivation; assert.ok(terminal, 'Terminal should be returned'); assert.strictEqual(callOrder.includes('show'), false, 'No show() when activation skipped'); - assert.strictEqual( - (terminalActivation.activate as sinon.SinonStub).called, - false, - 'No activate() when disableActivation is true', - ); + assert.strictEqual(terminalActivation.activateCalls, 0, 'No activate() when disableActivation is true'); }); }); From d6dea7bc1f5356de6d790f469f1e968ba5b5a6cb Mon Sep 17 00:00:00 2001 From: Anthony Kim Date: Thu, 29 Jan 2026 14:49:44 -0800 Subject: [PATCH 3/5] Clean up --- src/test/features/terminal/terminalManager.unit.test.ts | 8 -------- 1 file changed, 8 deletions(-) diff --git a/src/test/features/terminal/terminalManager.unit.test.ts b/src/test/features/terminal/terminalManager.unit.test.ts index acc0fac5..f4aaeeb6 100644 --- a/src/test/features/terminal/terminalManager.unit.test.ts +++ b/src/test/features/terminal/terminalManager.unit.test.ts @@ -81,7 +81,6 @@ suite('TerminalManager - create()', () => { setup(() => { terminalActivation = new TestTerminalActivation(); - // Create mock terminal with tracking - shares callOrder with terminalActivation mockTerminal = { name: 'Test Terminal', creationOptions: {} as TerminalOptions, @@ -92,21 +91,15 @@ suite('TerminalManager - create()', () => { sendText: sinon.stub(), }; - // Stub terminalUtils mockGetAutoActivationType = sinon.stub(terminalUtils, 'getAutoActivationType'); sinon.stub(terminalUtils, 'waitForShellIntegration').resolves(false); - - // Stub isActivatableEnvironment to return true sinon.stub(activationUtils, 'isActivatableEnvironment').returns(true); - // Stub window APIs sinon.stub(windowApis, 'createTerminal').returns(mockTerminal as Terminal); sinon.stub(windowApis, 'onDidOpenTerminal').returns(new Disposable(() => {})); sinon.stub(windowApis, 'onDidCloseTerminal').returns(new Disposable(() => {})); sinon.stub(windowApis, 'onDidChangeWindowState').returns(new Disposable(() => {})); sinon.stub(windowApis, 'terminals').returns([]); - - // Stub withProgress to execute the callback directly sinon.stub(windowApis, 'withProgress').callsFake(async (_options, task) => { const mockProgress: Progress<{ message?: string; increment?: number }> = { report: () => {} }; const mockCancellationToken = { @@ -116,7 +109,6 @@ suite('TerminalManager - create()', () => { return task(mockProgress, mockCancellationToken as never); }); - // Stub workspace APIs sinon.stub(workspaceApis, 'onDidChangeConfiguration').returns(new Disposable(() => {})); }); From 1f6652ed1adb502fea055057541b9c1874611564 Mon Sep 17 00:00:00 2001 From: Anthony Kim Date: Thu, 29 Jan 2026 14:51:22 -0800 Subject: [PATCH 4/5] clean up --- .../terminal/terminalManager.unit.test.ts | 20 ++++--------------- 1 file changed, 4 insertions(+), 16 deletions(-) diff --git a/src/test/features/terminal/terminalManager.unit.test.ts b/src/test/features/terminal/terminalManager.unit.test.ts index f4aaeeb6..c11ba206 100644 --- a/src/test/features/terminal/terminalManager.unit.test.ts +++ b/src/test/features/terminal/terminalManager.unit.test.ts @@ -127,15 +127,12 @@ suite('TerminalManager - create()', () => { // With ACT_TYPE_COMMAND, create() awaits activation which blocks returning the terminal. // Without showing the terminal early, users wouldn't see it until activation completes (2-5 seconds). test('ACT_TYPE_COMMAND: shows terminal before awaiting activation to prevent hidden terminal during activation', async () => { - // Mock mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_COMMAND); terminalManager = createTerminalManager(); - - // Run const env = createMockEnvironment(); + await terminalManager.create(env, { cwd: '/workspace' }); - // Assert - show() must be called before activate() so terminal is visible during activation const { callOrder } = terminalActivation; assert.ok(callOrder.includes('show'), 'Terminal show() should be called'); assert.ok(callOrder.includes('activate'), 'Terminal activate() should be called'); @@ -150,45 +147,36 @@ suite('TerminalManager - create()', () => { // With ACT_TYPE_SHELL/OFF, create() returns immediately without blocking. // The caller (runInTerminal) handles showing the terminal, so create() shouldn't call show(). test('ACT_TYPE_SHELL: does not call show() since create() returns immediately and caller handles visibility', async () => { - // Mock mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_SHELL); terminalManager = createTerminalManager(); - - // Run const env = createMockEnvironment(); + await terminalManager.create(env, { cwd: '/workspace' }); - // Assert - no blocking activation means caller (runInTerminal) will show terminal const { callOrder } = terminalActivation; assert.strictEqual(callOrder.includes('show'), false, 'show() deferred to caller'); assert.strictEqual(callOrder.includes('activate'), false, 'No command activation for shell startup mode'); }); test('ACT_TYPE_OFF: does not call show() since create() returns immediately and caller handles visibility', async () => { - // Mock mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_OFF); terminalManager = createTerminalManager(); - - // Run const env = createMockEnvironment(); + await terminalManager.create(env, { cwd: '/workspace' }); - // Assert - no activation means caller (runInTerminal) will show terminal const { callOrder } = terminalActivation; assert.strictEqual(callOrder.includes('show'), false, 'show() deferred to caller'); assert.strictEqual(callOrder.includes('activate'), false, 'Activation disabled'); }); test('disableActivation option: skips both show() and activation, returns terminal immediately', async () => { - // Mock mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_COMMAND); terminalManager = createTerminalManager(); - - // Run const env = createMockEnvironment(); + const terminal = await terminalManager.create(env, { cwd: '/workspace', disableActivation: true }); - // Assert - terminal returned without any activation logic const { callOrder } = terminalActivation; assert.ok(terminal, 'Terminal should be returned'); assert.strictEqual(callOrder.includes('show'), false, 'No show() when activation skipped'); From ead8a7eff0d53884ea963f86d8f661f5f190180e Mon Sep 17 00:00:00 2001 From: Anthony Kim Date: Thu, 29 Jan 2026 14:54:09 -0800 Subject: [PATCH 5/5] shel ltype --- src/test/features/terminal/terminalManager.unit.test.ts | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/test/features/terminal/terminalManager.unit.test.ts b/src/test/features/terminal/terminalManager.unit.test.ts index c11ba206..f053765f 100644 --- a/src/test/features/terminal/terminalManager.unit.test.ts +++ b/src/test/features/terminal/terminalManager.unit.test.ts @@ -8,6 +8,7 @@ import { PythonEnvironment } from '../../../api'; import * as windowApis from '../../../common/window.apis'; import * as workspaceApis from '../../../common/workspace.apis'; import * as activationUtils from '../../../features/common/activation'; +import * as shellDetector from '../../../features/common/shellDetector'; import { ShellEnvsProvider, ShellStartupScriptProvider, @@ -94,6 +95,7 @@ suite('TerminalManager - create()', () => { mockGetAutoActivationType = sinon.stub(terminalUtils, 'getAutoActivationType'); sinon.stub(terminalUtils, 'waitForShellIntegration').resolves(false); sinon.stub(activationUtils, 'isActivatableEnvironment').returns(true); + sinon.stub(shellDetector, 'identifyTerminalShell').returns('bash'); sinon.stub(windowApis, 'createTerminal').returns(mockTerminal as Terminal); sinon.stub(windowApis, 'onDidOpenTerminal').returns(new Disposable(() => {}));