Fix gotoTest

src/buildTree.ts

@@ -1,4 +1,4 @@
-import { IParsedName } from "./parseTestName";
+import { IParsedName, getSegmentString, getSegmentEnd } from "./parseTestName";
 
 /**
  * This is an "abstract" version of a tree node, containing the logical structure
@@ -19,8 +19,8 @@ export function buildTree(parsedNames: IParsedName[]): ITestTreeNode {
         for (let i = 0; i < parsedName.segments.length - 1; i++) {
             const segment = parsedName.segments[i];
 
-            const part = parsedName.fullName.substr(segment.start, segment.end - segment.start);
-            const fullName = parsedName.fullName.substr(0, segment.end);
+            const part = getSegmentString(parsedName.fullName, segment);
+            const fullName = parsedName.fullName.substring(0, getSegmentEnd(segment));
             if (!currentNode.subTrees.has(part)) {
                 const newTree: ITestTreeNode = {
                     fullName,
@@ -36,7 +36,7 @@ export function buildTree(parsedNames: IParsedName[]): ITestTreeNode {
         }
 
         const lastSegment = parsedName.segments[parsedName.segments.length - 1];
-        const testName = parsedName.fullName.substr(lastSegment.start, lastSegment.end - lastSegment.start);
+        const testName = getSegmentString(parsedName.fullName, lastSegment);
         currentNode.tests.push(testName);
     }
     return root;

src/gotoTest.ts

@@ -3,49 +3,48 @@ import { AppInsightsClient } from "./appInsightsClient";
 import { Logger } from "./logger";
 import { Utility } from "./utility";
 import { TestNode } from "./treeNodes/testNode";
+import { parseTestName, IStringView, getSegmentStart } from "./parseTestName";
 
 export class GotoTest {
 
-    public go(test: TestNode): void {
+    public async go(test: TestNode) {
 
         AppInsightsClient.sendEvent("gotoTest");
 
-        const symbolInformation = vscode.commands.executeCommand<vscode.SymbolInformation[]>(
-            "vscode.executeWorkspaceSymbolProvider",
-            test.fullName,
-        ).then((symbols) => {
-
-            let symbol: vscode.SymbolInformation;
-
-            try {
-                symbol = this.findTestLocation(symbols, test);
+        // Remove all brackets from the test name
+        const parsed = parseTestName(test.fullName);
+        const bracketsRemoved = parsed.segments
+            .map(segment => parsed.fullName.substring(getSegmentStart(segment), segment.name.end))
+            .join("");
 
-                vscode.workspace.openTextDocument(symbol.location.uri).then((doc) => {
-                    vscode.window.showTextDocument(doc).then((editor) => {
-                        const loc = symbol.location.range;
-                        const selection = new vscode.Selection(loc.start.line, loc.start.character, loc.start.line, loc.end.character);
-                        vscode.window.activeTextEditor.selection = selection;
-                        vscode.window.activeTextEditor.revealRange(selection, vscode.TextEditorRevealType.InCenter);
-                    });
-                });
-
-            } catch (r) {
-                Logger.Log(r.message);
-                vscode.window.showWarningMessage(r.message);
-            }
-
-        });
+        const symbols = await vscode.commands.executeCommand<vscode.SymbolInformation[]>(
+            "vscode.executeWorkspaceSymbolProvider",
+            bracketsRemoved,
+        )
+
+        let symbol: vscode.SymbolInformation;
+
+        try {
+            symbol = this.findTestLocation(symbols, bracketsRemoved);
+            const doc = await vscode.workspace.openTextDocument(symbol.location.uri);
+            const editor = await vscode.window.showTextDocument(doc)
+            const loc = symbol.location.range;
+            const selection = new vscode.Selection(loc.start.line, loc.start.character, loc.start.line, loc.end.character);
+            editor.selection = selection;
+            editor.revealRange(selection, vscode.TextEditorRevealType.InCenter);
+        } catch (r) {
+            Logger.Log(r.message);
+            vscode.window.showWarningMessage(r.message);
+        }
     }
 
-    public findTestLocation(symbols: vscode.SymbolInformation[], testNode: TestNode): vscode.SymbolInformation {
+    public findTestLocation(symbols: vscode.SymbolInformation[], testName: string): vscode.SymbolInformation {
 
         if (symbols.length === 0) {
             throw new Error("Could not find test (no symbols found)");
         }
 
-        const testFqn = testNode.fullName;
-
-        symbols = symbols.filter((s) => this.isSymbolATestCandidate(s) && testFqn.endsWith(this.getTestMethodFqn(s.name)));
+        symbols = symbols.filter((s) => this.isSymbolATestCandidate(s) && testName.endsWith(this.getTestMethodName(s.name)));
 
         if (symbols.length === 0) {
             throw Error("Could not find test (no symbols matching)");
@@ -58,16 +57,10 @@ export class GotoTest {
         return symbols[0];
     }
 
-    public getTestMethodFqn(testName: string): string {
+    public getTestMethodName(testName: string): string {
         // The symbols are reported on the form Method or Method(string, int) (in case of test cases etc).
         // We are only interested in the method name, not its arguments
-        const firstParanthesis = testName.indexOf("(");
-
-        if (firstParanthesis > -1) {
-            testName = testName.substring(0, firstParanthesis);
-        }
-
-        return testName;
+        return testName.replace(/\(.*$/, "");
     }
 
     private isSymbolATestCandidate(s: vscode.SymbolInformation): boolean {

src/parseTestName.ts

@@ -1,31 +1,54 @@
-export interface INameSegment {
+export interface IStringView {
     start: number;
     end: number;
 }
 
+export interface ISegment {
+    prefix?: IStringView,
+    name: IStringView,
+    brackets?: IStringView,
+}
+
 export interface IParsedName {
     fullName: string;
-    segments: INameSegment[];
+    segments: ISegment[];
 }
 
 export function parseTestName(name: string): IParsedName {
     let i = 0;
-    const segments = [];
+    const segments: ISegment[] = [];
     while (i < name.length) {
         segments.push(parseSegment());
     }
     return { fullName: name, segments };
 
-    function parseSegment(): INameSegment {
+    function parseSegment(): ISegment {
+        const prefix = parsePrefix();
+        const _name = parseName();
+        const brackets = parseBrackets();
+        return { prefix, name: _name, brackets };
+    }
+
+    function parsePrefix(): IStringView | undefined {
+        if (name[i] === "." || name[i] === "+") {
+            const result = { start: i, end: i + 1 };
+            i++;
+            return result;
+        }
+    }
+    function parseName(): IStringView {
         const start = i;
         while (i < name.length) {
-            if (tryParseBrackets()) { continue; }
-            if (name[i] === "." || name[i] === "+") { break; }
+            if (name[i] === "(" || name[i] === "+" || name[i] === ".") {
+                break;
+            }
             i++;
         }
-        const end = i;
-        i++;
-        return { start, end };
+        return { start, end: i };
+    }
+    function parseBrackets(): IStringView | undefined {
+        const start = i;
+        if (tryParseBrackets()) { return { start, end: i }; }
     }
 
     function tryParseBrackets(): boolean {
@@ -62,3 +85,18 @@ export function parseTestName(name: string): IParsedName {
         return true;
     }
 }
+
+export function getSegmentString(fullName: string, segment: ISegment) {
+    return fullName.substring(segment.name.start, getSegmentEnd(segment));
+}
+
+export function getSegmentStart(segment: ISegment) {
+    return segment.prefix?.start ?? segment.name.start;
+}
+
+export function getSegmentEnd(segment: ISegment) {
+    return segment.brackets?.end ?? segment.name.end;
+}
+export function viewToString(fullName: string, view: IStringView) {
+    return fullName.substring(view.start, view.end);
+}

test/gotoTest.test.ts

@@ -141,15 +141,15 @@ suite("Get test method name", () => {
     test("Test name without namespace", () => {
 
         const gotoTest = new GotoTest();
-        const result = gotoTest.getTestMethodFqn("Test");
+        const result = gotoTest.getTestMethodName("Test");
 
         assert.equal(result, "Test");
     });
 
     test("XUnit theory name without namespace", () => {
 
         const gotoTest = new GotoTest();
-        const result = gotoTest.getTestMethodFqn("Test(param: value)");
+        const result = gotoTest.getTestMethodName("Test(param: value)");
 
         assert.equal(result, "Test");
     });

test/parseTestName.test.ts

@@ -1,13 +1,13 @@
 import * as assert from "assert";
-import { parseTestName } from "../src/parseTestName";
+import { parseTestName, getSegmentString } from "../src/parseTestName";
 
 suite("parseTestName - test names are parsed correctly", () => {
     function testParsing(input, expected) {
         test(`${input} -> ${expected.map((x) => `"${x}"`).join(" ")}`, () => {
             const result = parseTestName(input);
             assert.equal(result.fullName, input);
             const segmentsAsStrings = result.segments.map(
-                (segment) => input.substr(segment.start, segment.end - segment.start));
+                (segment) => getSegmentString(input, segment));
             assert.deepEqual(segmentsAsStrings, expected);
         });
     }