Add context-aware test commands to extension

Author: govert

README.md

@@ -130,6 +130,7 @@ Once installed, the extension automatically activates when you open a \`.vb\` fi
 If you have multiple solutions, use the Command Palette action **"VB.NET: Select Workspace Solution"** to choose the active \`.sln/.slnf/.slnx\`.
 For diagnostics, use **"VB.NET: Show Logs"** and **"VB.NET: Toggle LSP Trace"**.
 If assets are missing, run **"VB.NET: Restore Workspace"** or **"VB.NET: Restore Project"**.
+To run tests scoped to the active file, solution, or project, use **"VB.NET: Run Tests"** (or **"VB.NET: Debug Tests (Preview)"**).
 To force a reanalysis without restarting VS Code, use **"VB.NET: Reload Workspace"**.
 For attaching to a running .NET process, use **"VB.NET: Attach Debugger to Process"**.
 

docs/configuration.md

@@ -3,7 +3,7 @@
 **`VB.NET` Language Support - User Configuration**
 
 Version: 1.1
-Last Updated: 2026-01-20
+Last Updated: 2026-01-22
 
 ## Table of Contents
 
@@ -30,6 +30,8 @@ Last Updated: 2026-01-20
 - **`VB.NET: Toggle LSP Trace`** — toggles `vbnet.trace.server` between `off` and `verbose`.
 - **`VB.NET: Restore Workspace`** — runs `dotnet restore` using the selected solution (or workspace root).
 - **`VB.NET: Restore Project`** — picks a `.vbproj` file and runs `dotnet restore` for it.
+- **`VB.NET: Run Tests`** — runs `dotnet test` using the active `.vb` context, selected solution, or project.
+- **`VB.NET: Debug Tests (Preview)`** — runs `dotnet test` and notes that debug attach is not yet implemented.
 - **`VB.NET: Reload Workspace`** — requests a workspace reload without restarting the extension.
 - **`VB.NET: Attach Debugger to Process`** — picks a running process and starts an attach session.
 
@@ -740,7 +742,7 @@ If configuration issues persist:
 
 ---
 
-**Last Updated**: 2026-01-18
+**Last Updated**: 2026-01-22
 
 **Maintained by**: `VB.NET` Language Support Contributors
 

src/extension/package.json

@@ -242,6 +242,16 @@
         "title": "Restore VB.NET Project",
         "category": "VB.NET"
       },
+      {
+        "command": "vbnet.runTestsInContext",
+        "title": "Run VB.NET Tests",
+        "category": "VB.NET"
+      },
+      {
+        "command": "vbnet.debugTestsInContext",
+        "title": "Debug VB.NET Tests (Preview)",
+        "category": "VB.NET"
+      },
       {
         "command": "vbnet.reloadWorkspace",
         "title": "Reload VB.NET Workspace",

src/extension/src/extension.ts

@@ -271,6 +271,31 @@ function registerCommands(context: vscode.ExtensionContext): void {
             }
         })
     );
+
+    context.subscriptions.push(
+        vscode.commands.registerCommand('vbnet.runTestsInContext', async () => {
+            try {
+                await runTestsInContext();
+            } catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                outputChannel?.appendLine(`Failed to run tests: ${message}`);
+                vscode.window.showErrorMessage(`Failed to run tests: ${message}`);
+            }
+        })
+    );
+
+    context.subscriptions.push(
+        vscode.commands.registerCommand('vbnet.debugTestsInContext', async () => {
+            try {
+                vscode.window.showInformationMessage('Debug test support is in preview; running dotnet test for now.');
+                await runTestsInContext(true);
+            } catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                outputChannel?.appendLine(`Failed to debug tests: ${message}`);
+                vscode.window.showErrorMessage(`Failed to debug tests: ${message}`);
+            }
+        })
+    );
 }
 
 interface SolutionPickItem extends vscode.QuickPickItem {
@@ -292,6 +317,10 @@ interface ProcessPickItem extends vscode.QuickPickItem {
     pid: number;
 }
 
+interface TestPickItem extends vscode.QuickPickItem {
+    targetPath?: string;
+}
+
 async function selectWorkspaceSolution(): Promise<void> {
     const workspaceFolders = vscode.workspace.workspaceFolders;
     if (!workspaceFolders || workspaceFolders.length === 0) {
@@ -429,7 +458,7 @@ async function restoreWorkspace(): Promise<void> {
     }
 
     const label = candidateSolution ? `Restoring ${path.basename(candidateSolution)}` : 'Restoring workspace';
-    await runDotnetCommand(args, workspaceRoot, label);
+    await runDotnetCommand(args, workspaceRoot, label, 'Restore completed.');
 }
 
 async function restoreProject(): Promise<void> {
@@ -465,7 +494,30 @@ async function restoreProject(): Promise<void> {
         return;
     }
 
-    await runDotnetCommand(['restore', pick.projectPath], workspaceRoot, `Restoring ${pick.label}`);
+    await runDotnetCommand(['restore', pick.projectPath], workspaceRoot, `Restoring ${pick.label}`, 'Restore completed.');
+}
+
+async function runTestsInContext(debug: boolean = false): Promise<void> {
+    const workspaceRoot = getWorkspaceRoot();
+    if (!workspaceRoot) {
+        return;
+    }
+
+    const target = await resolveTestTarget(workspaceRoot);
+    const args = ['test'];
+    if (target) {
+        args.push(target);
+    }
+
+    const title = target
+        ? `${debug ? 'Debugging' : 'Running'} tests: ${path.basename(target)}`
+        : `${debug ? 'Debugging' : 'Running'} tests`;
+
+    const successMessage = debug
+        ? 'Test run completed (debug attach not yet implemented).'
+        : 'Test run completed.';
+
+    await runDotnetCommand(args, workspaceRoot, title, successMessage);
 }
 
 function getWorkspaceRoot(): string | undefined {
@@ -517,6 +569,59 @@ async function pickWorkspaceSolutionCandidate(workspaceRoot: string): Promise<st
     return candidates[0];
 }
 
+async function resolveTestTarget(workspaceRoot: string): Promise<string | undefined> {
+    const activeFile = vscode.window.activeTextEditor?.document?.uri?.fsPath;
+    if (activeFile && activeFile.startsWith(workspaceRoot) && activeFile.toLowerCase().endsWith('.vb')) {
+        const nearestProject = findNearestProjectForFile(activeFile, workspaceRoot);
+        if (nearestProject) {
+            return nearestProject;
+        }
+    }
+
+    const configuredSolution = getConfiguredSolutionPath(workspaceRoot);
+    if (configuredSolution) {
+        return configuredSolution;
+    }
+
+    const candidateSolution = await pickWorkspaceSolutionCandidate(workspaceRoot);
+    if (candidateSolution) {
+        return candidateSolution;
+    }
+
+    const projects = await findWorkspaceProjects();
+    if (projects.length === 1) {
+        return projects[0];
+    }
+
+    if (projects.length > 1) {
+        const items: TestPickItem[] = projects.map((projectPath) => {
+            const relative = path.relative(workspaceRoot, projectPath);
+            const label = relative && !relative.startsWith('..') && !path.isAbsolute(relative)
+                ? relative
+                : path.basename(projectPath);
+            return {
+                label,
+                detail: projectPath,
+                targetPath: projectPath
+            };
+        });
+
+        items.unshift({
+            label: 'Workspace (dotnet test)',
+            description: 'Run tests without an explicit project/solution'
+        });
+
+        const pick = await vscode.window.showQuickPick(items, {
+            placeHolder: 'Select a project/solution to test',
+            matchOnDescription: true
+        });
+
+        return pick?.targetPath;
+    }
+
+    return undefined;
+}
+
 async function findWorkspaceSolutions(): Promise<string[]> {
     const config = vscode.workspace.getConfiguration('vbnet');
     const defaultExclude = '**/node_modules/**,**/.git/**,**/bower_components/**';
@@ -543,7 +648,7 @@ async function findWorkspaceProjects(): Promise<string[]> {
     return resources.map((resource) => resource.fsPath);
 }
 
-async function runDotnetCommand(args: string[], cwd: string, title: string): Promise<void> {
+async function runDotnetCommand(args: string[], cwd: string, title: string, successMessage?: string): Promise<void> {
     outputChannel?.show();
     outputChannel?.appendLine(`Running: dotnet ${args.join(' ')}`);
 
@@ -578,7 +683,9 @@ async function runDotnetCommand(args: string[], cwd: string, title: string): Pro
         })
     );
 
-    vscode.window.showInformationMessage('Restore completed.');
+    if (successMessage) {
+        vscode.window.showInformationMessage(successMessage);
+    }
 }
 
 function fsPathExists(filePath: string): boolean {
@@ -589,6 +696,34 @@ function fsPathExists(filePath: string): boolean {
     }
 }
 
+function findNearestProjectForFile(filePath: string, workspaceRoot: string): string | undefined {
+    let current = path.dirname(filePath);
+    const root = path.resolve(workspaceRoot);
+
+    while (current.startsWith(root)) {
+        try {
+            const entries = fs.readdirSync(current);
+            const candidates = entries.filter((entry) => entry.toLowerCase().endsWith('.vbproj'));
+            if (candidates.length > 0) {
+                return path.join(current, candidates[0]);
+            }
+        } catch {
+            return undefined;
+        }
+
+        if (current === root) {
+            break;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+
+    return undefined;
+}
+
 async function attachToProcess(): Promise<void> {
     const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
     const processes = await listProcesses();

test-explore/TEST_RESULTS.md

@@ -47,6 +47,24 @@ Optional flags:
 
 ## Recent runs
 
+### 2026-01-22 — CI-safe tests (VB.NET only)
+
+Commands:
+- `dotnet test test\VbNet.LanguageServer.Tests.Vb\VbNet.LanguageServer.Tests.Vb.vbproj -c Release`
+- `dotnet test test\VbNet.Extension.Tests.Vb\VbNet.Extension.Tests.Vb.vbproj -c Release`
+
+Outcome: PASS (150/150, 6/6)
+
+### 2026-01-22 — VS Code harness (VB.NET server, test commands)
+
+Command:
+- `cd test-explore\\clients\\vscode; npm test`
+
+Outcome: PASS (14 passing, 5 pending; non-fatal DAP warnings)
+Notes:
+- DAP warnings: `Failed command 'threads' : 0x80004005`.
+- DAP trace: `test-explore/clients/vscode/logs/dap-trace-2026-01-22T203652019Z.log`.
+
 ### 2026-01-22 — VS Code harness (VB.NET server, attach command)
 
 Command:

test-explore/TEST_SUITE.md

@@ -92,7 +92,7 @@ Purpose: Validate extension activation, configuration, and editor integrations.
 Targets:
 - Activation events (.vb file open, workspace containing .sln/.vbproj).
 - Output channels and log level propagation.
-- Commands (restart server, select solution, show output).
+- Commands (restart server, select solution, show output, restore, reload, attach, test runs).
 - Configuration changes (debounce and diagnostics mode).
 - Workspace trust behavior (limited activation if applicable).
 

test-explore/clients/vscode/src/suite/vbnet-extension.test.ts

@@ -279,6 +279,8 @@ if (skipVbnetSmoke) {
             assert.ok(commands.includes("vbnet.toggleLspTrace"), "Toggle LSP trace command not registered.");
             assert.ok(commands.includes("vbnet.restoreWorkspace"), "Restore workspace command not registered.");
             assert.ok(commands.includes("vbnet.restoreProject"), "Restore project command not registered.");
+            assert.ok(commands.includes("vbnet.runTestsInContext"), "Run tests command not registered.");
+            assert.ok(commands.includes("vbnet.debugTestsInContext"), "Debug tests command not registered.");
             assert.ok(commands.includes("vbnet.reloadWorkspace"), "Reload workspace command not registered.");
             assert.ok(commands.includes("vbnet.attachToProcess"), "Attach to process command not registered.");
             await config.update("trace.server", "verbose", vscode.ConfigurationTarget.Workspace);

test/VbNet.Extension.Tests.Vb/ExtensionManifestTests.vb

@@ -71,6 +71,8 @@ Namespace VbNet.Extension.Tests
                 "vbnet.toggleLspTrace",
                 "vbnet.restoreWorkspace",
                 "vbnet.restoreProject",
+                "vbnet.runTestsInContext",
+                "vbnet.debugTestsInContext",
                 "vbnet.reloadWorkspace",
                 "vbnet.attachToProcess"
             }