terminalManager.unit.test.ts

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

import * as assert from 'assert';
import * as fsapi from 'fs-extra';
import * as os from 'os';
import * as path from 'path';
import * as sinon from 'sinon';
import {
    Disposable,
    Event,
    EventEmitter,
    Progress,
    Terminal,
    TerminalOptions,
    Uri,
    WorkspaceConfiguration,
} from 'vscode';
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 * as shellUtils from '../../../features/terminal/shells/common/shellUtils';
import {
    ShellEnvsProvider,
    ShellScriptEditState,
    ShellSetupState,
    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';

/**
 * 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<DidChangeTerminalActivationStateEvent>();
    public onDidChangeTerminalActivationState: Event<DidChangeTerminalActivationStateEvent> =
        this.onDidChangeEmitter.event;

    isActivated(_terminal: Terminal, _environment?: PythonEnvironment): boolean {
        return false;
    }

    async activate(_terminal: Terminal, _environment: PythonEnvironment): Promise<void> {
        this.activateCalls += 1;
        this.callOrder.push('activate');
    }

    async deactivate(_terminal: Terminal): Promise<void> {
        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: TestTerminalActivation;
    let mockGetAutoActivationType: sinon.SinonStub;
    let terminalManager: TerminalManagerImpl;
    let mockTerminal: Partial<Terminal> & { show: sinon.SinonStub };

    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(() => {
        terminalActivation = new TestTerminalActivation();

        mockTerminal = {
            name: 'Test Terminal',
            creationOptions: {} as TerminalOptions,
            shellIntegration: undefined,
            show: sinon.stub().callsFake(() => {
                terminalActivation.callOrder.push('show');
            }),
            sendText: sinon.stub(),
        };

        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(() => {}));
        sinon.stub(windowApis, 'onDidCloseTerminal').returns(new Disposable(() => {}));
        sinon.stub(windowApis, 'onDidChangeWindowState').returns(new Disposable(() => {}));
        sinon.stub(windowApis, 'terminals').returns([]);
        sinon.stub(windowApis, 'withProgress').callsFake(async (_options, task) => {
            const mockProgress: Progress<{ message?: string; increment?: number }> = { report: () => {} };
            const mockCancellationToken = {
                isCancellationRequested: false,
                onCancellationRequested: () => new Disposable(() => {}),
            };
            return task(mockProgress, mockCancellationToken as never);
        });

        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, 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 () => {
        mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_COMMAND);
        terminalManager = createTerminalManager();
        const env = createMockEnvironment();

        await terminalManager.create(env, { cwd: '/workspace' });

        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');
        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 () => {
        mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_SHELL);
        terminalManager = createTerminalManager();
        const env = createMockEnvironment();

        await terminalManager.create(env, { cwd: '/workspace' });

        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 () => {
        mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_OFF);
        terminalManager = createTerminalManager();
        const env = createMockEnvironment();

        await terminalManager.create(env, { cwd: '/workspace' });

        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 () => {
        mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_COMMAND);
        terminalManager = createTerminalManager();
        const env = createMockEnvironment();

        const terminal = await terminalManager.create(env, { cwd: '/workspace', disableActivation: true });

        const { callOrder } = terminalActivation;
        assert.ok(terminal, 'Terminal should be returned');
        assert.strictEqual(callOrder.includes('show'), false, 'No show() when activation skipped');
        assert.strictEqual(terminalActivation.activateCalls, 0, 'No activate() when disableActivation is true');
    });
});

suite('TerminalManager - terminal naming', () => {
    let terminalActivation: TestTerminalActivation;
    let mockGetAutoActivationType: sinon.SinonStub;
    let terminalManager: TerminalManagerImpl;
    let mockTerminal: Partial<Terminal> & { show: sinon.SinonStub };
    let createTerminalStub: sinon.SinonStub;

    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(() => {
        terminalActivation = new TestTerminalActivation();

        mockTerminal = {
            name: 'Test Terminal',
            creationOptions: {} as TerminalOptions,
            shellIntegration: undefined,
            show: sinon.stub(),
            sendText: sinon.stub(),
        };

        mockGetAutoActivationType = sinon.stub(terminalUtils, 'getAutoActivationType');
        sinon.stub(terminalUtils, 'waitForShellIntegration').resolves(false);
        sinon.stub(activationUtils, 'isActivatableEnvironment').returns(true);
        sinon.stub(shellDetector, 'identifyTerminalShell').returns('bash');

        createTerminalStub = 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([]);
        sinon.stub(windowApis, 'withProgress').callsFake(async (_options, task) => {
            const mockProgress: Progress<{ message?: string; increment?: number }> = { report: () => {} };
            const mockCancellationToken = {
                isCancellationRequested: false,
                onCancellationRequested: () => new Disposable(() => {}),
            };
            return task(mockProgress, mockCancellationToken as never);
        });

        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, emptyEnvProviders, emptyScriptProviders);
    }

    test('getDedicatedTerminal sets Python file name as terminal name', async () => {
        mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_OFF);
        terminalManager = createTerminalManager();
        const env = createMockEnvironment();

        const optionsList: TerminalOptions[] = [];
        createTerminalStub.callsFake((options) => {
            optionsList.push(options);
            return mockTerminal as Terminal;
        });

        const tempRoot = await fsapi.mkdtemp(path.join(os.tmpdir(), 'py-envs-'));
        const projectPath = path.join(tempRoot, 'project');
        const filePath = path.join(projectPath, 'main.py');
        await fsapi.ensureDir(projectPath);
        await fsapi.writeFile(filePath, 'print("hello")');
        const projectUri = Uri.file(projectPath);
        const fileUri = Uri.file(filePath);

        const config = { get: sinon.stub().returns(false) } as unknown as WorkspaceConfiguration;
        sinon.stub(workspaceApis, 'getConfiguration').returns(config);

        try {
            await terminalManager.getDedicatedTerminal(fileUri, projectUri, env);

            assert.strictEqual(
                optionsList[0]?.name,
                'Python: main',
                'Dedicated terminal should use the file name in the title',
            );
        } finally {
            await fsapi.remove(tempRoot);
        }
    });

    test('getProjectTerminal sets Python as terminal name', async () => {
        mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_OFF);
        terminalManager = createTerminalManager();
        const env = createMockEnvironment();

        const optionsList: TerminalOptions[] = [];
        createTerminalStub.callsFake((options) => {
            optionsList.push(options);
            return mockTerminal as Terminal;
        });

        const tempRoot = await fsapi.mkdtemp(path.join(os.tmpdir(), 'py-envs-'));
        const projectPath = path.join(tempRoot, 'project');
        await fsapi.ensureDir(projectPath);
        const projectUri = Uri.file(projectPath);

        try {
            await terminalManager.getProjectTerminal(projectUri, env);

            assert.strictEqual(optionsList[0]?.name, 'Python', 'Project terminal should use the Python title');
        } finally {
            await fsapi.remove(tempRoot);
        }
    });

    // Regression test for https://github.com/microsoft/vscode-python-environments/issues/1230
    test('getDedicatedTerminal with string key uses string as terminal name', async () => {
        mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_OFF);
        terminalManager = createTerminalManager();
        const env = createMockEnvironment();

        const optionsList: TerminalOptions[] = [];
        createTerminalStub.callsFake((options) => {
            optionsList.push(options);
            return mockTerminal as Terminal;
        });

        const tempRoot = await fsapi.mkdtemp(path.join(os.tmpdir(), 'py-envs-'));
        const projectPath = path.join(tempRoot, 'project');
        await fsapi.ensureDir(projectPath);
        const projectUri = Uri.file(projectPath);

        const config = { get: sinon.stub().returns(false) } as unknown as WorkspaceConfiguration;
        sinon.stub(workspaceApis, 'getConfiguration').returns(config);

        try {
            await terminalManager.getDedicatedTerminal('my-terminal-key', projectUri, env);

            assert.strictEqual(
                optionsList[0]?.name,
                'Python: my-terminal-key',
                'Dedicated terminal with string key should use the string in the title',
            );
            assert.strictEqual(
                Uri.file(optionsList[0]?.cwd as string).fsPath,
                Uri.file(projectPath).fsPath,
                'Dedicated terminal with string key should use project directory as cwd',
            );
        } finally {
            await fsapi.remove(tempRoot);
        }
    });

    // Regression test for https://github.com/microsoft/vscode-python-environments/issues/1230
    test('getDedicatedTerminal with string key reuses terminal for same key', async () => {
        mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_OFF);
        terminalManager = createTerminalManager();
        const env = createMockEnvironment();

        let createCount = 0;
        createTerminalStub.callsFake((options) => {
            createCount++;
            return { ...mockTerminal, name: options.name } as Terminal;
        });

        const tempRoot = await fsapi.mkdtemp(path.join(os.tmpdir(), 'py-envs-'));
        const projectPath = path.join(tempRoot, 'project');
        await fsapi.ensureDir(projectPath);
        const projectUri = Uri.file(projectPath);

        const config = { get: sinon.stub().returns(false) } as unknown as WorkspaceConfiguration;
        sinon.stub(workspaceApis, 'getConfiguration').returns(config);

        try {
            const terminal1 = await terminalManager.getDedicatedTerminal('my-key', projectUri, env);
            const terminal2 = await terminalManager.getDedicatedTerminal('my-key', projectUri, env);

            assert.strictEqual(terminal1, terminal2, 'Same string key should return the same terminal');
            assert.strictEqual(createCount, 1, 'Terminal should be created only once');
        } finally {
            await fsapi.remove(tempRoot);
        }
    });

    // Regression test for https://github.com/microsoft/vscode-python-environments/issues/1230
    test('getDedicatedTerminal with string key uses different terminals for different keys', async () => {
        mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_OFF);
        terminalManager = createTerminalManager();
        const env = createMockEnvironment();

        let createCount = 0;
        createTerminalStub.callsFake((options) => {
            createCount++;
            return { ...mockTerminal, name: options.name, id: createCount } as unknown as Terminal;
        });

        const tempRoot = await fsapi.mkdtemp(path.join(os.tmpdir(), 'py-envs-'));
        const projectPath = path.join(tempRoot, 'project');
        await fsapi.ensureDir(projectPath);
        const projectUri = Uri.file(projectPath);

        const config = { get: sinon.stub().returns(false) } as unknown as WorkspaceConfiguration;
        sinon.stub(workspaceApis, 'getConfiguration').returns(config);

        try {
            const terminal1 = await terminalManager.getDedicatedTerminal('key-1', projectUri, env);
            const terminal2 = await terminalManager.getDedicatedTerminal('key-2', projectUri, env);

            assert.notStrictEqual(terminal1, terminal2, 'Different string keys should return different terminals');
            assert.strictEqual(createCount, 2, 'Two terminals should be created');
        } finally {
            await fsapi.remove(tempRoot);
        }
    });
});

suite('TerminalManager - initialize() with activateEnvInCurrentTerminal', () => {
    let terminalActivation: TestTerminalActivation;
    let terminalManager: TerminalManagerImpl;
    let mockGetAutoActivationType: sinon.SinonStub;
    let mockShouldActivateInCurrentTerminal: sinon.SinonStub;
    let mockTerminals: sinon.SinonStub;
    let mockGetEnvironmentForTerminal: sinon.SinonStub;

    const createMockTerminal = (name: string): Terminal =>
        ({
            name,
            creationOptions: {} as TerminalOptions,
            shellIntegration: undefined,
            show: sinon.stub(),
            sendText: sinon.stub(),
        }) as unknown as Terminal;

    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(() => {
        terminalActivation = new TestTerminalActivation();

        mockGetAutoActivationType = sinon.stub(terminalUtils, 'getAutoActivationType');
        mockShouldActivateInCurrentTerminal = sinon.stub(terminalUtils, 'shouldActivateInCurrentTerminal');
        mockGetEnvironmentForTerminal = sinon.stub(terminalUtils, 'getEnvironmentForTerminal');
        sinon.stub(terminalUtils, 'waitForShellIntegration').resolves(false);
        sinon.stub(activationUtils, 'isActivatableEnvironment').returns(true);
        sinon.stub(shellDetector, 'identifyTerminalShell').returns('bash');

        sinon.stub(windowApis, 'createTerminal').callsFake(() => createMockTerminal('new'));
        sinon.stub(windowApis, 'onDidOpenTerminal').returns(new Disposable(() => {}));
        sinon.stub(windowApis, 'onDidCloseTerminal').returns(new Disposable(() => {}));
        sinon.stub(windowApis, 'onDidChangeWindowState').returns(new Disposable(() => {}));
        sinon.stub(windowApis, 'activeTerminal').returns(undefined);

        mockTerminals = sinon.stub(windowApis, 'terminals');

        sinon.stub(windowApis, 'withProgress').callsFake(async (_options, task) => {
            const mockProgress = { report: () => {} };
            const mockToken = {
                isCancellationRequested: false,
                onCancellationRequested: () => new Disposable(() => {}),
            };
            return task(mockProgress as never, mockToken as never);
        });
        sinon.stub(workspaceApis, 'onDidChangeConfiguration').returns(new Disposable(() => {}));
    });

    teardown(() => {
        sinon.restore();
        terminalActivation.dispose();
    });

    function createTerminalManager(): TerminalManagerImpl {
        return new TerminalManagerImpl(terminalActivation, [], []);
    }

    test('initialize activates all pre-existing terminals when shouldActivateInCurrentTerminal returns true', async () => {
        const terminal1 = createMockTerminal('terminal1');
        const terminal2 = createMockTerminal('terminal2');
        const env = createMockEnvironment();

        mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_COMMAND);
        mockShouldActivateInCurrentTerminal.returns(true);
        mockTerminals.returns([terminal1, terminal2]);
        mockGetEnvironmentForTerminal.resolves(env);

        terminalManager = createTerminalManager();
        await terminalManager.initialize({} as never);

        assert.strictEqual(
            terminalActivation.activateCalls,
            2,
            'Should activate all pre-existing terminals when activateEnvInCurrentTerminal is true/default',
        );
    });

    test('initialize skips all pre-existing terminals when shouldActivateInCurrentTerminal returns false', async () => {
        const terminal1 = createMockTerminal('terminal1');
        const terminal2 = createMockTerminal('terminal2');
        const env = createMockEnvironment();

        mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_COMMAND);
        mockShouldActivateInCurrentTerminal.returns(false);
        mockTerminals.returns([terminal1, terminal2]);
        mockGetEnvironmentForTerminal.resolves(env);

        terminalManager = createTerminalManager();
        await terminalManager.initialize({} as never);

        assert.strictEqual(
            terminalActivation.activateCalls,
            0,
            'Should skip all pre-existing terminals when activateEnvInCurrentTerminal is explicitly false',
        );
    });

    test('initialize proceeds normally when shouldActivateInCurrentTerminal returns false but no pre-existing terminals', async () => {
        mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_COMMAND);
        mockShouldActivateInCurrentTerminal.returns(false);
        mockTerminals.returns([]);

        terminalManager = createTerminalManager();
        await terminalManager.initialize({} as never);

        assert.strictEqual(
            terminalActivation.activateCalls,
            0,
            'Should have no activations when there are no terminals',
        );
    });

    test('initialize skips shell fallback activation for pre-existing terminals when shouldActivateInCurrentTerminal returns false (ACT_TYPE_SHELL)', async () => {
        const terminal1 = createMockTerminal('terminal1');
        const env = createMockEnvironment();

        // Mock a shell startup provider that reports NotSetup so shellSetup gets set to false,
        // which would normally trigger the command fallback activation.
        const mockShellProvider: ShellStartupScriptProvider = {
            name: 'bash-test',
            shellType: 'bash',
            isSetup: sinon.stub().resolves(ShellSetupState.NotSetup),
            setupScripts: sinon.stub().resolves(ShellScriptEditState.NotEdited),
            teardownScripts: sinon.stub().resolves(ShellScriptEditState.NotEdited),
            clearCache: sinon.stub().resolves(),
        };
        sinon.stub(shellUtils, 'getShellIntegrationEnabledCache').resolves(false);
        sinon.stub(shellUtils, 'shouldUseProfileActivation').returns(false);

        mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_SHELL);
        mockShouldActivateInCurrentTerminal.returns(false);
        mockTerminals.returns([terminal1]);
        mockGetEnvironmentForTerminal.resolves(env);

        terminalManager = new TerminalManagerImpl(terminalActivation, [], [mockShellProvider]);
        await terminalManager.initialize({} as never);

        assert.strictEqual(
            terminalActivation.activateCalls,
            0,
            'Should skip shell fallback activation for pre-existing terminals when activateEnvInCurrentTerminal is explicitly false',
        );
    });

    test('initialize activates via shell command fallback for pre-existing terminals when shouldActivateInCurrentTerminal returns true (ACT_TYPE_SHELL)', async () => {
        const terminal1 = createMockTerminal('terminal1');
        const env = createMockEnvironment();

        // Mock a shell startup provider that reports NotSetup so shellSetup gets set to false,
        // triggering the command fallback activation.
        const mockShellProvider: ShellStartupScriptProvider = {
            name: 'bash-test',
            shellType: 'bash',
            isSetup: sinon.stub().resolves(ShellSetupState.NotSetup),
            setupScripts: sinon.stub().resolves(ShellScriptEditState.NotEdited),
            teardownScripts: sinon.stub().resolves(ShellScriptEditState.NotEdited),
            clearCache: sinon.stub().resolves(),
        };
        sinon.stub(shellUtils, 'getShellIntegrationEnabledCache').resolves(false);
        sinon.stub(shellUtils, 'shouldUseProfileActivation').returns(false);

        mockGetAutoActivationType.returns(terminalUtils.ACT_TYPE_SHELL);
        mockShouldActivateInCurrentTerminal.returns(true);
        mockTerminals.returns([terminal1]);
        mockGetEnvironmentForTerminal.resolves(env);

        terminalManager = new TerminalManagerImpl(terminalActivation, [], [mockShellProvider]);
        await terminalManager.initialize({} as never);

        assert.strictEqual(
            terminalActivation.activateCalls,
            1,
            'Should activate via command fallback when shell setup reports not setup',
        );
    });
});