Start catching results

gjsjohnmurray · gjsjohnmurray · commit 5c4bd0da7352 · 2023-03-16T23:12:25.000Z
diff --git a/src/debugTracker.ts b/src/debugTracker.ts
@@ -0,0 +1,126 @@
+import * as vscode from 'vscode';
+import { allTestRuns, loadedTestController, localTestController } from './extension';
+
+export class DebugTracker implements vscode.DebugAdapterTracker {
+
+  private session: vscode.DebugSession;
+  private testController: vscode.TestController
+  private run?: vscode.TestRun;
+  private testIdBase: string;
+  private classTestCollection?: vscode.TestItemCollection;
+  private className?: string;
+  private classTest?: vscode.TestItem;
+  private testMethodName?: string;
+  private testDuration?: number;
+  private methodTest?: vscode.TestItem;
+  private failureMessages: vscode.TestMessage[] = [];
+
+  constructor(session: vscode.DebugSession) {
+    this.session = session;
+    this.testController = this.session.configuration.name.startsWith('ServerTests:') ? loadedTestController : localTestController;
+    this.run = allTestRuns[this.session.configuration.testRunIndex];
+    this.testIdBase = this.session.configuration.testIdBase;
+    this.classTestCollection = this.testController.items.get(this.testIdBase)?.children;
+  }
+
+  onDidSendMessage(message: any): void {
+    if (message.type === 'event' && message.event === 'output' && message.body?.category === 'stdout') {
+      if (!this.run) {
+        return;
+      }
+      const line: string = (message.body.output as string).replace(/\n/, '');
+      //console.log(`${line}`);
+      if (this.className === undefined) {
+        const classBegin = line.match(/^    ([%\dA-Za-z][\dA-Za-z\.]*) begins \.\.\.$/);
+        if (classBegin) {
+          this.className = classBegin[1];
+          this.classTest = this.classTestCollection?.get(`${this.testIdBase}:${this.className}`);
+        }
+        return;
+      }
+
+      if (line.startsWith(`    ${this.className} `)) {
+        this.className = undefined;
+        return;
+      }
+
+      if (this.testMethodName === undefined) {
+        const methodBegin = line.match(/^      Test([%\dA-Za-z][\dA-Za-z]*).* begins \.\.\.$/);
+        if (methodBegin) {
+          this.testMethodName = methodBegin[1];
+          this.methodTest = this.classTest?.children.get(`${this.classTest.id}:Test${this.testMethodName}`);
+          this.failureMessages = [];
+          if (this.methodTest) {
+            this.run.started(this.methodTest)
+          }
+          return;
+        }
+      } else {
+        if (line.startsWith(`      Test${this.testMethodName} `)) {
+          const outcome = line.split(this.testMethodName + ' ')[1];
+          console.log(`Class ${this.className}, Test-method ${this.testMethodName}, outcome=${outcome}`);
+          if (this.methodTest) {
+            switch (outcome) {
+              case 'passed':
+                this.run.passed(this.methodTest, this.testDuration)
+                break;
+
+              case 'failed':
+                this.run.failed(this.methodTest, this.failureMessages.length > 0 ? this.failureMessages : { message: 'Failed with no messages' }, this.testDuration);
+                break;
+
+              default:
+                break;
+            }
+          }
+          this.testMethodName = undefined;
+          this.testDuration = undefined;
+          this.methodTest = undefined;
+          this.failureMessages = [];
+          return;
+        }
+      }
+
+      if (this.className && this.testMethodName) {
+        const assertPassedMatch = line.match(/^        (Assert\w+):(.*) \(passed\)$/);
+        if (assertPassedMatch) {
+          const macroName = assertPassedMatch[1];
+          const message = assertPassedMatch[2];
+          console.log(`Class ${this.className}, Test-method ${this.testMethodName}, macroName ${macroName}, outcome 'passed', message=${message}`);
+        } else {
+          const assertFailedMatch = line.match(/^(Assert\w+):(.*) \(failed\)  <<====/);
+          if (assertFailedMatch) {
+            const macroName = assertFailedMatch[1];
+            const message = assertFailedMatch[2];
+            console.log(`Class ${this.className}, Test-method ${this.testMethodName}, macroName ${macroName}, outcome 'failed', message=${message}`);
+            this.failureMessages.push({ message: message });
+          } else {
+            const logMessageMatch = line.match(/^        LogMessage:(.*)$/);
+            if (logMessageMatch) {
+              const message = logMessageMatch[1];
+              console.log(`Class ${this.className}, Test-method ${this.testMethodName}, macroName LogMessage, message=${message}`);
+              const duration = message.match(/^Duration of execution: (\d*\.\d+) sec.$/);
+              if (duration) {
+                this.testDuration = + duration[1] * 1000;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  onWillStartSession(): void {
+    console.log(`**Starting session ${this.session.name}, run.name = ${this.run?.name}`);
+  }
+
+  onWillStopSession(): void {
+    console.log(`**Stopping session ${this.session.name}`);
+    if (this.run) {
+      this.run.end();
+    }
+
+    // Clear reference to run (not known if this is necessary)
+    allTestRuns[this.session.configuration.testRunIndex] = undefined;
+  }
+}
diff --git a/src/debugTrackerFactory.ts b/src/debugTrackerFactory.ts
@@ -0,0 +1,9 @@
+import * as vscode from 'vscode';
+import { DebugTracker } from './debugTracker';
+
+export class DebugTrackerFactory implements vscode.DebugAdapterTrackerFactory {
+
+  createDebugAdapterTracker(session: vscode.DebugSession): vscode.ProviderResult<vscode.DebugAdapterTracker> {
+    return new DebugTracker(session);
+  }
+}
diff --git a/src/extension.ts b/src/extension.ts
@@ -4,11 +4,13 @@ import * as vscode from "vscode";
 import { setupHistoryExplorerController } from "./historyExplorer";
 import { setupServerTestsController } from "./serverTests";
 import { setupLocalTestsController } from "./localTests";
+import { DebugTrackerFactory } from "./debugTrackerFactory";
 
 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;
 
@@ -85,6 +87,10 @@ export async function activate(context: vscode.ExtensionContext) {
     context.subscriptions.push(historyBrowserController);
     await setupHistoryExplorerController();
 
+    context.subscriptions.push(
+      vscode.debug.registerDebugAdapterTrackerFactory('objectscript', new DebugTrackerFactory())
+    );
+
     // Register the commands
     context.subscriptions.push(
         //DUMMY example (remember to add entries to `contributes.commands` in package.json)
diff --git a/src/historyExplorer.ts b/src/historyExplorer.ts
@@ -190,7 +190,7 @@ async function addTestAsserts(item: vscode.TestItem, controller: vscode.TestCont
             spec,
             { apiVersion: 1, namespace, path: "/action/query" },
             {
-                query: "SELECT ID, Action, Status, Description FROM %UnitTest_Result.TestAssert WHERE TestMethod = ?",
+                query: "SELECT ID, Counter, COUNT(Counter %FOREACH(TestMethod)) AS MaxCounter, Action, Status, Description FROM %UnitTest_Result.TestAssert WHERE TestMethod = ?",
                 parameters: [testMethod]
             },
         );
@@ -209,7 +209,8 @@ async function addTestAsserts(item: vscode.TestItem, controller: vscode.TestCont
             }
 
             response?.data?.result?.content?.forEach(element => {
-                const child = controller.createTestItem(`${item.id}:${element.ID}`, `${element.Action}`);
+                // Prefix the label with an underscore-padded integer to preserve order
+                const child = controller.createTestItem(`${item.id}:${element.ID}`, `${element.Counter.toString().padStart(element.MaxCounter.toString().length, "_")}. ${element.Action}`);
                 child.description = element.Description;
                 child.canResolveChildren = false;
                 item.children.add(child);
@@ -236,7 +237,7 @@ export function replaceRootItems(controller: vscode.TestController) {
         if (server?.serverName && server.namespace) {
             const key = server.serverName + ':' + server.namespace.toUpperCase();
             if (!rootMap.has(key)) {
-                const item = controller.createTestItem(key, key);
+                const item = controller.createTestItem(key, key, folder.uri);
                 item.canResolveChildren = true;
                 rootMap.set(key, item);
             }
diff --git a/src/serverTests.ts b/src/serverTests.ts
@@ -1,5 +1,5 @@
 import * as vscode from 'vscode';
-import { loadedTestController } from './extension';
+import { allTestRuns, IServerSpec, loadedTestController, osAPI } from './extension';
 import { replaceRootItems, serverSpec } from './historyExplorer';
 import logger from './logger';
 import { makeRESTRequest } from './makeRESTRequest';
@@ -29,7 +29,7 @@ async function resolveItemChildren(item: vscode.TestItem) {
                                 `${item.id}:${fullClassName}`,
                                 fullClassName,
                                 vscode.Uri.from({
-                                    scheme: "isfs-readonly",
+                                    scheme: item.uri?.scheme === "isfs" ? "isfs" : "isfs-readonly",
                                     authority: item.id.toLowerCase(),
                                     path: "/" + fullClassName.replace(/\./g, "/") + ".cls"
                                 })
@@ -84,11 +84,15 @@ export async function runTestsHandler(request: vscode.TestRunRequest, cancellati
 
     const run = loadedTestController.createTestRun(
         request,
-        'Fake Test Results',
+        'Test Results',
         true
     );
+
     run.appendOutput('Fake output from fake run of fake server tests.\r\nTODO');
-    const mapAuthorities = new Map<string, Map<string, vscode.Uri>>();
+
+    // 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 queue: vscode.TestItem[] = [];
 
     // Loop through all included tests, or all known tests, and add them to our queue
@@ -111,16 +115,17 @@ export async function runTestsHandler(request: vscode.TestRunRequest, cancellati
 
         // Resolve children if not already done
         if (test.canResolveChildren && !isResolvedMap.get(test)) {
-            resolveItemChildren(test);
+            await resolveItemChildren(test);
         }
 
-        // Mark each leaf item as enqueued and note its .cls file for copying
-        if (test.children.size === 0 && test.uri) {
+        // Mark each leaf item (a TestXXX method in a class) as enqueued and note its .cls file for copying.
+        // Every leaf must have a uri.
+        if (test.children.size === 0 && test.uri && test.parent) {
             run.enqueued(test);
             const authority = test.uri.authority;
-            const mapUris = mapAuthorities.get(authority) || new Map<string, vscode.Uri>();
-            mapUris.set(test.uri.path, test.uri);
-            mapAuthorities.set(authority, mapUris);
+            const mapTestClasses = mapAuthorities.get(authority) || new Map<string, vscode.TestItem>();
+            mapTestClasses.set(test.uri.path, test.parent);
+            mapAuthorities.set(authority, mapTestClasses);
         }
 
         // Queue any children
@@ -131,31 +136,87 @@ export async function runTestsHandler(request: vscode.TestRunRequest, cancellati
       // TODO what?
     }
 
-    for await (const one of mapAuthorities) {
-      const authority = one[0];
-      const mapUris = one[1];
-      const username = 'johnm'; //TODO
-      const testRoot = vscode.Uri.from({scheme: 'isfs', authority, path: `/.vscode/UnitTestRoot/${username}`});
-      try {
-        await vscode.workspace.fs.delete(testRoot, { recursive: true });
-      } catch (error) {
-        console.log(error);
-      }
-      for await (const one of mapUris) {
-        const key = one[0];
-        const uri = one[1];
-        const keyParts = key.split('/');
-        const clsFile = keyParts.pop() || '';
-        const directoryUri = testRoot.with({path: testRoot.path.concat(keyParts.join('/'))});
+    for await (const mapInstance of mapAuthorities) {
+      const authority = mapInstance[0];
+      const mapTestClasses = mapInstance[1];
+      const firstClassTestItem = Array.from(mapTestClasses.values())[0];
+      const oneUri = firstClassTestItem.uri;
+
+      // This will always be true since every test added to the map above required a uri
+      if (oneUri) {
+        const folder = vscode.workspace.getWorkspaceFolder(oneUri);
+        const server = osAPI.serverForUri(oneUri);
+        const username = server.username || 'UnknownUser';
+        const testRoot = vscode.Uri.from({scheme: 'isfs', authority, path: `/.vscode/UnitTestRoot/${username}`});
         try {
-          await vscode.workspace.fs.copy(uri, directoryUri.with({path: directoryUri.path.concat(clsFile)}));
+          // Limitation of the Atelier API means this can only delete the files, not the folders
+          // but zombie folders shouldn't cause problems.
+          await vscode.workspace.fs.delete(testRoot, { recursive: true });
         } catch (error) {
           console.log(error);
         }
+        for await (const mapInstance of mapTestClasses) {
+          const key = mapInstance[0];
+          const uri = mapInstance[1].uri;
+          const keyParts = key.split('/');
+          const clsFile = keyParts.pop() || '';
+          const directoryUri = testRoot.with({path: testRoot.path.concat(keyParts.join('/'))});
+          // This will always be true since every test added to the map above required a uri
+          if (uri) {
+            try {
+              await vscode.workspace.fs.copy(uri, directoryUri.with({path: directoryUri.path.concat(clsFile)}));
+            } catch (error) {
+              console.log(error);
+            }
+          }
+        }
+
+        // Find this user's most recent TestInstance
+        const serverSpec: IServerSpec = {
+          username: server.username,
+          name: server.serverName,
+          webServer: {
+            host: server.host,
+            port: server.port,
+            pathPrefix: server.pathPrefix,
+            scheme: server.scheme
+          }
+        }
+        const response = await makeRESTRequest(
+            "POST",
+            serverSpec,
+            { apiVersion: 1, namespace: server.namespace, path: "/action/query" },
+            {
+                query: "SELECT TOP 1 ID, TestInstance, Name, Duration, Status, ErrorDescription FROM %UnitTest_Result.TestSuite WHERE Name %STARTSWITH ? ORDER BY TestInstance DESC",
+                parameters: [`${server.username}\\`]
+            },
+        );
+        if (response) {
+            const latestInstanceId = response?.data?.result?.content?.[0]?.ID;
+            console.log(latestInstanceId);
+        }
+
+        // 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 = {
+          "type": "objectscript",
+          "request": "launch",
+          "name": `ServerTests:${server.username}`,
+          "program": `##class(%UnitTest.Manager).RunTest("${server.username}","/noload/nodelete")`,
+          "testRunIndex": runIndex,
+          "testIdBase": firstClassTestItem.id.split(":", 2).join(":")
+        };
+        const sessionOptions: vscode.DebugSessionOptions = {
+          noDebug: request.profile?.kind !== vscode.TestRunProfileKind.Debug
+        }
+        if (!await vscode.debug.startDebugging(folder, configuration, sessionOptions)) {
+          await vscode.window.showErrorMessage(`Failed to launch testing`, { modal: true });
+          run.end();
+          allTestRuns[runIndex] = undefined;
+          return;
+        }
       }
     }
 
-    // TODO
-    await new Promise(resolve => setTimeout(resolve, 5000));
-    run.end();
+    //run.end();
 }
