implement django tests with custom runner

Author: eleanorjboyd

pythonFiles/unittestadapter/django_runner.py

@@ -0,0 +1,107 @@
+import subprocess
+import os
+import pathlib
+import re
+import sys
+
+
+def find_settings_module(path_to_manage_py):
+    dj_settings_module = None
+    with open(path_to_manage_py, "r") as manage_py:
+        pattern = r"^os\.environ\.setdefault\((['\"])(DJANGO_SETTINGS_MODULE)\1, (['\"])(?P<settings_path>[\w.]+)\3\)$"
+        for line in manage_py.readlines():
+            match_result = re.match(pattern, line.strip())
+            if match_result is not None:
+                dj_settings_module = match_result.groupdict().get("settings_path", None)
+                break
+    return dj_settings_module
+
+
+def configure_test_runner(path_to_manage_py):
+    # Getting the DJANGO_SETTINGS_MODULE from manage.py
+    dj_settings_module = find_settings_module(path_to_manage_py)
+    if dj_settings_module is None:
+        raise Exception("DJANGO_SETTINGS_MODULE not found in manage.py")
+
+    # Construct the path to the settings.py file
+    settings_file = os.path.join(
+        os.path.dirname(dj_settings_module.replace(".", os.sep)), "settings.py"
+    )
+    # Check if the settings.py file exists
+    if not os.path.exists(settings_file):
+        raise Exception(f"settings.py file not found at {settings_file}")
+    # Read the content of the existing settings.py file
+    with open(settings_file, "r") as f:
+        original_settings_content = f.read()
+
+    # Check if TEST_RUNNER is already defined in the settings
+    if "TEST_RUNNER" in original_settings_content:
+        print("TEST_RUNNER is already defined in settings.py. but continuing")
+        print("settings_content: ", original_settings_content)
+    else:
+        # Add the custom test runner to the settings.py file
+
+        # Get path to the custom_test_runner.py parent folder, add to sys.path
+        custom_test_runner_dir = pathlib.Path(__file__).parent
+        sys.path.insert(0, custom_test_runner_dir)
+
+        # Import your custom test runner class
+        # from execution import UnittestTestResult
+
+        # Set the TEST_RUNNER setting
+        setting_content = original_settings_content + (
+            "\n\n"
+            + "# Use custom test runner\n"
+            + "import sys\n"
+            + f"sys.path.insert(0, '{custom_test_runner_dir}')\n"
+            + f"TEST_RUNNER = 'django_test_runner.CustomTestRunner'\n"
+        )
+
+        # Write the updated content back to the settings.py file
+        with open(settings_file, "w") as f:
+            f.write(setting_content)
+
+        print("TEST_RUNNER setting added to settings.py.")
+    return settings_file, original_settings_content
+
+
+# Define a cleanup method
+def cleanup(settings_file, original_settings_content):
+    # Restore the original content of settings.py
+    with open(settings_file, "w") as f:
+        f.write(original_settings_content)
+    print("Settings.py has been restored to its original state.")
+
+    return True
+
+
+def runner():
+    # Define the path to your manage.py file
+    # could get path to manage.py from environment variable
+    # get Django test boolean
+    django_test_enabled = os.environ.get("DJANGO_TEST_ENABLED")
+    manage_py_path = os.environ.get("MANAGE_PY_PATH")
+
+    if (
+        django_test_enabled is not None
+        and django_test_enabled.lower() == "true"
+        and manage_py_path is not None
+    ):
+        # attempt to configure and run tests as django tests
+        try:
+            settings_file, original_settings_content = configure_test_runner(
+                manage_py_path
+            )
+            # Command to run 'python manage.py test'
+            python_executable = sys.executable
+            command = [python_executable, "manage.py", "test"]
+            print("running test command: ", command)
+            # Run the command
+            try:
+                subprocess.run(" ".join(command), shell=True, check=True)
+                # Cleanup
+                cleanup(settings_file, original_settings_content)
+            except subprocess.CalledProcessError as e:
+                print(f"Error running 'manage.py test': {e}")
+        except Exception as e:
+            print(f"Error configuring Django test runner: {e}")

pythonFiles/unittestadapter/django_test_runner.py

