python test driver: on Windows, spawn a separate Python

This is needed so we can properly remove the test dir
once the test is done, without risking that the Python
interpreter has a handle on files there.

Slightly improve the semantics for the wait factor.
Improve error reporting slightly.
Fix creation of URIs with respect to drive letters.

Follow-up on #1462

Author: setton

testsuite/drivers/lsp_ada_requests.py

@@ -8,7 +8,7 @@
 # TODO: use a library such as pytest-lsp to support most requests
 
 
-def initialize(workspacefolder="."):
+def initialize(workspacefolder=URI(".")):
     """This mimics what vs code sends at the moment"""
     return LSPMessage(
         {

testsuite/drivers/lsp_python_driver.py

@@ -73,13 +73,13 @@
 DEBUG_MODE = False
 
 
-def set_debug_mode(mode : bool = True):
+def set_debug_mode(mode: bool = True):
     """Set the debug mode."""
     global DEBUG_MODE
     DEBUG_MODE = mode
 
 
-def set_wait_factor(factor : float):
+def set_wait_factor(factor: float):
     """Set the wait factor."""
     global RLIMIT_SECONDS
     global RESPONSE_TIMEOUT
@@ -93,7 +93,7 @@ def __init__(
         self,
         cl: str | list[str] | None = "ada_language_server",
         working_dir: str = ".",
-        env: dict | None = None
+        env: dict | None = None,
     ):
         """Launch an LSP server and provide a way to send messages to it.
         cl is the command line to launch the LSP server.
@@ -119,8 +119,9 @@ def __init__(
         self.wd = working_dir
 
         # Kill the server when we reach this time
-        self.kill_me_at = time.time() + RLIMIT_SECONDS * (
-            1 + os.environ.get("ALS_WAIT_FACTOR", 0))
+        self.kill_me_at = time.time() + int(
+            RLIMIT_SECONDS * os.environ.get("ALS_WAIT_FACTOR", 1.0)
+        )
 
         # This contains either None or a timestamp. If a timestamp,
         # then the process should be killed after 2 seconds after this.
@@ -148,7 +149,6 @@ def __init__(
         if DEBUG_MODE:
             self.debug_here()
 
-
     def kill_task(self):
         while True:
             time.sleep(0.2)
@@ -178,7 +178,7 @@ def receive_task(self):
                 break
             if not header.startswith("Content-Length:"):
                 continue
-            length = int(header[len("Content-Length:"):])
+            length = int(header[len("Content-Length:") :])
 
             # TODO: Add support for "Content-Type" header
 
@@ -199,9 +199,7 @@ def receive_task(self):
 
             time.sleep(0.01)
 
-    def send(
-        self, message: LSPMessage, expect_response=True
-    ) -> LSPResponse | None:
+    def send(self, message: LSPMessage, expect_response=True) -> LSPResponse | None:
         """Send a message to the LSP server.
         If expect_response is True, wait for a response for at most timeout seconds.
         Return the response if any, or None if no response
@@ -257,12 +255,13 @@ def shutdown(self):
         # If errors were found, capture a replay file.
         # Compute the replay dir based on this file
         replay_dir = os.path.join(
-            os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
-            "replays"
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "replays"
         )
         # Create the directory if it doesn't exist
         os.makedirs(replay_dir, exist_ok=True)
-        replay_file = os.path.join(replay_dir, os.path.basename(self.wd) + "_replay.txt")
+        replay_file = os.path.join(
+            replay_dir, os.path.basename(self.wd) + "_replay.txt"
+        )
         self.errors.append(f"Replay file written to {replay_file}")
 
         # Write a "replay.txt" replay file

testsuite/drivers/lsp_types.py

@@ -127,7 +127,7 @@ def assertLocationsList(self, expected: list[(str, int)]):
         with line_number being 1-based.
         """
         if not isinstance(self.from_dict, list):
-            raise AssertionError("The response does not contain a list")
+            raise AssertionError(f"Expected a list, but received: {self.from_dict}")
 
         # Extract the locations from the response
         locations = []
@@ -161,5 +161,10 @@ def URI(filename: str) -> str:
     """Return a URI for the given filename."""
     # Get the absolute path for filename
     abs_path = os.path.abspath(filename)
+    # Replace the backslashes by slashes
+    abs_path = abs_path.replace("\\", "/")
+    # Replace "C:" by "/C%3A" for Windows paths
+    if abs_path[1] == ":":
+        abs_path = "/" + abs_path[0] + "%3A" + abs_path[2:]
     # Convert it to a URI
     return "file://" + abs_path

testsuite/drivers/python_driver.py

@@ -1,6 +1,7 @@
 import importlib.util
 import inspect
 import os
+import sys
 
 from drivers import ALSTestDriver
 from drivers.lsp_python_driver import set_debug_mode, set_wait_factor
@@ -31,25 +32,69 @@ def run(self):
 
         # If there is a "test.py", evaluate it
         if os.path.exists(os.path.join(wd, "test.py")):
-            # Load test.py as a module
-            python_file = os.path.join(wd, "test.py")
-            spec = importlib.util.spec_from_file_location("module.name", python_file)
-            module = importlib.util.module_from_spec(spec)
-            spec.loader.exec_module(module)
-
-            # Look for functions with the decorator @simple_test and run them
-            errors = [
-                f"no function with @simple_test or @complex_test found in {python_file}"
+            # Spawn a separate executable for the test. The reason
+            # for this is that we want to be able to remove the
+            # test directory after the test is done, but we can't
+            # do that under Windows if this Python driver still has
+            # a handle on the module file.
+            cmd = [
+                sys.executable,
+                __file__,
+                os.path.join(wd, "test.py"),
+                self.env.als,
+                self.env.als_home,
+                str(self.env.wait_factor),
             ]
-
-            for _, obj in inspect.getmembers(module):
-                if inspect.isfunction(obj) and (
-                    hasattr(obj, "simple_test") or hasattr(obj, "complex_test")
-                ):
-                    errors = obj(wd)
-
-            if len(errors) > 0:
-                self.result.log += "\n".join(errors)
-                raise TestAbortWithFailure("Test returned errors")
+            self.shell(
+                cmd,
+                cwd=wd,
+                env={
+                    "PYTHONPATH": os.path.dirname(os.path.dirname(__file__)),
+                },
+                ignore_environ=False,
+            )
         else:
             raise TestAbortWithFailure("No test.py found in %s" % wd)
+
+
+def run_a_module(
+    test_py_path: str, als: str, als_home: str, wait_factor: float, debug: bool
+):
+    if debug:
+        set_debug_mode(True)
+
+    set_wait_factor(wait_factor)
+
+    wd = os.path.dirname(test_py_path)
+
+    # Load test.py as a module
+    spec = importlib.util.spec_from_file_location("module.name", test_py_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    # Look for functions with the decorator @simple_test and run them
+    errors = [f"no function with @simple_test or @complex_test found in {test_py_path}"]
+
+    for _, obj in inspect.getmembers(module):
+        if inspect.isfunction(obj) and (
+            hasattr(obj, "simple_test") or hasattr(obj, "complex_test")
+        ):
+            errors = obj(wd)
+
+    if len(errors) > 0:
+        print("\n".join(errors))
+        sys.exit(1)
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Run a Python test driver")
+    parser.add_argument("test", help="The test to load")
+    parser.add_argument("als", help="The ALS program to run")
+    parser.add_argument("als_home", help="The ALS home directory")
+    parser.add_argument("wait_factor", type=float, help="The wait factor")
+    parser.add_argument("--debug", action="store_true", help="Enable debug mode")
+    args = parser.parse_args()
+    run_a_module(args.test, args.als, args.als_home, args.wait_factor, args.debug)