add dryrun debug option and test explorer profile closes #25

Author: d-biehl

package.json

@@ -528,6 +528,11 @@
                 "description": "Where to launch the debug target: internal console, integrated terminal, or external terminal.",
                 "default": "integratedTerminal"
               },
+              "dryRun": {
+                "type": "boolean",
+                "description": "Verifies test data and runs tests so that library keywords are not executed. Corresponds to the '--dryrun' option of the robot module.",
+                "default": false
+              },
               "python": {
                 "type": "string",
                 "description": "Specifies the python interpreter to use. If not specified, the python interpreter defined for the extension is used.",

robotcode/debugger/launcher/server.py

@@ -141,6 +141,7 @@ async def _launch(
         groupOutput: Optional[bool] = False,
         stopOnEntry: Optional[bool] = False,  # noqa: N803
         arguments: Optional[LaunchRequestArguments] = None,
+        dryRun: Optional[bool] = None,
         *_args: Any,
         **_kwargs: Any,
     ) -> None:
@@ -179,6 +180,9 @@ async def _launch(
 
         run_args += ["--"]
 
+        if dryRun:
+            run_args += ["--dryrun"]
+
         if outputDir:
             run_args += ["-d", outputDir]
 

robotcode/debugger/listeners.py

@@ -1,4 +1,5 @@
 from dataclasses import dataclass
+from pathlib import Path
 from typing import Any, Dict, Iterator, List, Optional, Union, cast
 
 from .dap_types import Event, Model
@@ -8,6 +9,7 @@
 @dataclass
 class RobotExecutionEventBody(Model):
     type: str
+    id: str
     attributes: Optional[Dict[str, Any]] = None
     failed_keywords: Optional[List[Dict[str, Any]]] = None
 
@@ -23,7 +25,15 @@ def __init__(self, no_debug: bool = False) -> None:
 
     def start_suite(self, name: str, attributes: Dict[str, Any]) -> None:
         Debugger.instance().send_event(
-            self, Event(event="robotStarted", body=RobotExecutionEventBody(type="suite", attributes=dict(attributes)))
+            self,
+            Event(
+                event="robotStarted",
+                body=RobotExecutionEventBody(
+                    type="suite",
+                    id=f"{attributes.get('source', '')};{attributes.get('longname', '')}",
+                    attributes=dict(attributes),
+                ),
+            ),
         )
 
         Debugger.instance().start_output_group(name, attributes, "SUITE")
@@ -41,7 +51,10 @@ def end_suite(self, name: str, attributes: Dict[str, Any]) -> None:
             Event(
                 event="robotEnded",
                 body=RobotExecutionEventBody(
-                    type="suite", attributes=dict(attributes), failed_keywords=self.failed_keywords
+                    type="suite",
+                    attributes=dict(attributes),
+                    id=f"{attributes.get('source', '')};{attributes.get('longname', '')}",
+                    failed_keywords=self.failed_keywords,
                 ),
             ),
         )
@@ -50,7 +63,16 @@ def start_test(self, name: str, attributes: Dict[str, Any]) -> None:
         self.failed_keywords = None
 
         Debugger.instance().send_event(
-            self, Event(event="robotStarted", body=RobotExecutionEventBody(type="test", attributes=dict(attributes)))
+            self,
+            Event(
+                event="robotStarted",
+                body=RobotExecutionEventBody(
+                    type="test",
+                    id=f"{attributes.get('source', '')};{attributes.get('longname', '')};"
+                    f"{attributes.get('lineno', 0)}",
+                    attributes=dict(attributes),
+                ),
+            ),
         )
 
         Debugger.instance().start_output_group(name, attributes, "TEST")
@@ -67,7 +89,11 @@ def end_test(self, name: str, attributes: Dict[str, Any]) -> None:
             Event(
                 event="robotEnded",
                 body=RobotExecutionEventBody(
-                    type="test", attributes=dict(attributes), failed_keywords=self.failed_keywords
+                    type="test",
+                    id=f"{attributes.get('source', '')};{attributes.get('longname', '')};"
+                    f"{attributes.get('lineno', 0)}",
+                    attributes=dict(attributes),
+                    failed_keywords=self.failed_keywords,
                 ),
             ),
         )
