implement django tests with custom runner

pythonFiles/unittestadapter/django_runner.py

@@ -0,0 +1,47 @@
+import subprocess
+import os
+import pathlib
+import sys
+from typing import Union
+
+from pythonFiles.unittestadapter.execution import VSCodeUnittestError
+
+
+def django_execution_runner(start_dir: Union[str, None]):
+    # Get path to manage.py if set as an env var, otherwise use the default
+    manage_py_path = os.environ.get("MANAGE_PY_PATH")
+
+    if manage_py_path is None:
+        # Search for default manage.py path at the root of the workspace
+        if not start_dir:
+            print(
+                "Error running Django, no start_dir provided or value for MANAGE_PY_PATH"
+            )
+
+        cwd = os.path.abspath(start_dir)
+        manage_py_path = os.path.join(cwd, "manage.py")
+
+    try:
+        # 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)
+        custom_test_runner = "django_test_runner.CustomTestRunner"
+
+        # Build command to run 'python manage.py test'.
+        python_executable = sys.executable
+        command = [
+            python_executable,
+            "manage.py",
+            "test",
+            "--testrunner",
+            custom_test_runner,
+        ]
+        print("Running Django run tests with command: ", command)
+        try:
+            subprocess.run(" ".join(command), shell=True, check=True)
+        except subprocess.CalledProcessError as e:
+            print(f"Error running 'manage.py test': {e}")
+            raise VSCodeUnittestError(f"Error running 'manage.py test': {e}")
+    except Exception as e:
+        print(f"Error configuring Django test runner: {e}")
+        raise VSCodeUnittestError(f"Error configuring Django test runner: {e}")

pythonFiles/unittestadapter/django_test_runner.py

@@ -0,0 +1,21 @@
+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()
+        if kwargs["resultclass"] is not None:
+            raise ValueError(
+                "Resultclass already set, cannot use custom test runner design for VS Code compatibility."
+            )
+        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 django_execution_runner
 
 ErrorType = Union[
     Tuple[Type[BaseException], BaseException, TracebackType], Tuple[None, None, None]
@@ -30,6 +31,13 @@
 DEFAULT_PORT = 45454
 
 
+class VSCodeUnittestError(Exception):
+    """A custom exception class for pytest errors."""
+
+    def __init__(self, message):
+        super().__init__(message)
+
+
 class TestOutcomeEnum(str, enum.Enum):
     error = "error"
     failure = "failure"
@@ -103,7 +111,6 @@
         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 +135,16 @@
             "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):
@@ -303,36 +317,44 @@
 
     testPort = int(os.environ.get("TEST_PORT", DEFAULT_PORT))
     testUuid = os.environ.get("TEST_UUID")
-    if testPort is DEFAULT_PORT:
-        print(
-            "Error[vscode-unittest]: TEST_PORT is not set.",
-            " TEST_UUID = ",
-            testUuid,
-        )
-    if testUuid is None:
-        print(
-            "Error[vscode-unittest]: TEST_UUID is not set.",
-            " TEST_PORT = ",
-            testPort,
-        )
-        testUuid = "unknown"
-    if test_ids_from_buffer:
-        # Perform test execution.
-        payload = run_tests(
-            start_dir, test_ids_from_buffer, pattern, top_level_dir, testUuid
-        )
-    else:
-        cwd = os.path.abspath(start_dir)
-        status = TestExecutionStatus.error
+    try:
+        if testPort is DEFAULT_PORT:
+            raise VSCodeUnittestError(
+                "Error[vscode-unittest]: TEST_PORT is not set.",
+                " TEST_UUID = ",
+                testUuid,
+            )
+        if testUuid is None:
+            raise VSCodeUnittestError(
+                "Error[vscode-unittest]: TEST_UUID is not set.",
+                " TEST_PORT = ",
+                testPort,
+            )
+        if test_ids_from_buffer:
+            # Perform test execution.
+
+            # Check to see if we are running django tests.
+            django_test_enabled = os.environ.get("DJANGO_TEST_ENABLED")
+            print("DJANGO_TEST_ENABLED = ", django_test_enabled)
+            if django_test_enabled and django_test_enabled.lower() == "true":
+                # run django runner
+                print("running django runner")
+                django_execution_runner(start_dir)
+            else:
+                print("running unittest runner")
+                payload = run_tests(
+                    start_dir, test_ids_from_buffer, pattern, top_level_dir, testUuid
+                )
+        else:
+            raise VSCodeUnittestError("No test ids received from buffer")
+    except Exception as exception:
         payload: PayloadDict = {
-            "cwd": cwd,
-            "status": status,
-            "error": "No test ids received from buffer",
+            "cwd": os.path.abspath(start_dir) if start_dir else None,
+            "status": TestExecutionStatus.error,
+            "error": exception,
             "result": None,
         }
+        post_response(payload, testPort, "unknown")
+
     eot_payload: EOTPayloadDict = {"command_type": "execution", "eot": True}
-    if testUuid is None:
-        print("Error sending response, uuid unknown to python server.")
-        post_response(eot_payload, testPort, "unknown")
-    else:
-        post_response(eot_payload, testPort, testUuid)
+    post_response(eot_payload, testPort, testUuid)

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,