jac-client 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

jac_client/tests/conftest.py

@@ -0,0 +1,281 @@
+"""Pytest configuration and shared fixtures for jac-client tests.
+
+This module provides session-scoped fixtures to optimize test execution by:
+1. Running npm install once per session and caching node_modules
+2. Providing shared Vite build infrastructure
+3. Mocking npm install for tests that only need jac.toml manipulation
+"""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from collections.abc import Generator
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from jaclang.pycore.runtime import JacRuntime as Jac
+from jaclang.pycore.runtime import JacRuntimeImpl, plugin_manager
+
+# Store unregistered plugins globally for session-level management
+_external_plugins: list = []
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    """Disable jac-scale plugin at the start of the test session.
+
+    jac-scale plugin is disabled during tests to avoid MongoDB connections
+    and other jac-scale specific dependencies. jac-client plugin is kept
+    enabled since we're testing it.
+    """
+    global _external_plugins
+    for name, plugin in list(plugin_manager.list_name_plugin()):
+        # Keep core runtime and jac-client plugins
+        if plugin is JacRuntimeImpl or name == "JacRuntimeImpl":
+            continue
+        if "client" in name.lower() or "JacClient" in str(type(plugin)):
+            continue
+        # Disable jac-scale and other external plugins
+        _external_plugins.append((name, plugin))
+        plugin_manager.unregister(plugin=plugin, name=name)
+
+
+def pytest_unconfigure(config: pytest.Config) -> None:
+    """Re-register external plugins at the end of the test session."""
+    global _external_plugins
+    for name, plugin in _external_plugins:
+        with contextlib.suppress(ValueError):
+            plugin_manager.register(plugin, name=name)
+    _external_plugins.clear()
+
+
+def _get_jac_command() -> list[str]:
+    """Get the jac command with proper path handling."""
+    # Try to find jac in PATH or use python -m jaclang
+    jac_path = shutil.which("jac")
+    if jac_path:
+        return [jac_path]
+    # Fall back to running via python module
+    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 might be installed via nvm, ensure PATH includes common locations
+    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}"
+    return env
+
+
+@pytest.fixture(autouse=True)
+def reset_jac_machine() -> Generator[None, None, None]:
+    """Reset Jac machine before and after each test."""
+    Jac.reset_machine()
+    yield
+    Jac.reset_machine()
+
+
+# Session-scoped cache for npm installation
+_npm_cache_dir: Path | None = None
+
+
+def _get_minimal_jac_toml() -> str:
+    """Get minimal jac.toml content for npm cache setup."""
+    return """[project]
+name = "npm-cache"
+version = "0.0.1"
+description = "Cached npm modules"
+entry-point = "app.jac"
+
+[plugins.client.vite.build]
+minify = false
+"""
+
+
+@pytest.fixture(scope="session")
+def npm_cache_dir() -> Generator[Path, None, None]:
+    """Session-scoped fixture that provides a directory with npm packages installed.
+
+    This runs npm install once per test session and provides the path to the
+    .jac-client.configs directory containing node_modules.
+    """
+    global _npm_cache_dir
+
+    if _npm_cache_dir is not None and _npm_cache_dir.exists():
+        yield _npm_cache_dir
+        return
+
+    # Create a persistent temp directory for the session
+    cache_dir = Path(tempfile.mkdtemp(prefix="jac_npm_cache_"))
+
+    # Create jac.toml
+    jac_toml = cache_dir / "jac.toml"
+    jac_toml.write_text(_get_minimal_jac_toml())
+
+    # Run jac add --cl to install packages
+    jac_cmd = _get_jac_command()
+    env = _get_env_with_npm()
+    result = subprocess.run(
+        [*jac_cmd, "add", "--cl"],
+        cwd=cache_dir,
+        capture_output=True,
+        text=True,
+        env=env,
+    )
+
+    if result.returncode != 0:
+        # Clean up on failure
+        shutil.rmtree(cache_dir, ignore_errors=True)
+        pytest.skip(f"Failed to set up npm cache: {result.stderr}")
+
+    _npm_cache_dir = cache_dir
+    yield cache_dir
+
+    # Cleanup after all tests complete
+    shutil.rmtree(cache_dir, ignore_errors=True)
+
+
+@pytest.fixture
+def vite_project_dir(npm_cache_dir: Path, tmp_path: Path) -> Path:
+    """Fixture that provides a project directory with pre-installed node_modules.
+
+    This copies node_modules from the session cache instead of running npm install.
+    """
+    # Create jac.toml in the temp directory
+    jac_toml = tmp_path / "jac.toml"
+    jac_toml.write_text(_get_minimal_jac_toml())
+
+    # Copy .jac-client.configs directory (contains package.json)
+    source_configs = npm_cache_dir / ".jac-client.configs"
+    dest_configs = tmp_path / ".jac-client.configs"
+    if source_configs.exists():
+        shutil.copytree(source_configs, dest_configs, symlinks=True)
+
+    # Copy node_modules from project root (npm installs there, not in .jac-client.configs)
+    source_node_modules = npm_cache_dir / "node_modules"
+    dest_node_modules = tmp_path / "node_modules"
+    if source_node_modules.exists():
+        shutil.copytree(source_node_modules, dest_node_modules, symlinks=True)
+
+    # Create required directories
+    (tmp_path / "dist").mkdir(exist_ok=True)
+    (tmp_path / "compiled").mkdir(exist_ok=True)
+    (tmp_path / "build").mkdir(exist_ok=True)
+
+    return tmp_path
+
+
+@pytest.fixture
+def vite_project_with_antd(npm_cache_dir: Path, tmp_path: Path) -> Path:
+    """Fixture that provides a project directory with antd pre-installed."""
+    # Create jac.toml with antd dependency
+    jac_toml_content = """[project]
+name = "antd-test"
+version = "0.0.1"
+description = "Test project with antd"
+entry-point = "app.jac"
+
+[plugins.client.vite.build]
+minify = false
+
+[dependencies.npm]
+antd = "^6.0.0"
+"""
+    jac_toml = tmp_path / "jac.toml"
+    jac_toml.write_text(jac_toml_content)
+
+    # Copy base .jac-client.configs first for faster install
+    source_configs = npm_cache_dir / ".jac-client.configs"
+    dest_configs = tmp_path / ".jac-client.configs"
+    if source_configs.exists():
+        shutil.copytree(source_configs, dest_configs, symlinks=True)
+
+    # Copy base node_modules for faster install (npm will add antd on top)
+    source_node_modules = npm_cache_dir / "node_modules"
+    dest_node_modules = tmp_path / "node_modules"
+    if source_node_modules.exists():
+        shutil.copytree(source_node_modules, dest_node_modules, symlinks=True)
+
+    # Install antd on top (uses cached node_modules as base)
+    jac_cmd = _get_jac_command()
+    env = _get_env_with_npm()
+    result = subprocess.run(
+        [*jac_cmd, "add", "--cl"],
+        cwd=tmp_path,
+        capture_output=True,
+        text=True,
+        env=env,
+    )
+    if result.returncode != 0:
+        pytest.skip(f"Failed to install antd: {result.stderr}")
+
+    # Create required directories
+    (tmp_path / "dist").mkdir(exist_ok=True)
+    (tmp_path / "compiled").mkdir(exist_ok=True)
+    (tmp_path / "build").mkdir(exist_ok=True)
+
+    return tmp_path
+
+
+@pytest.fixture
+def mock_npm_install():
+    """Fixture that mocks npm install for tests that only test jac.toml manipulation.
+
+    Use this for CLI tests (add/remove commands) that don't need actual npm packages.
+    """
+    with patch(
+        "jac_client.plugin.src.package_installer.PackageInstaller._regenerate_and_install"
+    ) as mock:
+        yield mock
+
+
+@pytest.fixture
+def cli_test_dir(tmp_path: Path) -> Path:
+    """Fixture that provides a minimal test directory for CLI tests."""
+    return tmp_path
+
+
+def create_test_jac_toml(
+    path: Path,
+    deps: str = "",
+    dev_deps: str = "",
+    name: str = "test-project",
+) -> Path:
+    """Helper to create a jac.toml file for testing.
+
+    Args:
+        path: Directory to create jac.toml in
+        deps: Dependencies to add (TOML format, e.g., 'lodash = "^4.17.21"')
+        dev_deps: Dev dependencies to add (TOML format)
+        name: Project name
+
+    Returns:
+        Path to the created jac.toml file
+    """
+    deps_section = f"\n{deps}" if deps else ""
+    dev_deps_section = f"\n{dev_deps}" if dev_deps else ""
+
+    content = f"""[project]
+name = "{name}"
+version = "1.0.0"
+description = "Test project"
+entry-point = "app.jac"
+
+[dependencies.npm]{deps_section}
+
+[dev-dependencies.npm]{dev_deps_section}
+"""
+    config_path = path / "jac.toml"
+    config_path.write_text(content)
+    return config_path