@@ -153,6 +179,9 @@ def close(self) -> None:
 class ListenerV3:
     ROBOT_LISTENER_API_VERSION = "3"
 
+    def __init__(self) -> None:
+        self._event_sended = False
+
     def start_suite(self, data: Any, result: Any) -> None:
         from robot.running import TestCase, TestSuite
 
@@ -163,9 +192,15 @@ def enqueue(item: Union[TestSuite, TestCase]) -> Iterator[str]:
                 for s in item.tests:
                     yield from enqueue(s)
 
-            yield item.longname
+                yield f"{Path(item.source).resolve()};{item.longname}"
+                return
 
-        items = [i for i in enqueue(cast(TestSuite, data))]
+            yield f"{Path(item.source).resolve()};{item.longname};{item.lineno}"
+
+        if self._event_sended:
+            return
+
+        items = list(reversed([i for i in enqueue(cast(TestSuite, data))]))
 
         Debugger.instance().send_event(
             self,
@@ -175,6 +210,8 @@ def enqueue(item: Union[TestSuite, TestCase]) -> Iterator[str]:
             ),
         )
 
+        self._event_sended = True
+
     def end_suite(self, data: Any, result: Any) -> None:
         pass
 

robotcode/language_server/robotframework/parts/discovering.py

@@ -61,6 +61,7 @@ class FindTestCasesVisitor(AsyncVisitor):
     async def get(self, source: DocumentUri, model: ast.AST, base_name: Optional[str]) -> List[TestItem]:
         self._results: List[TestItem] = []
         self.source = source
+        self.path = Uri(source).to_path().resolve()
         self.base_name = base_name
         await self.visit(model)
         return self._results
