jac-client 0.2.8__py3-none-any.whl → 0.2.11__py3-none-any.whl

jac_client/tests/test_it.py

@@ -6,87 +6,21 @@ import gc
 import json
 import os
 import shutil
-import socket
-import sys
 import tempfile
 import time
 from http.client import RemoteDisconnected
-from pathlib import Path
 from subprocess import PIPE, Popen, run
 from urllib.error import HTTPError, URLError
 from urllib.request import Request, urlopen
 
 import pytest
 
-from jaclang.pycore.runtime import JacRuntime as Jac
-
-
-def _get_jac_command() -> list[str]:
-    """Get the jac command with proper path handling."""
-    jac_path = shutil.which("jac")
-    if jac_path:
-        return [jac_path]
-    return [sys.executable, "-m", "jaclang"]
-
-
-def _get_env_with_npm() -> dict[str, str]:
-    """Get environment dict with npm in PATH."""
-    env = os.environ.copy()
-    npm_path = shutil.which("npm")
-    if npm_path:
-        npm_dir = str(Path(npm_path).parent)
-        current_path = env.get("PATH", "")
-        if npm_dir not in current_path:
-            env["PATH"] = f"{npm_dir}:{current_path}"
-    # Also check common nvm locations
-    nvm_dir = os.environ.get("NVM_DIR", os.path.expanduser("~/.nvm"))
-    nvm_node_bin = Path(nvm_dir) / "versions" / "node"
-    if nvm_node_bin.exists():
-        for version_dir in nvm_node_bin.iterdir():
-            bin_dir = version_dir / "bin"
-            if bin_dir.exists() and (bin_dir / "npm").exists():
-                current_path = env.get("PATH", "")
-                if str(bin_dir) not in current_path:
-                    env["PATH"] = f"{bin_dir}:{current_path}"
-                break
-    return env
-
-
-@pytest.fixture(autouse=True)
-def reset_jac_machine():
-    """Reset Jac machine before and after each test."""
-    Jac.reset_machine()
-    yield
-    Jac.reset_machine()
-
-
-def _wait_for_port(
-    host: str,
-    port: int,
-    timeout: float = 60.0,
-    poll_interval: float = 0.5,
-) -> None:
-    """Block until a TCP port is accepting connections or timeout.
-
-    Raises:
-        TimeoutError: if the port is not accepting connections within timeout.
-    """
-    deadline = time.time() + timeout
-    last_err: Exception | None = None
-
-    while time.time() < deadline:
-        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
-            sock.settimeout(poll_interval)
-            try:
-                sock.connect((host, port))
-                return
-            except OSError as exc:  # Connection refused / timeout
-                last_err = exc
-                time.sleep(poll_interval)
-
-    raise TimeoutError(
-        f"Timed out waiting for {host}:{port} to become available. Last error: {last_err}"
-    )
+from .test_helpers import (
+    get_env_with_npm,  # Backward compat alias
+    get_free_port,
+    get_jac_command,
+    wait_for_port,
+)
 
 
 def _wait_for_endpoint(
@@ -150,7 +84,7 @@ def _wait_for_endpoint(
 def test_all_in_one_app_endpoints() -> None:
     """Create a Jac app, copy @all-in-one into it, install packages from jac.toml, then verify endpoints."""
     print(
-        "[DEBUG] Starting test_all_in_one_app_endpoints using jac create --cl + @all-in-one"
+        "[DEBUG] Starting test_all_in_one_app_endpoints using jac create --use client + @all-in-one"
     )
 
     # Resolve the path to jac_client/examples/all-in-one relative to this test file.
@@ -171,9 +105,9 @@ def test_all_in_one_app_endpoints() -> None:
             print(f"[DEBUG] Changed working directory to {temp_dir}")
 
             # 1. Create a new Jac app via CLI (requires jac + jac-client plugin installed)
-            print(f"[DEBUG] Running 'jac create --cl {app_name}'")
+            print(f"[DEBUG] Running 'jac create --use client {app_name}'")
             process = Popen(
-                ["jac", "create", "--cl", app_name],
+                ["jac", "create", "--use", "client", app_name],
                 stdin=PIPE,
                 stdout=PIPE,
                 stderr=PIPE,
@@ -183,21 +117,21 @@ def test_all_in_one_app_endpoints() -> None:
             returncode = process.returncode
 
             print(
-                "[DEBUG] 'jac create --cl' completed "
+                "[DEBUG] 'jac create --use client' completed "
                 f"returncode={returncode}\n"
                 f"STDOUT:\n{stdout}\n"
                 f"STDERR:\n{stderr}\n"
             )
 
-            # If the currently installed `jac` CLI does not support `create --cl`,
+            # If the currently installed `jac` CLI does not support `create --use client`,
             # fail the test instead of skipping it.
-            if returncode != 0 and "unrecognized arguments: --cl" in stderr:
+            if returncode != 0 and "unrecognized arguments: --use" in stderr:
                 pytest.fail(
-                    "Test failed: installed `jac` CLI does not support `create --cl`."
+                    "Test failed: installed `jac` CLI does not support `create --use client`."
                 )
 
             assert returncode == 0, (
-                f"jac create --cl failed\nSTDOUT:\n{stdout}\nSTDERR:\n{stderr}\n"
+                f"jac create --use client failed\nSTDOUT:\n{stdout}\nSTDERR:\n{stderr}\n"
             )
 
             project_path = os.path.join(temp_dir, app_name)
@@ -217,17 +151,17 @@ def test_all_in_one_app_endpoints() -> None:
                 else:
                     shutil.copy2(src, dst)
 
-            # 3. Install packages from jac.toml using `jac add --cl`
+            # 3. Install packages from jac.toml using `jac add --npm`
             # This reads packages from jac.toml, generates package.json, and runs npm install
-            print("[DEBUG] Running 'jac add --cl' to install packages from jac.toml")
+            print("[DEBUG] Running 'jac add --npm' to install packages from jac.toml")
             jac_add_result = run(
-                ["jac", "add", "--cl"],
+                ["jac", "add", "--npm"],
                 cwd=project_path,
                 capture_output=True,
                 text=True,
             )
             print(
-                "[DEBUG] 'jac add --cl' completed "
+                "[DEBUG] 'jac add --npm' completed "
                 f"returncode={jac_add_result.returncode}\n"
                 f"STDOUT (truncated to 2000 chars):\n{jac_add_result.stdout[:2000]}\n"
                 f"STDERR (truncated to 2000 chars):\n{jac_add_result.stderr[:2000]}\n"
@@ -235,28 +169,36 @@ def test_all_in_one_app_endpoints() -> None:
 
             if jac_add_result.returncode != 0:
                 pytest.fail(
-                    f"Test failed: jac add --cl failed or npm is not available in PATH.\n"
+                    f"Test failed: jac add --npm failed or npm is not available in PATH.\n"
                     f"STDOUT:\n{jac_add_result.stdout}\n"
                     f"STDERR:\n{jac_add_result.stderr}\n"
                 )
 
-            app_jac_path = os.path.join(project_path, "app.jac")
-            assert os.path.isfile(app_jac_path), "all-in-one src/app.jac file missing"
+            app_jac_path = os.path.join(project_path, "main.jac")
+            assert os.path.isfile(app_jac_path), "all-in-one main.jac file missing"
 
-            # 4. Start the server: `jac start src/app.jac`
+            # 4. Start the server: `jac start main.jac`
             # NOTE: We don't use text mode here, so `Popen` defaults to bytes.
             # Use `Popen[bytes]` in the type annotation to keep mypy happy.
             server: Popen[bytes] | None = None
+            # Use dynamic port allocation to avoid conflicts when running tests in parallel
+            server_port = get_free_port()
             try:
-                print("[DEBUG] Starting server with 'jac start src/app.jac'")
+                print(
+                    f"[DEBUG] Starting server with 'jac start main.jac -p {server_port}'"
+                )
                 server = Popen(
-                    ["jac", "start", "src/app.jac"],
+                    ["jac", "start", "main.jac", "-p", str(server_port)],
                     cwd=project_path,
                 )
                 # Wait for localhost:8000 to become available
-                print("[DEBUG] Waiting for server to be available on 127.0.0.1:8000")
-                _wait_for_port("127.0.0.1", 8000, timeout=90.0)
-                print("[DEBUG] Server is now accepting connections on 127.0.0.1:8000")
+                print(
+                    f"[DEBUG] Waiting for server to be available on 127.0.0.1:{server_port}"
+                )
+                wait_for_port("127.0.0.1", server_port, timeout=90.0)
+                print(
+                    f"[DEBUG] Server is now accepting connections on 127.0.0.1:{server_port}"
+                )
 
                 # "/" – server up (serves client app HTML due to base_route_app="app")
                 # Note: The root endpoint may return 503 while the client bundle is building.
@@ -264,7 +206,7 @@ def test_all_in_one_app_endpoints() -> None:
                 try:
                     print("[DEBUG] Sending GET request to root endpoint / (with retry)")
                     root_bytes = _wait_for_endpoint(
-                        "http://127.0.0.1:8000",
+                        f"http://127.0.0.1:{server_port}",
                         timeout=120.0,
                         poll_interval=2.0,
                         request_timeout=30.0,
@@ -290,7 +232,7 @@ def test_all_in_one_app_endpoints() -> None:
                         "[DEBUG] Sending GET request to /cl/app endpoint (with retry)"
                     )
                     page_bytes = _wait_for_endpoint(
-                        "http://127.0.0.1:8000/cl/app",
+                        f"http://127.0.0.1:{server_port}/cl/app",
                         timeout=120.0,
                         poll_interval=2.0,
                         request_timeout=30.0,
@@ -310,7 +252,7 @@ def test_all_in_one_app_endpoints() -> None:
                 try:
                     print("[DEBUG] Sending GET request to /cl/app#/nested endpoint")
                     with urlopen(
-                        "http://127.0.0.1:8000/cl/app#/nested",
+                        f"http://127.0.0.1:{server_port}/cl/app#/nested",
                         timeout=200,
                     ) as resp_nested:
                         nested_body = resp_nested.read().decode(
@@ -336,7 +278,7 @@ def test_all_in_one_app_endpoints() -> None:
                 try:
                     print("[DEBUG] Sending GET request to /static/assets/burger.png")
                     with urlopen(
-                        "http://127.0.0.1:8000/static/assets/burger.png",
+                        f"http://127.0.0.1:{server_port}/static/assets/burger.png",
                         timeout=20,
                     ) as resp_png:
                         png_bytes = resp_png.read()
@@ -362,7 +304,7 @@ def test_all_in_one_app_endpoints() -> None:
                         "[DEBUG] Sending GET request to /workers/worker.js (with retry)"
                     )
                     worker_js_bytes = _wait_for_endpoint(
-                        "http://127.0.0.1:8000/workers/worker.js",
+                        f"http://127.0.0.1:{server_port}/workers/worker.js",
                         timeout=60.0,
                         poll_interval=2.0,
                         request_timeout=20.0,
@@ -384,13 +326,18 @@ def test_all_in_one_app_endpoints() -> None:
                         f"Failed to GET /workers/worker.js after retries: {exc}"
                     )
 
-                # "/walker/get_server_message" – walkers are integrated and up and running
+                # POST /walker/get_server_message – walkers are integrated and up and running
                 try:
-                    print("[DEBUG] Sending GET request to /walker/get_server_message")
-                    with urlopen(
-                        "http://127.0.0.1:8000/walker/get_server_message",
-                        timeout=20,
-                    ) as resp_walker:
+                    print(
+                        "[DEBUG] Sending POST request to /walker/get_server_message endpoint"
+                    )
+                    req = Request(
+                        f"http://127.0.0.1:{server_port}/walker/get_server_message",
+                        data=json.dumps({}).encode("utf-8"),
+                        headers={"Content-Type": "application/json"},
+                        method="POST",
+                    )
+                    with urlopen(req, timeout=20) as resp_walker:
                         walker_body = resp_walker.read().decode(
                             "utf-8", errors="ignore"
                         )
@@ -400,12 +347,13 @@ def test_all_in_one_app_endpoints() -> None:
                             f"Body (truncated to 500 chars):\n{walker_body[:500]}"
                         )
                         assert resp_walker.status == 200
-                        assert "get_server_message" in walker_body
-                except (URLError, HTTPError) as exc:
+                        # The walker reports "hello from a basic walker!"
+                        assert "hello from a basic walker" in walker_body.lower()
+                except (URLError, HTTPError, RemoteDisconnected) as exc:
                     print(
                         f"[DEBUG] Error while requesting /walker/get_server_message: {exc}"
                     )
-                    pytest.fail("Failed to GET /walker/get_server_message")
+                    pytest.fail("Failed to POST /walker/get_server_message")
 
                 # POST /walker/create_todo – create a Todo via walker HTTP API
                 try:
@@ -416,7 +364,7 @@ def test_all_in_one_app_endpoints() -> None:
                         "text": "Sample todo from all-in-one app",
                     }
                     req = Request(
-                        "http://127.0.0.1:8000/walker/create_todo",
+                        f"http://127.0.0.1:{server_port}/walker/create_todo",
                         data=json.dumps(payload).encode("utf-8"),
                         headers={"Content-Type": "application/json"},
                         method="POST",
@@ -447,7 +395,7 @@ def test_all_in_one_app_endpoints() -> None:
                         "password": test_password,
                     }
                     req_register = Request(
-                        "http://127.0.0.1:8000/user/register",
+                        f"http://127.0.0.1:{server_port}/user/register",
                         data=json.dumps(register_payload).encode("utf-8"),
                         headers={"Content-Type": "application/json"},
                         method="POST",
@@ -488,7 +436,7 @@ def test_all_in_one_app_endpoints() -> None:
                         "password": test_password,
                     }
                     req_login = Request(
-                        "http://127.0.0.1:8000/user/login",
+                        f"http://127.0.0.1:{server_port}/user/login",
                         data=json.dumps(login_payload).encode("utf-8"),
                         headers={"Content-Type": "application/json"},
                         method="POST",
@@ -524,7 +472,7 @@ def test_all_in_one_app_endpoints() -> None:
                         "password": "wrong_password",
                     }
                     req_invalid_login = Request(
-                        "http://127.0.0.1:8000/user/login",
+                        f"http://127.0.0.1:{server_port}/user/login",
                         data=json.dumps(invalid_login_payload).encode("utf-8"),
                         headers={"Content-Type": "application/json"},
                         method="POST",
@@ -611,10 +559,10 @@ def test_all_in_one_app_endpoints() -> None:
 
 
 def test_default_client_app_renders() -> None:
-    """Test that a default `jac create --cl` app renders correctly when served.
+    """Test that a default `jac create --use client` app renders correctly when served.
 
     This test validates the out-of-the-box experience:
-    1. Creates a new client app using `jac create --cl`
+    1. Creates a new client app using `jac create --use client`
     2. Installs packages
     3. Starts the server
     4. Validates that the default app renders with expected content
@@ -631,11 +579,13 @@ def test_default_client_app_renders() -> None:
             print(f"[DEBUG] Changed working directory to {temp_dir}")
 
             # 1. Create a new default Jac client app
-            jac_cmd = _get_jac_command()
-            env = _get_env_with_npm()
-            print(f"[DEBUG] Running '{' '.join(jac_cmd)} create --cl {app_name}'")
+            jac_cmd = get_jac_command()
+            env = get_env_with_npm()
+            print(
+                f"[DEBUG] Running '{' '.join(jac_cmd)} create --use client {app_name}'"
+            )
             process = Popen(
-                [*jac_cmd, "create", "--cl", app_name],
+                [*jac_cmd, "create", "--use", "client", app_name],
                 stdin=PIPE,
                 stdout=PIPE,
                 stderr=PIPE,
@@ -646,18 +596,18 @@ def test_default_client_app_renders() -> None:
             returncode = process.returncode
 
             print(
-                f"[DEBUG] 'jac create --cl' completed returncode={returncode}\n"
+                f"[DEBUG] 'jac create --use client' completed returncode={returncode}\n"
                 f"STDOUT:\n{stdout}\n"
                 f"STDERR:\n{stderr}\n"
             )
 
-            if returncode != 0 and "unrecognized arguments: --cl" in stderr:
+            if returncode != 0 and "unrecognized arguments: --use" in stderr:
                 pytest.fail(
-                    "Test failed: installed `jac` CLI does not support `create --cl`."
+                    "Test failed: installed `jac` CLI does not support `create --use client`."
                 )
 
             assert returncode == 0, (
-                f"jac create --cl failed\nSTDOUT:\n{stdout}\nSTDERR:\n{stderr}\n"
+                f"jac create --use client failed\nSTDOUT:\n{stdout}\nSTDERR:\n{stderr}\n"
             )
 
             project_path = os.path.join(temp_dir, app_name)
@@ -679,46 +629,52 @@ def test_default_client_app_renders() -> None:
             jac_toml_path = os.path.join(project_path, "jac.toml")
             assert os.path.isfile(jac_toml_path), "jac.toml should exist"
 
-            # 2. Ensure packages are installed (jac create --cl should have done this)
-            # If node_modules doesn't exist, run jac add --cl
+            # 2. Ensure packages are installed (jac create --use client should have done this)
+            # If node_modules doesn't exist, run jac add --npm
             node_modules_path = os.path.join(
                 project_path, ".jac", "client", "node_modules"
             )
             if not os.path.isdir(node_modules_path):
-                print("[DEBUG] node_modules not found, running 'jac add --cl'")
+                print("[DEBUG] node_modules not found, running 'jac add --npm'")
                 jac_add_result = run(
-                    [*jac_cmd, "add", "--cl"],
+                    [*jac_cmd, "add", "--npm"],
                     cwd=project_path,
                     capture_output=True,
                     text=True,
                     env=env,
                 )
                 print(
-                    f"[DEBUG] 'jac add --cl' completed returncode={jac_add_result.returncode}\n"
+                    f"[DEBUG] 'jac add --npm' completed returncode={jac_add_result.returncode}\n"
                     f"STDOUT (truncated):\n{jac_add_result.stdout[:1000]}\n"
                     f"STDERR (truncated):\n{jac_add_result.stderr[:1000]}\n"
                 )
                 if jac_add_result.returncode != 0:
                     pytest.fail(
-                        f"jac add --cl failed\n"
+                        f"jac add --npm failed\n"
                         f"STDOUT:\n{jac_add_result.stdout}\n"
                         f"STDERR:\n{jac_add_result.stderr}\n"
                     )
 
             # 3. Start the server (now uses main.jac at project root)
             server: Popen[bytes] | None = None
+            # Use dynamic port allocation to avoid conflicts when running tests in parallel
+            server_port = get_free_port()
             try:
-                print("[DEBUG] Starting server with 'jac start main.jac'")
+                print(
+                    f"[DEBUG] Starting server with 'jac start main.jac -p {server_port}'"
+                )
                 server = Popen(
-                    [*jac_cmd, "start", "main.jac"],
+                    [*jac_cmd, "start", "main.jac", "-p", str(server_port)],
                     cwd=project_path,
                     env=env,
                 )
 
                 # Wait for server to be ready
-                print("[DEBUG] Waiting for server on 127.0.0.1:8000")
-                _wait_for_port("127.0.0.1", 8000, timeout=90.0)
-                print("[DEBUG] Server is accepting connections")
+                print(f"[DEBUG] Waiting for server on 127.0.0.1:{server_port}")
+                wait_for_port("127.0.0.1", server_port, timeout=90.0)
+                print(
+                    f"[DEBUG] Server is accepting connections on 127.0.0.1:{server_port}"
+                )
 
                 # 4. Test root endpoint - for client-only apps, root serves the HTML app
                 # Note: The root endpoint may return 503 while the client bundle is building.
@@ -726,7 +682,7 @@ def test_default_client_app_renders() -> None:
                 try:
                     print("[DEBUG] Testing root endpoint / (with retry)")
                     root_bytes = _wait_for_endpoint(
-                        "http://127.0.0.1:8000",
+                        f"http://127.0.0.1:{server_port}",
                         timeout=120.0,
                         poll_interval=2.0,
                         request_timeout=30.0,
@@ -750,7 +706,7 @@ def test_default_client_app_renders() -> None:
                 try:
                     print("[DEBUG] Testing client app endpoint /cl/app")
                     page_bytes = _wait_for_endpoint(
-                        "http://127.0.0.1:8000/cl/app",
+                        f"http://127.0.0.1:{server_port}/cl/app",
                         timeout=120.0,
                         poll_interval=2.0,
                         request_timeout=30.0,
@@ -786,7 +742,7 @@ def test_default_client_app_renders() -> None:
                     )
                     if script_match:
                         js_path = script_match.group(1)
-                        js_url = f"http://127.0.0.1:8000{js_path}"
+                        js_url = f"http://127.0.0.1:{server_port}{js_path}"
                         print(f"[DEBUG] Fetching JS bundle from {js_url}")
                         with urlopen(js_url, timeout=30) as resp:
                             js_body = resp.read().decode("utf-8", errors="ignore")