Respect hidden tests; support testing a single method; support cancel

Author: gjsjohnmurray

src/commonRunTestsHandler.ts

@@ -11,12 +11,14 @@ export async function commonRunTestsHandler(controller: vscode.TestController, r
   // For each authority (i.e. server:namespace) accumulate a map of the class-level Test nodes in the tree.
   // We don't yet support running only some TestXXX methods in a testclass
   const mapAuthorities = new Map<string, Map<string, vscode.TestItem>>();
+  const runIndices: number[] =[];
   const queue: vscode.TestItem[] = [];
 
   // Loop through all included tests, or all known tests, and add them to our queue
   if (request.include) {
     request.include.forEach(test => queue.push(test));
   } else {
+    // Run was launched from controller's root level
     controller.items.forEach(test => queue.push(test));
   }
 
@@ -25,7 +27,7 @@ export async function commonRunTestsHandler(controller: vscode.TestController, r
     const test = queue.pop()!;
 
     // Skip tests the user asked to exclude
-    if (request.exclude?.includes(test)) {
+    if (request.exclude && request.exclude.filter((excludedTest) => excludedTest.id === test.id).length > 0) {
       continue;
     }
 
@@ -58,15 +60,26 @@ export async function commonRunTestsHandler(controller: vscode.TestController, r
     test.children.forEach(test => queue.push(test));
   }
 
+  // Cancelled while building our structures?
+  if (cancellation.isCancellationRequested) {
+    return;
+  }
+
   if (mapAuthorities.size === 0) {
     // Nothing included
     vscode.window.showWarningMessage(`Empty test run`);
     return;
   }
 
-  if (cancellation.isCancellationRequested) {
-    // TODO what?
-  }
+  // Stop debugging sessions we started
+  cancellation.onCancellationRequested(() => {
+    runIndices.forEach((runIndex) => {
+      const session = allTestRuns[runIndex]?.debugSession;
+      if (session) {
+        vscode.debug.stopDebugging(session);
+      }
+    });
+  });
 
   for await (const mapInstance of mapAuthorities) {
 
@@ -135,20 +148,43 @@ export async function commonRunTestsHandler(controller: vscode.TestController, r
       const runQualifiers = controller.id === `${extensionId}-Local` ? "" : "/noload/nodelete";
       // Run tests through the debugger but only stop at breakpoints etc if user chose "Debug Test" instead of "Run Test"
       const runIndex = allTestRuns.push(run) - 1;
-      const configuration: vscode.DebugConfiguration = {
+      runIndices.push(runIndex);
+
+      // Compute the testspec argument for %UnitTest.Manager.RunTest() call.
+      // Typically it is a testsuite, the subfolder where we copied all the testclasses,
+      // but if only a single method of a single class is being tested we will also specify testcase and testmethod.
+      let testSpec = serverSpec.username;
+      if (request.include?.length === 1) {
+        const idParts = request.include[0].id.split(":");
+        if (idParts.length === 4) {
+          testSpec = `${serverSpec.username}:${idParts[2]}:${idParts[3]}`;
+        }
+      }
+
+      const configuration = {
         "type": "objectscript",
         "request": "launch",
         "name": `${controller.id.split("-").pop()}Tests:${serverSpec.name}:${namespace}:${serverSpec.username}`,
-        "program": `##class(%UnitTest.Manager).RunTest("${serverSpec.username}","${runQualifiers}")`,
-        "testRunIndex": runIndex,
-        "testIdBase": firstClassTestItem.id.split(":", 2).join(":")
+        "program": `##class(%UnitTest.Manager).RunTest("${testSpec}","${runQualifiers}")`,
+
+        // Extra properties needed by our DebugAdapterTracker
+        "testingRunIndex": runIndex,
+        "testingIdBase": firstClassTestItem.id.split(":", 2).join(":")
       };
       const sessionOptions: vscode.DebugSessionOptions = {
         noDebug: request.profile?.kind !== vscode.TestRunProfileKind.Debug,
         suppressDebugToolbar: request.profile?.kind !== vscode.TestRunProfileKind.Debug
       };
-      if (!await vscode.debug.startDebugging(folder, configuration, sessionOptions)) {
-        await vscode.window.showErrorMessage(`Failed to launch testing`, { modal: true });
+
+      // ObjectScript debugger's initializeRequest handler needs to identify target server and namespace
+      // and does this from current active document, so here we make sure there's a suitable one.
+      vscode.commands.executeCommand("vscode.open", oneUri, { preserveFocus: true });
+
+      // Start the debugger unless cancelled
+      if (cancellation.isCancellationRequested || !await vscode.debug.startDebugging(folder, configuration, sessionOptions)) {
+        if (!cancellation.isCancellationRequested) {
+          await vscode.window.showErrorMessage(`Failed to launch testing`, { modal: true });
+        }
         run.end();
         allTestRuns[runIndex] = undefined;
         return;

src/debugTracker.ts

@@ -1,5 +1,5 @@
 import * as vscode from 'vscode';
-import { allTestRuns, loadedTestController, localTestController } from './extension';
+import { allTestRuns, loadedTestController, localTestController, TestRun } from './extension';
 import { refreshHistoryRootItem } from './historyExplorer';
 
 export class DebugTracker implements vscode.DebugAdapterTracker {
@@ -8,8 +8,8 @@ export class DebugTracker implements vscode.DebugAdapterTracker {
   private serverName: string;
   private namespace: string;
   private testController: vscode.TestController
-  private run?: vscode.TestRun;
-  private testIdBase: string;
+  private run?: TestRun;
+  private testingIdBase: string;
   private className?: string;
   private testMethodName?: string;
   private testDuration?: number;
@@ -22,8 +22,11 @@ export class DebugTracker implements vscode.DebugAdapterTracker {
     let runType: string;
     [ runType, this.serverName, this.namespace ] = this.session.configuration.name.split(':');
     this.testController = runType === 'LoadedTests' ? loadedTestController : localTestController;
-    this.run = allTestRuns[this.session.configuration.testRunIndex];
-    this.testIdBase = this.session.configuration.testIdBase;
+    this.run = allTestRuns[this.session.configuration.testingRunIndex];
+    if (this.run) {
+      this.run.debugSession = session;
+    };
+    this.testingIdBase = this.session.configuration.testingIdBase;
     this.methodTestMap = new Map<string, vscode.TestItem>();
 
     const addToMethodTestMap = (testItem?: vscode.TestItem) => {
@@ -39,10 +42,10 @@ export class DebugTracker implements vscode.DebugAdapterTracker {
 
     if (runType === 'LoadedTests') {
       // This tree is flat
-      addToMethodTestMap(this.testController.items.get(this.testIdBase));
+      addToMethodTestMap(this.testController.items.get(this.testingIdBase));
     } else {
       // This tree is nested
-      addToMethodTestMap(this.testController.items.get(this.testIdBase + ':'));
+      addToMethodTestMap(this.testController.items.get(this.testingIdBase + ':'));
     }
   }
 
@@ -70,7 +73,7 @@ export class DebugTracker implements vscode.DebugAdapterTracker {
         const methodBegin = line.match(/^      Test([%\dA-Za-z][\dA-Za-z]*).* begins \.\.\.$/);
         if (methodBegin) {
           this.testMethodName = methodBegin[1];
-          this.methodTest = this.methodTestMap.get(`${this.testIdBase}:${this.className}:Test${this.testMethodName}`);
+          this.methodTest = this.methodTestMap.get(`${this.testingIdBase}:${this.className}:Test${this.testMethodName}`);
           this.failureMessages = [];
           if (this.methodTest) {
             this.run.started(this.methodTest)
@@ -143,7 +146,15 @@ export class DebugTracker implements vscode.DebugAdapterTracker {
       refreshHistoryRootItem(this.serverName, this.namespace);
     }
 
-    // Clear reference to run (not known if this is necessary)
-    allTestRuns[this.session.configuration.testRunIndex] = undefined;
+    // Clear run record (may not be necessary, but is harmless)
+    allTestRuns[this.session.configuration.testingRunIndex] = undefined;
+  }
+
+  onError(error: Error): void {
+    //console.log(`**Erroring session ${this.session.name}: error.message=${error.message}`);
+  }
+
+  onExit(code: number | undefined, signal: string | undefined): void {
+    //console.log(`**Exiting session ${this.session.name}: code=${code}, signal=${signal}`);
   }
 }

src/extension.ts

@@ -10,10 +10,14 @@ export const extensionId = "intersystems-community.testingmanager";
 export let localTestController: vscode.TestController;
 export let loadedTestController: vscode.TestController;
 export let historyBrowserController: vscode.TestController;
-export const allTestRuns: (vscode.TestRun | undefined)[] = [];
 export let osAPI: any;
 export let smAPI: any;
 
+export interface TestRun extends vscode.TestRun {
+  debugSession?: vscode.DebugSession
+}
+export const allTestRuns: (TestRun | undefined)[] = [];
+
 export interface IWebServerSpec {
     scheme?: string;
     host: string;