@@ -80,7 +81,7 @@ async def visit_TestCase(self, node: ast.AST) -> None:  # noqa: N802
         self._results.append(
             TestItem(
                 type="test",
-                id=f"{self.source};{longname};{test_case.lineno}",
+                id=f"{self.path};{longname};{test_case.lineno}",
                 longname=longname,
                 label=test_case.name,
                 uri=self.source,
@@ -206,14 +207,13 @@ 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=f"{uri};{test.longname};{test.lineno}",
+                        id=f"{Path(test.source).resolve()};{test.longname};{test.lineno}",
                         label=test.name,
                         longname=test.longname,
-                        uri=uri,
+                        uri=str(Uri.from_path(test.source)) if test.source else None,
                         range=Range(
                             start=Position(line=test.lineno - 1, character=0),
                             end=Position(line=test.lineno - 1, character=0),
@@ -225,13 +225,12 @@ 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=f"{uri};{suite.longname}",
+                id=f"{Path(suite.source).resolve()};{suite.longname}",
                 label=suite.name,
                 longname=suite.longname,
-                uri=uri,
+                uri=str(Uri.from_path(suite.source)) if suite.source else None,
                 children=children,
                 range=Range(
                     start=Position(line=0, character=0),
@@ -277,20 +276,19 @@ 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=uri,
+                            id=str(Path.cwd()),
                             label=Path.cwd().name,
                             longname=Path.cwd().name,
-                            uri=uri,
+                            uri=str(Uri.from_path(Path.cwd())),
                             children=[
                                 *suite_item,
                                 *[
                                     TestItem(
                                         type="error",
-                                        id=f"{Uri.from_path(i)};ERROR",
+                                        id=f"{i};ERROR",
                                         longname="error",
                                         label=i,
                                         error=f"Parsing '{i}' failed: File or directory to does not exist.",

vscode-client/debugmanager.ts

@@ -338,7 +338,8 @@ export class DebugManager {
     included: string[],
     excluded: string[],
     runId?: string,
-    options?: vscode.DebugSessionOptions
+    options?: vscode.DebugSessionOptions,
+    dryRun?: boolean
   ): Promise<void> {
     const config = vscode.workspace.getConfiguration(CONFIG_SECTION, folder);
 
@@ -379,6 +380,7 @@ export class DebugManager {
           args: args,
           console: config.get("debug.defaultConsole", "integratedTerminal"),
           runId: runId,
+          dryRun,
         },
       },
       options

vscode-client/testcontrollermanager.ts

@@ -26,6 +26,7 @@ type RobotEventType = "suite" | "test" | "keyword" | string;
 
 interface RobotExecutionEvent {
   type: RobotEventType;
+  id: string;
   attributes: RobotExecutionAttributes | undefined;
   failedKeywords: RobotExecutionAttributes[] | undefined;
 }
@@ -77,6 +78,8 @@ export class TestControllerManager {
   public readonly testController: vscode.TestController;
   public readonly runProfile: vscode.TestRunProfile;
   public readonly debugProfile: vscode.TestRunProfile;
+  public readonly dryRunProfile: vscode.TestRunProfile;
+  public readonly dryRunDebugProfile: vscode.TestRunProfile;
   private readonly refreshMutex = new Mutex();
   private readonly debugSessions = new Set<vscode.DebugSession>();
   private readonly didChangedTimer = new Map<string, DidChangeEntry>();
@@ -91,15 +94,31 @@ export class TestControllerManager {
     this.testController = vscode.tests.createTestController("robotCode.RobotFramework", "RobotFramework");
 
     this.runProfile = this.testController.createRunProfile(
-      "Run Tests",
+      "Run",
       vscode.TestRunProfileKind.Run,
-      async (request, token) => this.runTests(request, token)
+      async (request, token) => this.runTests(request, token),
+      true
+    );
+
+    this.dryRunProfile = this.testController.createRunProfile(
+      "Dry Run",
+      vscode.TestRunProfileKind.Run,
+      async (request, token) => this.runTests(request, token, true),
+      false
     );
 
     this.debugProfile = this.testController.createRunProfile(
       "Debug",
       vscode.TestRunProfileKind.Debug,
-      async (request, token) => this.runTests(request, token)
+      async (request, token) => this.runTests(request, token),
+      true
+    );
+
+    this.dryRunDebugProfile = this.testController.createRunProfile(
+      "Dry Debug",
+      vscode.TestRunProfileKind.Debug,
+      async (request, token) => this.runTests(request, token, true),
+      false
     );
 
     this.testController.resolveHandler = async (item) => {
@@ -563,7 +582,11 @@ export class TestControllerManager {
 
   private static readonly runId = TestControllerManager.runIdGenerator();
 
-  public async runTests(request: vscode.TestRunRequest, token: vscode.CancellationToken): Promise<void> {
+  public async runTests(
+    request: vscode.TestRunRequest,
+    token: vscode.CancellationToken,
+    dryRun?: boolean
+  ): Promise<void> {
     let includedItems: vscode.TestItem[] = [];
 
     if (request.include) {
@@ -601,7 +624,7 @@ export class TestControllerManager {
       const workspaceItem = this.findTestItemByUri(workspace.uri.toString());
 
       if (includedItems.length === 1 && includedItems[0] === workspaceItem && excluded.size === 0) {
-        await DebugManager.runTests(workspace, [], [], [], runId, options);
+        await DebugManager.runTests(workspace, [], [], [], runId, options, dryRun);
       } else {
         const includedInWs = ids.map((i) => this.findRobotItem(i)?.longname).filter((i) => i !== undefined) as string[];
         const excludedInWs =
@@ -621,7 +644,7 @@ export class TestControllerManager {
             suites.add(t);
           }
         }
-        await DebugManager.runTests(workspace, Array.from(suites), includedInWs, excludedInWs, runId, options);
+        await DebugManager.runTests(workspace, Array.from(suites), includedInWs, excludedInWs, runId, options, dryRun);
       }
     }
   }
@@ -671,7 +694,7 @@ export class TestControllerManager {
     const run = this.testRuns.get(runId);
 
     if (run !== undefined) {
-      const item = this.findTestItemById(event.attributes.longname);
+      const item = this.findTestItemById(event.id);
       if (item !== undefined) {
         run.started(item);
       }
@@ -696,7 +719,7 @@ export class TestControllerManager {
     const run = this.testRuns.get(runId);
 
     if (run !== undefined) {
-      const item = this.findTestItemById(event.attributes.longname);
+      const item = this.findTestItemById(event.id);
       if (item !== undefined) {
         switch (event.attributes.status) {
           case "PASS":