@@ -0,0 +1,17 @@
+from django.test.runner import DiscoverRunner
+import sys
+import os
+import pathlib
+
+script_dir = pathlib.Path(__file__).parent
+sys.path.append(os.fspath(script_dir))
+
+from execution import UnittestTestResult
+
+
+class CustomTestRunner(DiscoverRunner):
+    def get_test_runner_kwargs(self):
+        print("get_test_runner_kwargs")
+        kwargs = super().get_test_runner_kwargs()
+        kwargs["resultclass"] = UnittestTestResult
+        return kwargs

pythonFiles/unittestadapter/execution.py

@@ -20,6 +20,7 @@
 from testing_tools import process_json_util, socket_manager
 from typing_extensions import Literal, NotRequired, TypeAlias, TypedDict
 from unittestadapter.utils import parse_unittest_args
+from django_runner import runner
 
 ErrorType = Union[
     Tuple[Type[BaseException], BaseException, TracebackType], Tuple[None, None, None]
@@ -103,7 +104,6 @@ def formatResult(
         subtest: Union[unittest.TestCase, None] = None,
     ):
         tb = None
-
         message = ""
         # error is a tuple of the form returned by sys.exc_info(): (type, value, traceback).
         if error is not None:
@@ -128,9 +128,16 @@ def formatResult(
             "subtest": subtest.id() if subtest else None,
         }
         self.formatted[test_id] = result
-        if testPort == 0 or testUuid == 0:
-            print("Error sending response, port or uuid unknown to python server.")
-        send_run_data(result, testPort, testUuid)
+        testPort2 = int(os.environ.get("TEST_PORT", DEFAULT_PORT))
+        testUuid2 = os.environ.get("TEST_UUID")
+        if testPort2 == 0 or testUuid2 == 0:
+            print(
+                "Error sending response, port or uuid unknown to python server.",
+                testPort,
+                testUuid,
+            )
+
+        send_run_data(result, testPort2, testUuid2)
 
 
 class TestExecutionStatus(str, enum.Enum):
@@ -318,9 +325,19 @@ def post_response(
         testUuid = "unknown"
     if test_ids_from_buffer:
         # Perform test execution.
-        payload = run_tests(
-            start_dir, test_ids_from_buffer, pattern, top_level_dir, testUuid
-        )
+
+        # get django test boolean
+        django_test_enabled = os.environ.get("DJANGO_TEST_ENABLED")
+        print("DJANGO_TEST_ENABLED = ", django_test_enabled)
+        if django_test_enabled:
+            # run django runner
+            print("running django runner")
+            runner()
+        else:
+            print("running unittest runner")
+            payload = run_tests(
+                start_dir, test_ids_from_buffer, pattern, top_level_dir, testUuid
+            )
     else:
         cwd = os.path.abspath(start_dir)
         status = TestExecutionStatus.error

src/client/testing/testController/common/server.ts

@@ -184,14 +184,24 @@ export class PythonTestServer implements ITestServer, Disposable {
         mutableEnv.TEST_PORT = this.getPort().toString();
         mutableEnv.RUN_TEST_IDS_PORT = runTestIdPort;
 
+        const isRun = runTestIdPort !== undefined;
+
+        // NEEDS TO BE UNCOMMENTED TO GET DJANGO WORKING
+        // if (isRun) {
+        //     mutableEnv.DJANGO_TEST_ENABLED = 'true';
+        //     mutableEnv.MANAGE_PY_PATH = [options.cwd, 'manage.py'].join('/');
+        //     console.log('DJANGO_TEST_ENABLED', mutableEnv.DJANGO_TEST_ENABLED);
+        //     console.log('MANAGE_PY_PATH', mutableEnv.MANAGE_PY_PATH);
+        // }
+
         const spawnOptions: SpawnOptions = {
             token: options.token,
             cwd: options.cwd,
             throwOnStdErr: true,
             outputChannel: options.outChannel,
             env: mutableEnv,
         };
-        const isRun = runTestIdPort !== undefined;
+
         // Create the Python environment in which to execute the command.
         const creationOptions: ExecutionFactoryCreateWithEnvironmentOptions = {
             allowEnvironmentFetchExceptions: false,