[#37] make TestItems more unique to also be able to execute duplicated test/suite name addresses

Author: d-biehl

robotcode/language_server/robotframework/parts/discovering.py

@@ -35,7 +35,7 @@ class GetAllTestsParams(Model):
 @dataclass(repr=False)
 class GetTestsParams(Model):
     text_document: TextDocumentIdentifier
-    id: Optional[str]
+    base_name: Optional[str]
 
 
 @dataclass(repr=False)
@@ -48,6 +48,7 @@ class TestItem(Model):
     type: str
     id: str
     label: str
+    longname: str
     uri: Optional[DocumentUri] = None
     children: Optional[List[TestItem]] = None
     description: Optional[str] = None
@@ -57,10 +58,10 @@ class TestItem(Model):
 
 
 class FindTestCasesVisitor(AsyncVisitor):
-    async def get(self, source: DocumentUri, model: ast.AST, id: Optional[str]) -> List[TestItem]:
+    async def get(self, source: DocumentUri, model: ast.AST, base_name: Optional[str]) -> List[TestItem]:
         self._results: List[TestItem] = []
         self.source = source
-        self.id = id
+        self.base_name = base_name
         await self.visit(model)
         return self._results
 
@@ -75,10 +76,12 @@ async def visit_TestCase(self, node: ast.AST) -> None:  # noqa: N802
         from robot.parsing.model.statements import Tags
 
         test_case = cast(TestCase, node)
+        longname = f"{self.base_name}.{test_case.name}" if self.base_name else test_case.name
         self._results.append(
             TestItem(
                 type="test",
-                id=f"{self.id}.{test_case.name}" if self.id else test_case.name,
+                id=f"{self.source};{longname};{test_case.lineno}",
+                longname=longname,
                 label=test_case.name,
                 uri=self.source,
                 range=Range(
@@ -203,12 +206,14 @@ def generate(suite: TestSuite) -> TestItem:
 
             test: TestCase
             for test in suite.tests:
+                uri = str(Uri.from_path(test.source)) if test.source else None
                 children.append(
                     TestItem(
                         type="test",
-                        id=test.longname,
+                        id=f"{uri};{test.longname};{test.lineno}",
                         label=test.name,
-                        uri=str(Uri.from_path(test.source)) if test.source else None,
+                        longname=test.longname,
+                        uri=uri,
                         range=Range(
                             start=Position(line=test.lineno - 1, character=0),
                             end=Position(line=test.lineno - 1, character=0),
@@ -220,11 +225,13 @@ def generate(suite: TestSuite) -> TestItem:
             for s in suite.suites:
                 children.append(generate(s))
 
+            uri = str(Uri.from_path(suite.source)) if suite.source else None
             return TestItem(
                 type="suite",
-                id=suite.longname,
+                id=f"{uri};{suite.longname}",
                 label=suite.name,
-                uri=str(Uri.from_path(suite.source)) if suite.source else None,
+                longname=suite.longname,
+                uri=uri,
                 children=children,
                 range=Range(
                     start=Position(line=0, character=0),
@@ -270,17 +277,21 @@ def nonexisting_paths(paths: List[str]) -> Iterator[str]:
                     )
                     suite_item = [generate(suite)] if suite else []
 
+                    uri = str(Uri.from_path(Path.cwd()))
                     return [
                         TestItem(
                             type="workspace",
-                            id=Path.cwd().name,
+                            id=uri,
                             label=Path.cwd().name,
+                            longname=Path.cwd().name,
+                            uri=uri,
                             children=[
                                 *suite_item,
                                 *[
                                     TestItem(
                                         type="error",
-                                        id=i,
+                                        id=f"{Uri.from_path(i)};ERROR",
+                                        longname="error",
                                         label=i,
                                         error=f"Parsing '{i}' failed: File or directory to does not exist.",
                                     )
@@ -298,7 +309,15 @@ def nonexisting_paths(paths: List[str]) -> Iterator[str]:
             except (SystemExit, KeyboardInterrupt):
                 raise
             except BaseException as e:
-                return [TestItem(type="error", id=Path.cwd().name, label=Path.cwd().name, error=str(e))]
+                return [
+                    TestItem(
+                        type="error",
+                        id=str(Uri.from_path(Path.cwd())),
+                        longname="error",
+                        label=Path.cwd().name,
+                        error=str(e),
+                    )
+                ]
 
     @rpc_method(name="robot/discovering/getTestsFromWorkspace", param_type=GetAllTestsParams)
     @_logger.call
@@ -317,7 +336,7 @@ async def get_tests_from_workspace(
     @rpc_method(name="robot/discovering/getTestsFromDocument", param_type=GetTestsParams)
     @_logger.call
     async def get_tests_from_document(
-        self, text_document: TextDocumentIdentifier, id: Optional[str], *args: Any, **kwargs: Any
+        self, text_document: TextDocumentIdentifier, base_name: Optional[str], *args: Any, **kwargs: Any
     ) -> List[TestItem]:
         async def run() -> List[TestItem]:
             try:
@@ -328,7 +347,7 @@ async def run() -> List[TestItem]:
                             Uri(text_document.uri).to_path(), language_id="robotframework"
                         )
                     ),
-                    id,
+                    base_name,
                 )
             except (asyncio.CancelledError, SystemExit, KeyboardInterrupt):
                 raise

vscode-client/languageclientsmanger.ts

@@ -39,6 +39,7 @@ export interface RobotTestItem {
   uri?: string;
   children: RobotTestItem[] | undefined;
   label: string;
+  longname: string;
   description?: string;
   range?: Range;
   error?: string;
@@ -446,7 +447,7 @@ export class LanguageClientsManager {
 
   public async getTestsFromDocument(
     document: vscode.TextDocument,
-    id?: string,
+    base_name?: string,
     token?: vscode.CancellationToken
   ): Promise<RobotTestItem[] | undefined> {
     const client = await this.getLanguageClientForResource(document.uri);
@@ -459,13 +460,13 @@ export class LanguageClientsManager {
             "robot/discovering/getTestsFromDocument",
             {
               textDocument: { uri: document.uri.toString() },
-              id: id,
+              base_name: base_name,
             },
             token
           )
         : await client.sendRequest<RobotTestItem[]>("robot/discovering/getTestsFromDocument", {
             textDocument: { uri: document.uri.toString() },
-            id: id,
+            base_name: base_name,
           })) ?? undefined
     );
   }

vscode-client/testcontrollermanager.ts

@@ -332,7 +332,7 @@ export class TestControllerManager {
           const openDoc = vscode.workspace.textDocuments.find((d) => d.uri.toString() === item.uri?.toString());
 
           if (openDoc !== undefined) {
-            tests = await this.languageClientsManager.getTestsFromDocument(openDoc, robotItem.id, token);
+            tests = await this.languageClientsManager.getTestsFromDocument(openDoc, robotItem.longname, token);
           }
         }
         if (token?.isCancellationRequested) return;
@@ -587,7 +587,7 @@ export class TestControllerManager {
       }
     });
 
-    for (const [workspace, id] of included) {
+    for (const [workspace, ids] of included) {
       const runId = TestControllerManager.runId.next().value;
       this.testRuns.set(runId, run);
 
@@ -603,8 +603,12 @@ export class TestControllerManager {
       if (includedItems.length === 1 && includedItems[0] === workspaceItem && excluded.size === 0) {
         await DebugManager.runTests(workspace, [], [], [], runId, options);
       } else {
-        const includedInWs = id.map((i) => i.id);
-        const excludedInWs = excluded.get(workspace)?.map((i) => i.id) ?? [];
+        const includedInWs = ids.map((i) => this.findRobotItem(i)?.longname).filter((i) => i !== undefined) as string[];
+        const excludedInWs =
+          (excluded
+            .get(workspace)
+            ?.map((i) => this.findRobotItem(i)?.longname)
+            .filter((i) => i !== undefined) as string[]) ?? [];
         const suites = new Set<string>();
 
         for (const t of [...includedInWs, ...excludedInWs]) {