optimize starting of tests

Author: d-biehl

robotcode/language_server/robotframework/parts/discovering.py

@@ -28,6 +28,7 @@
 class GetAllTestsParams(Model):
     workspace_folder: str
     paths: Optional[List[str]]
+    suites: Optional[List[str]] = None
 
 
 @dataclass(repr=False)
@@ -97,7 +98,9 @@ class DiscoveringProtocolPart(RobotLanguageServerProtocolPart):
     def __init__(self, parent: RobotLanguageServerProtocol) -> None:
         super().__init__(parent)
 
-    def _get_tests_from_workspace(self, workspace_folder: Path, paths: Optional[List[str]]) -> List[TestItem]:
+    def _get_tests_from_workspace(
+        self, workspace_folder: Path, paths: Optional[List[str]], suites: Optional[List[str]]
+    ) -> List[TestItem]:
         from robot.output.logger import LOGGER
         from robot.running import TestCase, TestSuite
 
@@ -166,7 +169,11 @@ def nonexisting_paths(paths: List[str]) -> Iterator[str]:
                                 yield str(p)
 
                     valid_paths = [i for i in normalize_paths(paths)]
-                    suite: Optional[TestSuite] = TestSuite.from_file_system(*valid_paths) if valid_paths else None
+                    suite: Optional[TestSuite] = (
+                        TestSuite.from_file_system(*valid_paths, included_suites=suites if suites else None)
+                        if valid_paths
+                        else None
+                    )
                     suite_item = [generate(suite)] if suite else []
 
                     return [
@@ -201,10 +208,11 @@ async def get_tests_from_workspace(
         self,
         workspace_folder: str,
         paths: Optional[List[str]],
+        suites: Optional[List[str]],
         *args: Any,
         **kwargs: Any,
     ) -> List[TestItem]:
-        return await run_in_thread(self._get_tests_from_workspace, Uri(workspace_folder).to_path(), paths)
+        return await run_in_thread(self._get_tests_from_workspace, Uri(workspace_folder).to_path(), paths, suites)
 
     @rpc_method(name="robot/discovering/getTestsFromDocument", param_type=GetTestsParams)
     @_logger.call

vscode-client/debugmanager.ts

@@ -40,11 +40,11 @@ class RobotCodeDebugConfigurationProvider implements vscode.DebugConfigurationPr
     if (!debugConfiguration.python) debugConfiguration.python = this.pythonManager.getPythonCommand(folder);
 
     debugConfiguration.robotPythonPath = [
-      ...config.get<Array<string>>("robot.pythonPath", []),
+      ...config.get<string[]>("robot.pythonPath", []),
       ...(debugConfiguration.robotPythonPath ?? []),
     ];
 
-    debugConfiguration.args = [...config.get<Array<string>>("robot.args", []), ...(debugConfiguration.args ?? [])];
+    debugConfiguration.args = [...config.get<string[]>("robot.args", []), ...(debugConfiguration.args ?? [])];
 
     debugConfiguration.variables = {
       ...config.get<{ [Key: string]: unknown }>("robot.variables", {}),
@@ -112,9 +112,9 @@ class RobotCodeDebugAdapterDescriptorFactory implements vscode.DebugAdapterDescr
           throw new Error("Can't get a valid python command.");
         }
 
-        const debugAdapterArgs = config.get<Array<string>>("debugAdapter.args", []);
+        const debugAdapterArgs = config.get<string[]>("debugAdapter.args", []);
 
-        const args: Array<string> = ["-u", this.pythonManager.pythonDebugAdapterMain, "--mode", "stdio"].concat(
+        const args: string[] = ["-u", this.pythonManager.pythonDebugAdapterMain, "--mode", "stdio"].concat(
           debugAdapterArgs
         );
 
@@ -270,44 +270,51 @@ export class DebugManager {
 
   static async runTests(
     folder: vscode.WorkspaceFolder,
+    suites: string[],
     included: string[],
     excluded: string[],
     runId?: string,
     options?: vscode.DebugSessionOptions
   ): Promise<void> {
-    if (included.length) {
-      const config = vscode.workspace.getConfiguration(CONFIG_SECTION, folder);
+    const config = vscode.workspace.getConfiguration(CONFIG_SECTION, folder);
+
+    const args = [];
+
+    for (const s of suites) {
+      args.push("--suite");
+      args.push(s);
+    }
 
-      const args = [];
+    if (included.length > 0) {
       args.push("--prerunmodifier");
 
       args.push(`robotcode.debugger.modifiers.ByLongName:${included.join(":")}`);
+    }
 
-      if (excluded.length > 0) {
-        args.push("--prerunmodifier");
+    if (excluded.length > 0) {
+      args.push("--prerunmodifier");
 
-        args.push(`robotcode.debugger.modifiers.ExcludedByLongName:${excluded.join(":")}`);
-      }
-      const template = config.get("debug.defaultConfiguration", {});
+      args.push(`robotcode.debugger.modifiers.ExcludedByLongName:${excluded.join(":")}`);
+    }
+    const template = config.get("debug.defaultConfiguration", {});
 
-      await vscode.debug.startDebugging(
-        folder,
-        {
-          ...template,
-          ...{
-            type: "robotcode",
-            name: "robotcode: Run Tests",
-            request: "launch",
-            cwd: folder?.uri.fsPath,
-            target: ".",
-            args: args,
-            console: config.get("debug.defaultConsole", "integratedTerminal"),
-            runId: runId,
-          },
+    await vscode.debug.startDebugging(
+      folder,
+      {
+        ...template,
+        ...{
+          type: "robotcode",
+          name: "robotcode: Run Tests",
+          request: "launch",
+          cwd: folder?.uri.fsPath,
+          target: ".",
+          args: args,
+          console: config.get("debug.defaultConsole", "integratedTerminal"),
+          runId: runId,
         },
-        options
-      );
-    }
+      },
+      options
+    );
   }
 
   static async OnDebugpyStarted(

vscode-client/languageclientsmanger.ts

@@ -179,9 +179,9 @@ export class LanguageClientsManager {
       throw new Error("Can't find a valid python executable.");
     }
 
-    const serverArgs = config.get<Array<string>>("languageServer.args", []);
+    const serverArgs = config.get<string[]>("languageServer.args", []);
 
-    const args: Array<string> = [
+    const args: string[] = [
       "-u",
 
       // "-m",
@@ -193,7 +193,7 @@ export class LanguageClientsManager {
       this.pythonManager.pythonLanguageServerMain,
     ];
 
-    const debug_args: Array<string> = ["--log"];
+    const debug_args: string[] = ["--log"];
 
     const transport = { stdio: TransportKind.stdio, pipe: TransportKind.pipe, socket: TransportKind.socket }[mode];
 
@@ -405,7 +405,8 @@ export class LanguageClientsManager {
 
   public async getTestsFromWorkspace(
     workspaceFolder: vscode.WorkspaceFolder,
-    paths?: Array<string>,
+    paths?: string[],
+    suites?: string[],
     token?: vscode.CancellationToken
   ): Promise<RobotTestItem[] | undefined> {
     const client = await this.getLanguageClientForResource(workspaceFolder.uri);
@@ -419,6 +420,7 @@ export class LanguageClientsManager {
             {
               workspaceFolder: workspaceFolder.uri.toString(),
               paths: paths ?? ["."],
+              suites,
             },
             token
           )

vscode-client/testcontrollermanager.ts

@@ -332,7 +332,7 @@ export class TestControllerManager {
         if (!this.robotTestItems.has(workspace) && this.robotTestItems.get(workspace) === undefined) {
           this.robotTestItems.set(
             workspace,
-            await this.languageClientsManager.getTestsFromWorkspace(workspace, [], token)
+            await this.languageClientsManager.getTestsFromWorkspace(workspace, [], undefined, token)
           );
         }
 
@@ -550,13 +550,27 @@ export class TestControllerManager {
         };
       }
 
-      await DebugManager.runTests(
-        workspace,
-        id.map((i) => i.id),
-        excluded.get(workspace)?.map((i) => i.id) ?? [],
-        runId,
-        options
-      );
+      const workspaceItem = this.findTestItemByUri(workspace.uri.toString());
+
+      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 suites = new Set<string>();
+
+        for (const t of [...includedInWs, ...excludedInWs]) {
+          const testItem = this.findTestItemById(t);
+          if (!testItem?.canResolveChildren) {
+            if (testItem?.parent) {
+              suites.add(testItem.parent.id);
+            }
+          } else {
+            suites.add(t);
+          }
+        }
+        await DebugManager.runTests(workspace, Array.from(suites), includedInWs, excludedInWs, runId, options);
+      }
     }
   }