jac_client/tests/fixtures/basic-app/app.jac

@@ -1,6 +1,6 @@
 """Sample Jac module containing client-side declarations."""
 
-cl let API_LABEL: str = "Runtime Test";
+cl glob API_LABEL: str = "Runtime Test";
 
 cl obj ButtonProps {
     has label: str = "Tap Me";
@@ -8,7 +8,7 @@ cl obj ButtonProps {
 }
 
 cl def app() {
-    let props = ButtonProps(label="Tap Me", color="primary");
+    props = ButtonProps(label="Tap Me", color="primary");
     return <div class="app">
         <h1>
             {API_LABEL}

jac_client/tests/fixtures/cl_file/app.cl.jac

@@ -1,8 +1,8 @@
 import from react { useState }
 
 def app()  -> any {
-    let [todos, setTodos] = useState([]);
-    let [input, setInput] = useState("");
+    [todos, setTodos] = useState([]);
+    [input, setInput] = useState("");
 
     # Event Handler
     async def addTodo()  -> None {

jac_client/tests/fixtures/client_app_with_antd/app.jac

@@ -2,7 +2,7 @@
 
 cl import from antd { Button }
 
-cl let APP_NAME: str = "Ant Design Test";
+cl glob APP_NAME: str = "Ant Design Test";
 
 cl def ButtonTest() {
     return <div>

jac_client/tests/fixtures/js_import/app.jac

@@ -2,13 +2,13 @@
 
 cl import from .utils { formatMessage, calculateSum, JS_CONSTANT, MessageFormatter }
 
-cl let JS_IMPORT_LABEL: str = "JavaScript Import Test";
+cl glob JS_IMPORT_LABEL: str = "JavaScript Import Test";
 
 cl def JsImportTest()  -> any {
-    let greeting = formatMessage("Jac");
-    let sum = calculateSum(5, 3);
-    let formatter = MessageFormatter("JS");
-    let formatted = formatter.format("Hello from JS class");
+    greeting = formatMessage("Jac");
+    sum = calculateSum(5, 3);
+    formatter = MessageFormatter("JS");
+    formatted = formatter.format("Hello from JS class");
 
     return <div class="js-import-test">
         <h1>

jac_client/tests/fixtures/spawn_test/app.jac

@@ -39,13 +39,13 @@ cl import from react {
 
 cl {
     def app()  -> any {
-        let [standardResult, setStandardResult] = useState(None);
-        let [standardComputed, setStandardComputed] = useState(None);
-        let [reverseResult, setReverseResult] = useState(None);
-        let [uuidResult, setUuidResult] = useState(None);
-        let [reverseUuidResult, setReverseUuidResult] = useState(None);
-        let [positionalResult, setPositionalResult] = useState(None);
-        let [spreadResult, setSpreadResult] = useState(None);
+        [standardResult, setStandardResult] = useState(None);
+        [standardComputed, setStandardComputed] = useState(None);
+        [reverseResult, setReverseResult] = useState(None);
+        [uuidResult, setUuidResult] = useState(None);
+        [reverseUuidResult, setReverseUuidResult] = useState(None);
+        [positionalResult, setPositionalResult] = useState(None);
+        [spreadResult, setSpreadResult] = useState(None);
 
         async def loadData()  -> None {
             # Test standard spawn order: node spawn walker()

jac_client/tests/fixtures/with-ts/app.jac

@@ -0,0 +1,35 @@
+
+# Pages
+cl import from react { useState, useEffect }
+cl import from ".components/Button.tsx" { Button }
+
+cl {
+    def app()  -> any {
+        [count, setCount] = useState(0);
+        useEffect(lambda   -> None{ console.log("Count: ", count);} , [count]);
+        return <div
+            style={{padding: "2rem", fontFamily: "Arial, sans-serif"}}
+        >
+            <h1>
+                Hello, World!
+            </h1>
+            <p>
+                Count: {count}
+            </p>
+            <div
+                style={{display: "flex", gap: "1rem", marginTop: "1rem"}}
+            >
+                <Button
+                    label="Increment"
+                    onClick={lambda   -> None{ setCount(count + 1);} }
+                    variant="primary"
+                />
+                <Button
+                    label="Reset"
+                    onClick={lambda   -> None{ setCount(0);} }
+                    variant="secondary"
+                />
+            </div>
+        </div>;
+    }
+}