Implement multiroot support for createTerminal command

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

Author: Copilot

src/features/envCommands.ts

@@ -514,23 +514,17 @@ export async function createTerminalCommand(
     api: PythonEnvironmentApi,
     tm: TerminalManager,
 ): Promise<Terminal | undefined> {
-    if (context === undefined) {
-        const pw = await pickProject(api.getPythonProjects());
+    if (context === undefined || context instanceof Uri) {
+        // For undefined context or Uri context, check for multiroot and prompt if needed
+        const projects = api.getPythonProjects();
+        const pw = await pickProject(projects);
         if (pw) {
             const env = await api.getEnvironment(pw.uri);
             const cwd = await findParentIfFile(pw.uri.fsPath);
             if (env) {
                 return await tm.create(env, { cwd });
             }
         }
-    } else if (context instanceof Uri) {
-        const uri = context as Uri;
-        const env = await api.getEnvironment(uri);
-        const pw = api.getPythonProject(uri);
-        if (env && pw) {
-            const cwd = await findParentIfFile(pw.uri.fsPath);
-            return await tm.create(env, { cwd });
-        }
     } else if (context instanceof ProjectItem) {
         const view = context as ProjectItem;
         const env = await api.getEnvironment(view.project.uri);

src/test/features/envCommands.unit.test.ts

@@ -4,9 +4,11 @@ import * as sinon from 'sinon';
 import { EnvironmentManagers, InternalEnvironmentManager, PythonProjectManager } from '../../internal.api';
 import * as projectApi from '../../common/pickers/projects';
 import * as managerApi from '../../common/pickers/managers';
-import { PythonEnvironment, PythonProject } from '../../api';
-import { createAnyEnvironmentCommand } from '../../features/envCommands';
-import { Uri } from 'vscode';
+import { PythonEnvironment, PythonEnvironmentApi, PythonProject } from '../../api';
+import { createAnyEnvironmentCommand, createTerminalCommand } from '../../features/envCommands';
+import { Terminal, Uri } from 'vscode';
+import { TerminalManager } from '../../features/terminal/terminalManager';
+import * as fs from 'fs-extra';
 
 suite('Create Any Environment Command Tests', () => {
     let em: typeMoq.IMock<EnvironmentManagers>;
@@ -175,3 +177,128 @@ suite('Create Any Environment Command Tests', () => {
         em.verifyAll();
     });
 });
+
+suite('Create Terminal Command Tests', () => {
+    let api: typeMoq.IMock<PythonEnvironmentApi>;
+    let tm: typeMoq.IMock<TerminalManager>;
+    let env: typeMoq.IMock<PythonEnvironment>;
+    let terminal: typeMoq.IMock<Terminal>;
+    let pickProjectStub: sinon.SinonStub;
+    let fsStatStub: sinon.SinonStub;
+    let project1: PythonProject = {
+        uri: Uri.file('/workspace/folder1'),
+        name: 'folder1',
+    };
+    let project2: PythonProject = {
+        uri: Uri.file('/workspace/folder2'),
+        name: 'folder2',
+    };
+
+    setup(() => {
+        env = typeMoq.Mock.ofType<PythonEnvironment>();
+        env.setup((e) => e.envId).returns(() => ({ id: 'env1', managerId: 'test' }));
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        env.setup((e: any) => e.then).returns(() => undefined);
+
+        terminal = typeMoq.Mock.ofType<Terminal>();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        terminal.setup((t: any) => t.then).returns(() => undefined);
+
+        api = typeMoq.Mock.ofType<PythonEnvironmentApi>();
+        tm = typeMoq.Mock.ofType<TerminalManager>();
+
+        pickProjectStub = sinon.stub(projectApi, 'pickProject');
+        // Stub fs.stat to return a directory stats object to avoid file system access
+        fsStatStub = sinon.stub(fs, 'stat');
+        fsStatStub.resolves({ isFile: () => false, isDirectory: () => true } as any);
+    });
+
+    teardown(() => {
+        sinon.restore();
+    });
+
+    test('Single project: should create terminal without prompting', async () => {
+        // Setup: single project
+        api.setup((a) => a.getPythonProjects()).returns(() => [project1]);
+        api.setup((a) => a.getEnvironment(project1.uri)).returns(() => Promise.resolve(env.object));
+        tm.setup((t) => t.create(env.object, typeMoq.It.isAny())).returns(() => Promise.resolve(terminal.object));
+
+        // pickProject should return the single project without prompting
+        pickProjectStub.resolves(project1);
+
+        const result = await createTerminalCommand(undefined, api.object, tm.object);
+
+        assert.strictEqual(result, terminal.object, 'Expected terminal to be created');
+        assert.strictEqual(pickProjectStub.callCount, 1, 'pickProject should be called once');
+    });
+
+    test('Multiple projects: should prompt user to select project', async () => {
+        // Setup: multiple projects
+        api.setup((a) => a.getPythonProjects()).returns(() => [project1, project2]);
+        api.setup((a) => a.getEnvironment(project2.uri)).returns(() => Promise.resolve(env.object));
+        tm.setup((t) => t.create(env.object, typeMoq.It.isAny())).returns(() => Promise.resolve(terminal.object));
+
+        // User selects project2
+        pickProjectStub.resolves(project2);
+
+        const result = await createTerminalCommand(undefined, api.object, tm.object);
+
+        assert.strictEqual(result, terminal.object, 'Expected terminal to be created');
+        assert.strictEqual(pickProjectStub.callCount, 1, 'pickProject should be called once');
+        // Verify pickProject was called with both projects
+        assert.deepStrictEqual(
+            pickProjectStub.firstCall.args[0],
+            [project1, project2],
+            'pickProject should be called with all projects',
+        );
+    });
+
+    test('Uri context with single project: should create terminal without prompting', async () => {
+        // Setup: single project
+        api.setup((a) => a.getPythonProjects()).returns(() => [project1]);
+        api.setup((a) => a.getEnvironment(project1.uri)).returns(() => Promise.resolve(env.object));
+        tm.setup((t) => t.create(env.object, typeMoq.It.isAny())).returns(() => Promise.resolve(terminal.object));
+
+        // pickProject should return the single project without prompting
+        pickProjectStub.resolves(project1);
+
+        const result = await createTerminalCommand(project1.uri, api.object, tm.object);
+
+        assert.strictEqual(result, terminal.object, 'Expected terminal to be created');
+        assert.strictEqual(pickProjectStub.callCount, 1, 'pickProject should be called once');
+    });
+
+    test('Uri context with multiple projects: should prompt user to select project', async () => {
+        // Setup: multiple projects, context is project1.uri but user should still be prompted
+        api.setup((a) => a.getPythonProjects()).returns(() => [project1, project2]);
+        api.setup((a) => a.getEnvironment(project2.uri)).returns(() => Promise.resolve(env.object));
+        tm.setup((t) => t.create(env.object, typeMoq.It.isAny())).returns(() => Promise.resolve(terminal.object));
+
+        // User selects project2 (different from context)
+        pickProjectStub.resolves(project2);
+
+        const result = await createTerminalCommand(project1.uri, api.object, tm.object);
+
+        assert.strictEqual(result, terminal.object, 'Expected terminal to be created');
+        assert.strictEqual(pickProjectStub.callCount, 1, 'pickProject should be called once');
+        // Verify pickProject was called with all projects, not just the context
+        assert.deepStrictEqual(
+            pickProjectStub.firstCall.args[0],
+            [project1, project2],
+            'pickProject should be called with all projects',
+        );
+    });
+
+    test('User cancels project selection: should not create terminal', async () => {
+        // Setup: multiple projects
+        api.setup((a) => a.getPythonProjects()).returns(() => [project1, project2]);
+
+        // User cancels selection
+        pickProjectStub.resolves(undefined);
+
+        const result = await createTerminalCommand(undefined, api.object, tm.object);
+
+        assert.strictEqual(result, undefined, 'Expected no terminal to be created when user cancels');
+        assert.strictEqual(pickProjectStub.callCount, 1, 'pickProject should be called once');
+    });
+});