fix: discovering last test in identical-named suites only

Author: ILikeRubberDuckies

src/controller.ts

@@ -5,12 +5,12 @@ import picomatch from "picomatch";
 import * as vscode from "vscode";
 import { coverageContext } from "./coverage";
 import { DisposableStore, MutableDisposable } from "./disposable";
+import { ExtensionConfig } from './extension-config';
 import { last } from "./iterable";
 import { ICreateOpts, ItemType, getContainingItemsForFile, testMetadata } from "./metadata";
 import { IParsedNode, parseSource } from "./parsing";
 import { RunHandler, TestRunner } from "./runner";
 import { ISourceMapMaintainer, SourceMapStore } from "./source-map-store";
-import { ExtensionConfig } from './extension-config';
 
 const diagnosticCollection = vscode.languages.createDiagnosticCollection("nodejs-testing-dupes");
 
@@ -185,20 +185,31 @@ export class Controller {
     const add = (
       parent: vscode.TestItem,
       node: IParsedNode,
+      id: string,
       start: vscode.Location,
       end: vscode.Location,
     ): vscode.TestItem => {
-      let item = parent.children.get(node.name);
+      let item = parent.children.get(id);
       if (!item) {
-        item = this.ctrl.createTestItem(node.name, node.name, start.uri);
+        item = this.ctrl.createTestItem(id, node.name, start.uri);
         testMetadata.set(item, { type: ItemType.Test });
         parent.children.add(item);
       }
       item.range = new vscode.Range(start.range.start, end.range.end);
 
       const seen = new Map<string, vscode.TestItem>();
+      const level2Dupes = new Map<string, vscode.TestItem>();
+      for (const [, sibling] of parent.children) {
+        if (sibling.id == item.id || sibling.label !== node.name) {
+          continue;
+        }
+
+        for (const [, cousin] of sibling.children) {
+          level2Dupes.set(cousin.label, cousin);
+        }
+      }
       for (const child of node.children) {
-        const existing = seen.get(child.name);
+        const existing = seen.get(child.name) || level2Dupes.get(child.name);
         const start = sourceMap.originalPositionFor(
           child.location.start.line,
           child.location.start.column,
@@ -212,7 +223,7 @@ export class Controller {
           continue;
         }
 
-        seen.set(child.name, add(item, child, start, end));
+        seen.set(child.name, add(item, child, child.name, start, end));
       }
 
       for (const [id] of item.children) {
@@ -228,6 +239,7 @@ export class Controller {
     // source file. This is probably a good assumption. Likewise we assume that a single
     // a single describe/test is not split between different files.
     const newTestsInFile = new Map<string, vscode.TestItem>();
+    let nId: number = 0;
     for (const node of tree) {
       const start = sourceMap.originalPositionFor(
         node.location.start.line,
@@ -236,7 +248,14 @@ export class Controller {
       const end = sourceMap.originalPositionFor(node.location.end.line, node.location.end.column);
       const file = last(this.getContainingItemsForFile(start.uri, { compiledFile: uri }))!.item!;
       diagnosticCollection.delete(start.uri);
-      newTestsInFile.set(node.name, add(file, node, start, end));
+      if (newTestsInFile.has(node.name) && ["describe", "suite"].includes(node.fn)) {
+        const id = `${node.name}#${nId++}`;
+        newTestsInFile.set(id, add(file, node, id, start, end));
+      }
+      else {
+        nId = 0;
+        newTestsInFile.set(node.name, add(file, node, node.name, start, end));
+      }
     }
 
     if (previous) {

src/runner.ts

@@ -99,16 +99,33 @@ export class TestRunner implements vscode.Disposable {
       const concurrency = this.concurrency.value || cpus().length;
       const getTestByPath = (path: string[]): vscode.TestItem | undefined => {
         const uri = vscode.Uri.parse(path[0]);
-        let item = last(getContainingItemsForFile(wf, ctrl, uri))!.item;
-        if (!item) {
+        let fileItem = last(getContainingItemsForFile(wf, ctrl, uri))!.item;
+        if (!fileItem) {
           return undefined;
         }
 
-        for (let i = 1; item && i < path.length; i++) {
-          item = item.children.get(path[i]);
+        let item: vscode.TestItem;
+        const searchPath = (test: vscode.TestItem, pathIndex: number) => {
+          let id = path[pathIndex];
+          let nId = 0;
+          let child;
+          do {
+            child = test.children.get(id);
+            if (child && path[pathIndex + 1] === undefined) {
+              item = child;
+            }
+            else {
+              child && searchPath(child, pathIndex + 1);
+            }
+
+            id = `${path[pathIndex]}#${nId++}`;
+          }
+          while (child)
         }
 
-        return item;
+        searchPath(fileItem, 1);
+
+        return item!;
       };
 
       // inline source maps read from the runtime. These will both be definitive
@@ -422,6 +439,23 @@ export class TestRunner implements vscode.Disposable {
     const modernNamePatterns = nodeMajorVersion >= 22;
 
     const addTestsToFileRecord = (record: IIncludeFile, queue: vscode.TestItem[]) => {
+      //merge queue-items with the same (extended) id
+      for (let i = 0; i < queue.length; i++) {
+        let nId = 0;
+        for (let j = 0; j < queue.length; j++) {
+          if (i == j) continue;
+
+          if (`${queue[i].id}#${nId++}` === queue[j].id) {
+            for (const [, child] of queue[j].children) {
+              queue[i].children.add(child);
+            }
+            queue.splice(j, 1);
+            j--;
+            if (i > j) i--;
+          }
+        }
+      }
+
       record.include ??= new Set();
 
       while (queue.length) {