Tester support for Javascript programming language.

README.md

@@ -128,6 +128,8 @@ The autotester currently supports testers for the following languages and testin
     - [`tasty-quickcheck`](https://hackage.haskell.org/package/tasty-quickcheck)
 - `java`
     - [JUnit](https://junit.org/junit4/)
+- `js` (JavaScript)
+    - [Jest](https://jestjs.io/)
 - `py` (python3)
     - [Unittest](https://docs.python.org/3/library/unittest.html)
     - [Pytest](https://docs.pytest.org/en/latest/)
@@ -155,6 +157,8 @@ Installing each tester will also install the following additional packages (syst
     - tasty-quickcheck (cabal package)
 - `java`
     - openjdk-8-jdk
+- `js` (JavaScript)
+    - none
 - `py` (python3)
     - none
 - `pyta`

server/.dockerfiles/Dockerfile

@@ -44,6 +44,7 @@ RUN mkdir -p ${WORKSPACE} && chown ${LOGIN_USER} ${WORKSPACE} && \
 # in markus-autotesting/server.
 COPY --parents \
     ./autotest_server/testers/java/requirements.system \
+    ./autotest_server/testers/js/requirements.system \
     ./autotest_server/testers/haskell/requirements.system \
     ./autotest_server/testers/r/requirements.system \
     ./autotest_server/testers/racket/requirements.system \

server/autotest_server/testers/__init__.py

@@ -3,7 +3,7 @@
 import importlib
 import os
 
-_TESTERS = ("ai", "custom", "haskell", "java", "jupyter", "py", "pyta", "r", "racket")
+_TESTERS = ("ai", "custom", "haskell", "java", "js", "jupyter", "py", "pyta", "r", "racket")
 
 
 def install(testers: list[str] = _TESTERS) -> tuple[dict, dict]:

server/autotest_server/testers/js/js_tester.py

@@ -0,0 +1,140 @@
+import subprocess
+import json
+import os
+
+from ..tester import Tester, Test, TestError
+from ..specs import TestSpecs
+
+
+class JsTest(Test):
+    def __init__(self, tester, result):
+        self.test_name_ = result.get("fullName", "unknown")
+        self.status = result.get("status")
+        self.message = "\n".join(result.get("failureMessages", []))
+        super().__init__(tester)
+
+    @property
+    def test_name(self):
+        """Return the full name of this test."""
+        return self.test_name_
+
+    @Test.run_decorator
+    def run(self):
+        """Return the result of this test based on its Jest status."""
+        if self.status == "passed":
+            return self.passed()
+        elif self.status == "failed":
+            return self.failed(self.message)
+        else:
+            return self.error(message=self.message or f"Unexpected status: {self.status}")
+
+
+class JsTester(Tester):
+
+    def __init__(
+        self,
+        specs: TestSpecs,
+        test_class=JsTest,
+        resource_settings: list[tuple[int, tuple[int, int]]] | None = None,
+    ) -> None:
+        """
+        Initialize a JavaScript tester using the specifications in specs.
+
+        This tester will create tests of type test_class.
+        """
+        super().__init__(specs, test_class, resource_settings=resource_settings)
+
+    def _run_pnpm_install(self, dir_path):
+        """
+        Run pnpm install in dir_path to install dependencies from package.json.
+        """
+        corepack_home = os.path.join(dir_path, ".corepack")
+        xdg_cache_home = os.path.join(dir_path, ".cache")
+        os.makedirs(corepack_home, exist_ok=True)
+        os.makedirs(xdg_cache_home, exist_ok=True)
+        env = {**os.environ, "COREPACK_HOME": corepack_home, "XDG_CACHE_HOME": xdg_cache_home}
+        result = subprocess.run(
+            ["pnpm", "install"],
+            capture_output=True,
+            text=True,
+            cwd=dir_path,
+            env=env,
+        )
+        return result
+
+    def _run_jest(self, dir_path, timeout, test_files=None):
+        """
+        Run Jest in dir_path and return its stdout and return code.
+
+        --json: output results as JSON to stdout
+        --forceExit: prevents jest from hanging if tests leave open connections
+        --runInBand: run all tests serially in the current process
+        """
+        local_jest = os.path.join(dir_path, "node_modules", ".bin", "jest")
+        jest_cmd = local_jest if os.path.isfile(local_jest) else "jest"
+        cmd = [jest_cmd, "--rootDir", dir_path, "--json", "--forceExit", "--runInBand"]
+        if test_files:
+            cmd.extend(test_files)
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            cwd=dir_path,
+            timeout=timeout,
+        )
+        return result.stdout, result.returncode
+
+    def _parse_jest_output(self, raw_json):
+        """
+        Parse Jest's JSON output and return a list of individual test results.
+
+        Returns a tuple (results, error) where error is set if JSON parsing fails.
+        """
+        try:
+            data = json.loads(raw_json)
+        except json.JSONDecodeError as e:
+            return None, e
+
+        results = []
+        for test_suite in data.get("testResults", []):
+            for test in test_suite.get("assertionResults", []):
+                results.append(test)
+
+        return results, None
+
+    @Tester.run_decorator
+    def run(self):
+        """
+        Run pnpm install and then Jest, parsing the results and printing each test outcome.
+        """
+        dir_path = os.getcwd()
+        test_data = self.specs.get("test_data", default={}) or {}
+
+        timeout = test_data.get("timeout", 30)
+        if os.path.isfile(os.path.join(dir_path, "package.json")):
+            pnpm_result = self._run_pnpm_install(dir_path)
+            if pnpm_result.returncode != 0:
+                err = pnpm_result.stderr or pnpm_result.stdout or "(no output)"
+                raise TestError(f"pnpm install failed:\n{err}")
+
+        script_files = test_data.get("script_files", [])
+        try:
+            jest_json_output, jest_rc = self._run_jest(dir_path, timeout, test_files=script_files)
+        except subprocess.TimeoutExpired:
+            raise TestError("Jest timed out")
+
+        if jest_rc != 0:
+            err = jest_json_output
+            raise TestError(f"Jest failed (exit code {jest_rc}).\n{err}")
+        if not jest_json_output:
+            raise TestError("Jest produced no output")
+
+        test_results, err = self._parse_jest_output(jest_json_output)
+        if err:
+            raise TestError(str(err))
+
+        for result in test_results:
+            if result.get("status") == "pending":
+                continue
+            test = self.test_class(self, result)
+            print(test.run(), flush=True)

server/autotest_server/testers/js/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "autotest-js",
+  "version": "1.0.0",
+  "private": true
+}

server/autotest_server/testers/js/requirements.system

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+set -euxo pipefail
+
+if ! command -v node &> /dev/null; then
+  apt-get -y update
+  DEBIAN_FRONTEND=noninteractive apt-get install -y -o 'Dpkg::Options::=--force-confdef' -o 'Dpkg::Options::=--force-confold' curl ca-certificates
+  curl -fsSL https://deb.nodesource.com/setup_24.x | bash -
+  DEBIAN_FRONTEND=noninteractive apt-get install -y -o 'Dpkg::Options::=--force-confdef' -o 'Dpkg::Options::=--force-confold' nodejs
+fi
+
+if ! command -v pnpm &> /dev/null; then
+  corepack enable
+  corepack prepare pnpm@latest --activate
+fi
+
+if ! command -v jest &> /dev/null; then
+  export PNPM_HOME="/usr/local/share/pnpm"
+  export PATH="${PNPM_HOME}:${PATH}"
+  pnpm config set global-bin-dir /usr/local/bin
+  pnpm config set global-dir /usr/local/share/pnpm-global
+  pnpm add -g jest
+fi

server/autotest_server/testers/js/schema.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+from typing import Annotated
+from msgspec import Meta
+from markus_autotesting_core.types import BaseTestData, BaseTesterSettings
+
+
+class JsTesterSettings(BaseTesterSettings):
+    """The settings for the JavaScript tester."""
+
+    test_data: Annotated[list[JsTestData], Meta(title="Test Groups", min_length=1)]
+
+
+class JsTestData(BaseTestData, kw_only=True):
+    """The `test_data` specification for the JavaScript tester."""
+
+    pass

server/autotest_server/testers/js/setup.py

@@ -0,0 +1,19 @@
+import os
+import subprocess
+from ..schema import generate_schema
+from .schema import JsTesterSettings
+
+
+def create_environment(_settings, _env_dir, default_env_dir):
+    return {"PYTHON": os.path.join(default_env_dir, "bin", "python3")}
+
+
+def install():
+    """Run the requirements.system shell script to install Node.js, pnpm, and Jest."""
+    path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "requirements.system")
+    print(f"[AUTOTESTER] Running {path}", flush=True)
+    subprocess.run(path, check=True)
+
+
+def settings():
+    return generate_schema(JsTesterSettings)

server/autotest_server/tests/fixtures/specs/js/simple.json

@@ -0,0 +1,19 @@
+{
+    "tester_type": "js",
+    "test_data": [
+        {
+            "script_files": [
+                "test.js"
+            ],
+            "category": [
+                "instructor"
+            ],
+            "timeout": 30,
+            "extra_info": {
+                "criterion": "criterion",
+                "display_output": "instructors",
+                "name": "JS Test Group 1"
+            }
+        }
+    ]
+}