jac-client 0.2.2__py3-none-any.whl → 0.2.6__py3-none-any.whl

jac_client/tests/test_cl.py

@@ -1,530 +0,0 @@
-"""Tests for Vite client bundle generation."""
-
-from __future__ import annotations
-
-import json
-import subprocess
-import tempfile
-from pathlib import Path
-
-import pytest
-
-from jac_client.plugin.vite_client_bundle import ViteClientBundleBuilder
-from jaclang.runtimelib.runtime import JacRuntime as Jac
-
-
-@pytest.fixture(autouse=True)
-def reset_jac_machine():
-    """Reset Jac machine before and after each test."""
-    Jac.reset_machine()
-    yield
-    Jac.reset_machine()
-
-
-def _create_test_project_with_vite(
-    temp_path: Path, include_antd: bool = False
-) -> tuple[Path, Path]:
-    """Create a minimal test project with Vite installed.
-
-    Args:
-        temp_path: Path to the temporary directory
-        include_antd: If True, includes antd in dependencies
-    """
-    # Create package.json with base dependencies
-    dependencies = {
-        "react": "^19.2.0",
-        "react-dom": "^19.2.0",
-        "react-router-dom": "^7.3.0",
-    }
-
-    # Add antd if requested
-    if include_antd:
-        dependencies["antd"] = "^5.0.0"
-
-    # Create package.json structure
-    package_data = {
-        "name": "test-client",
-        "version": "0.0.1",
-        "type": "module",
-        "scripts": {
-            "build": "npm run compile && vite build",
-            "dev": "vite dev",
-            "preview": "vite preview",
-            "compile": 'babel src --out-dir build --extensions ".jsx,.js" --out-file-extension .js',
-        },
-        "dependencies": dependencies,
-        "devDependencies": {
-            "vite": "^6.4.1",
-            "@babel/cli": "^7.28.3",
-            "@babel/core": "^7.28.5",
-            "@babel/preset-env": "^7.28.5",
-            "@babel/preset-react": "^7.28.5",
-        },
-    }
-
-    package_json = temp_path / "package.json"
-    with package_json.open("w", encoding="utf-8") as f:
-        json.dump(package_data, f, indent=2)
-
-    # Create .babelrc file
-    babelrc = temp_path / ".babelrc"
-    babelrc.write_text(
-        """{
-    "presets": [[
-        "@babel/preset-env",
-        {
-            "modules": false
-        }
-    ], "@babel/preset-react"]
-}
-""",
-        encoding="utf-8",
-    )
-
-    # Create vite.config.js file
-    vite_config = temp_path / "vite.config.js"
-    vite_config.write_text(
-        """import { defineConfig } from "vite";
-import path from "path";
-import { fileURLToPath } from "url";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-export default defineConfig({
-  root: ".",
-  build: {
-    rollupOptions: {
-      input: "build/main.js",
-      output: {
-        entryFileNames: "client.[hash].js",
-        assetFileNames: "[name].[ext]",
-      },
-    },
-    outDir: "dist",
-    emptyOutDir: true,
-    minify: false,
-  },
-  publicDir: false,
-  resolve: {
-    alias: {
-      "@jac-client/utils": path.resolve(__dirname, "src/client_runtime.js"),
-    },
-  },
-});
-""",
-        encoding="utf-8",
-    )
-
-    # Install dependencies
-    result = subprocess.run(
-        ["npm", "install"],
-        cwd=temp_path,
-        check=False,
-        capture_output=True,
-        text=True,
-    )
-    if result.returncode != 0:
-        error_msg = f"npm install failed with exit code {result.returncode}\n"
-        error_msg += f"stdout: {result.stdout}\n"
-        error_msg += f"stderr: {result.stderr}\n"
-        raise RuntimeError(error_msg)
-
-    # Create output directory
-    output_dir = temp_path / "dist"
-    output_dir.mkdir(parents=True, exist_ok=True)
-
-    src_dir = temp_path / "src"
-    src_dir.mkdir(parents=True, exist_ok=True)
-
-    build_dir = temp_path / "build"
-    build_dir.mkdir(parents=True, exist_ok=True)
-
-    return package_json, output_dir
-
-
-def test_build_bundle_with_vite() -> None:
-    """Test that Vite bundling produces optimized output with proper structure."""
-    # Create a temporary directory for our test project
-    with tempfile.TemporaryDirectory() as temp_dir:
-        temp_path = Path(temp_dir)
-
-        package_json, output_dir = _create_test_project_with_vite(temp_path)
-        runtime_path = Path(__file__).parent.parent / "plugin" / "client_runtime.jac"
-        # Initialize the Vite builder
-        builder = ViteClientBundleBuilder(
-            runtime_path=runtime_path,
-            vite_package_json=package_json,
-            vite_output_dir=output_dir,
-            vite_minify=False,  # Disable minification for easier inspection
-        )
-        # Import the test module
-        fixtures_dir = Path(__file__).parent / "fixtures" / "basic-app"
-        (module,) = Jac.jac_import("app", str(fixtures_dir))
-        # Build the bundle
-        bundle = builder.build(module, force=True)
-
-        assert bundle is not None
-        assert bundle.module_name == "app"
-        assert "app" in bundle.client_functions
-        assert "ButtonProps" in bundle.client_functions
-        assert "API_LABEL" in bundle.client_globals
-        assert len(bundle.hash) > 10
-
-        # Verify bundle code contains expected content
-        assert "function app()" in bundle.code
-        assert 'API_LABEL = "Runtime Test";' in bundle.code
-
-        # Verify bundle was written to output directory
-        bundle_files = list(output_dir.glob("client.*.js"))
-        assert len(bundle_files) > 0, "Expected at least one bundle file"
-
-        # Verify cached bundle is identical
-        cached = builder.build(module, force=False)
-        assert bundle.hash == cached.hash
-        assert bundle.code == cached.code
-
-
-def test_vite_bundle_without_package_json() -> None:
-    """Test that missing package.json raises appropriate error."""
-    fixtures_dir = Path(__file__).parent / "fixtures" / "basic-app"
-    (module,) = Jac.jac_import("app", str(fixtures_dir))
-
-    runtime_path = Path(__file__).parent.parent / "plugin" / "client_runtime.jac"
-
-    # Create builder without package.json
-    builder = ViteClientBundleBuilder(
-        runtime_path=runtime_path,
-        vite_package_json=Path("/nonexistent/package.json"),
-        vite_output_dir=Path("/tmp/output"),
-    )
-
-    # Building should raise an error
-    from jaclang.runtimelib.client_bundle import ClientBundleError
-
-    with pytest.raises(ClientBundleError) as cm:
-        builder.build(module, force=True)
-
-    assert "Vite package.json not found" in str(cm.value)
-
-
-def test_build_bundle_with_antd() -> None:
-    """Test that Vite bundling works with Ant Design components."""
-    with tempfile.TemporaryDirectory() as temp_dir:
-        temp_path = Path(temp_dir)
-
-        # Create project with Vite and Ant Design installed
-        package_json, output_dir = _create_test_project_with_vite(
-            temp_path, include_antd=True
-        )
-        runtime_path = Path(__file__).parent.parent / "plugin" / "client_runtime.jac"
-
-        # Initialize the Vite builder
-        builder = ViteClientBundleBuilder(
-            runtime_path=runtime_path,
-            vite_package_json=package_json,
-            vite_output_dir=output_dir,
-            vite_minify=False,
-        )
-
-        # Import the test module with Ant Design
-        fixtures_dir = Path(__file__).parent / "fixtures" / "client_app_with_antd"
-        (module,) = Jac.jac_import("app", str(fixtures_dir))
-
-        # Build the bundle
-        bundle = builder.build(module, force=True)
-
-        # Verify bundle structure
-        assert bundle is not None
-        assert bundle.module_name == "app"
-        assert "ButtonTest" in bundle.client_functions
-        assert "CardTest" in bundle.client_functions
-        assert "APP_NAME" in bundle.client_globals
-
-        # Verify bundle code contains expected content
-        assert "function ButtonTest()" in bundle.code
-        assert "function CardTest()" in bundle.code
-        assert 'APP_NAME = "Ant Design Test";' in bundle.code
-
-        # verify antd components are present
-        assert "ButtonGroup" in bundle.code
-
-        # Verify the Ant Design fixture content is present
-        assert "Testing Ant Design integration" in bundle.code
-
-        # Verify bundle was written to output directory
-        bundle_files = list(output_dir.glob("client.*.js"))
-        assert len(bundle_files) > 0, "Expected at least one bundle file"
-
-        # Cleanup
-        builder.cleanup_temp_dir()
-
-
-def test_relative_import() -> None:
-    """Test that relative imports work correctly in Vite bundling."""
-    with tempfile.TemporaryDirectory() as temp_dir:
-        temp_path = Path(temp_dir)
-
-        # Create project with Vite installed
-        package_json, output_dir = _create_test_project_with_vite(
-            temp_path, include_antd=True
-        )
-        runtime_path = Path(__file__).parent.parent / "plugin" / "client_runtime.jac"
-
-        # Initialize the Vite builder
-        builder = ViteClientBundleBuilder(
-            runtime_path=runtime_path,
-            vite_package_json=package_json,
-            vite_output_dir=output_dir,
-            vite_minify=False,
-        )
-
-        # Import the test module with relative import
-        fixtures_dir = Path(__file__).parent / "fixtures" / "relative_import"
-        (module,) = Jac.jac_import("app", str(fixtures_dir))
-
-        # Build the bundle
-        bundle = builder.build(module, force=True)
-
-        # Verify bundle structure
-        assert bundle is not None
-        assert bundle.module_name == "app"
-        assert "RelativeImport" in bundle.client_functions
-        assert "app" in bundle.client_functions
-        assert "CustomButton" in bundle.code
-
-        # Verify bundle code contains expected content
-        assert "function RelativeImport()" in bundle.code
-        assert "function app()" in bundle.code
-
-        # Verify that the relative import (Button from .button) is properly resolved
-        assert "ButtonGroup" in bundle.code
-
-        # Verify bundle was written to output directory
-        bundle_files = list(output_dir.glob("client.*.js"))
-        assert len(bundle_files) > 0, "Expected at least one bundle file"
-
-        # Cleanup
-        builder.cleanup_temp_dir()
-
-
-def test_js_import() -> None:
-    """Test that JavaScript file imports work correctly in Vite bundling."""
-    with tempfile.TemporaryDirectory() as temp_dir:
-        temp_path = Path(temp_dir)
-        # Create project with Vite installed
-        package_json, output_dir = _create_test_project_with_vite(temp_path)
-        runtime_path = Path(__file__).parent.parent / "plugin" / "client_runtime.jac"
-        # Initialize the Vite builder
-        builder = ViteClientBundleBuilder(
-            runtime_path=runtime_path,
-            vite_package_json=package_json,
-            vite_output_dir=output_dir,
-            vite_minify=False,
-        )
-
-        # Import the test module with JavaScript import
-        fixtures_dir = Path(__file__).parent / "fixtures" / "js_import"
-        (module,) = Jac.jac_import("app", str(fixtures_dir))
-
-        # Build the bundle
-        bundle = builder.build(module, force=True)
-
-        # Verify bundle structure
-        assert bundle is not None
-        assert bundle.module_name == "app"
-        assert "JsImportTest" in bundle.client_functions
-        assert "app" in bundle.client_functions
-        assert "JS_IMPORT_LABEL" in bundle.client_globals
-
-        # Verify bundle code contains expected content
-        assert "function JsImportTest()" in bundle.code
-        assert "function app()" in bundle.code
-        assert 'JS_IMPORT_LABEL = "JavaScript Import Test";' in bundle.code
-
-        # Verify JavaScript imports are present in the bundle
-        # The JavaScript functions should be available in the bundle
-        assert "formatMessage" in bundle.code
-        assert "calculateSum" in bundle.code
-        assert "JS_CONSTANT" in bundle.code
-        assert "MessageFormatter" in bundle.code
-
-        # Verify the JavaScript utility code is included
-        assert "Hello," in bundle.code  # From formatMessage function
-        assert "Imported from JavaScript" in bundle.code  # From JS_CONSTANT
-
-        # Verify bundle was written to output directory
-        bundle_files = list(output_dir.glob("client.*.js"))
-        assert len(bundle_files) > 0, "Expected at least one bundle file"
-
-        # Cleanup
-        builder.cleanup_temp_dir()
-
-
-def test_jsx_fragments_and_spread_props() -> None:
-    """Test that JSX fragments and spread props work correctly."""
-    with tempfile.TemporaryDirectory() as temp_dir:
-        temp_path = Path(temp_dir)
-
-        # Create project with Vite installed
-        package_json, output_dir = _create_test_project_with_vite(temp_path)
-        runtime_path = Path(__file__).parent.parent / "plugin" / "client_runtime.jac"
-
-        # Initialize the Vite builder
-        builder = ViteClientBundleBuilder(
-            runtime_path=runtime_path,
-            vite_package_json=package_json,
-            vite_output_dir=output_dir,
-            vite_minify=False,
-        )
-
-        # Import the test module with fragments and spread props
-        fixtures_dir = Path(__file__).parent / "fixtures" / "test_fragments_spread"
-        (module,) = Jac.jac_import("app", str(fixtures_dir))
-
-        # Build the bundle
-        bundle = builder.build(module, force=True)
-
-        # Verify bundle structure
-        assert bundle is not None
-        assert bundle.module_name == "app"
-        assert "FragmentTest" in bundle.client_functions
-        assert "SpreadPropsTest" in bundle.client_functions
-        assert "MixedTest" in bundle.client_functions
-        assert "NestedFragments" in bundle.client_functions
-
-        # Verify spread props handling (Object.assign is used by compiler)
-        assert "Object.assign" in bundle.code
-
-        # Verify fragment test function exists
-        assert "function FragmentTest()" in bundle.code
-
-        # Verify spread props test function exists
-        assert "function SpreadPropsTest()" in bundle.code
-
-        # Verify bundle was written to output directory
-        bundle_files = list(output_dir.glob("client.*.js"))
-        assert len(bundle_files) > 0, "Expected at least one bundle file"
-
-        # Cleanup
-        builder.cleanup_temp_dir()
-
-
-def test_spawn_operator() -> None:
-    """Test that spawn operator generates correct __jacSpawn calls for both orderings and node types (root and UUID)."""
-    with tempfile.TemporaryDirectory() as temp_dir:
-        temp_path = Path(temp_dir)
-
-        # Create project with Vite installed
-        package_json, output_dir = _create_test_project_with_vite(temp_path)
-        runtime_path = Path(__file__).parent.parent / "plugin" / "client_runtime.jac"
-
-        # Initialize the Vite builder
-        builder = ViteClientBundleBuilder(
-            runtime_path=runtime_path,
-            vite_package_json=package_json,
-            vite_output_dir=output_dir,
-            vite_minify=False,
-        )
-
-        # Import the test module with both spawn operator orderings
-        fixtures_dir = Path(__file__).parent / "fixtures" / "spawn_test"
-        (module,) = Jac.jac_import("app", str(fixtures_dir))
-
-        # Build the bundle
-        bundle = builder.build(module, force=True)
-
-        # Verify bundle structure
-        assert bundle is not None
-        assert bundle.module_name == "app"
-        assert "app" in bundle.client_functions
-
-        # Verify complete __jacSpawn calls for root spawn scenarios
-        # Standard order: root spawn test_walker()
-        assert '__jacSpawn("test_walker", "", {})' in bundle.code
-
-        # Standard order: root spawn parameterized_walker(value=42)
-        assert '__jacSpawn("parameterized_walker", "", {' in bundle.code
-        assert '"value": 42' in bundle.code
-
-        # Reverse order: test_walker(message="Reverse spawn!") spawn root
-        # Should generate: __jacSpawn("test_walker", "", {message: "Reverse spawn!"})
-        import re
-
-        assert re.search(
-            r'__jacSpawn\("test_walker",\s*"",\s*\{[^}]*"message":\s*"Reverse spawn!"[^}]*\}\)',
-            bundle.code,
-        )
-
-        # Verify UUID spawn scenarios with complete calls
-        # Standard UUID spawn: node_id spawn test_walker()
-        # Should generate: __jacSpawn("test_walker", node_id, {})
-        assert '__jacSpawn("test_walker", node_id, {})' in bundle.code
-        assert '"550e8400-e29b-41d4-a716-446655440000"' in bundle.code
-
-        # Reverse UUID spawn: parameterized_walker(value=100) spawn another_node_id
-        # Should generate: __jacSpawn("parameterized_walker", another_node_id, {value: 100})
-        assert re.search(
-            r'__jacSpawn\("parameterized_walker",\s*another_node_id,\s*\{[^}]*"value":\s*100[^}]*\}\)',
-            bundle.code,
-        )
-        assert '"6ba7b810-9dad-11d1-80b4-00c04fd430c8"' in bundle.code
-
-        # Verify positional argument mapping for walkers
-        assert re.search(
-            r'__jacSpawn\("positional_walker",\s*node_id,\s*\{[^}]*"label":\s*"Node positional"[^}]*"count":\s*2',
-            bundle.code,
-        )
-        # Verify spread (**kwargs) handling when walker is on left-hand side
-        assert re.search(
-            r'__jacSpawn\("positional_walker",\s*"",\s*_objectSpread\(\{\s*"label":\s*"Spread order"[^}]*"count":\s*5\s*\},\s*extra_fields\)',
-            bundle.code,
-        )
-
-        # Verify we have at least 7 __jacSpawn calls (previous cases + new positional/spread)
-        assert bundle.code.count("__jacSpawn") >= 7, (
-            "Expected at least 7 __jacSpawn calls in bundle"
-        )
-
-        # Verify bundle was written to output directory
-        bundle_files = list(output_dir.glob("client.*.js"))
-        assert len(bundle_files) > 0, "Expected at least one bundle file"
-
-        # Cleanup
-        builder.cleanup_temp_dir()
-
-
-def test_serve_cl_file() -> None:
-    """Test that serving a .cl file works correctly."""
-    with tempfile.TemporaryDirectory() as temp_dir:
-        temp_path = Path(temp_dir)
-
-        # Create project with Vite installed
-        package_json, output_dir = _create_test_project_with_vite(temp_path)
-        runtime_path = Path(__file__).parent.parent / "plugin" / "client_runtime.jac"
-
-        # Initialize the Vite builder
-        builder = ViteClientBundleBuilder(
-            runtime_path=runtime_path,
-            vite_package_json=package_json,
-            vite_output_dir=output_dir,
-            vite_minify=False,
-        )
-
-        # Import the test module with both spawn operator orderings
-        fixtures_dir = Path(__file__).parent / "fixtures" / "cl_file"
-        (module,) = Jac.jac_import("app", str(fixtures_dir))
-
-        # Build the bundle
-        bundle = builder.build(module, force=True)
-        # Verify bundle structure
-        assert bundle is not None
-        assert bundle.module_name == "app"
-        assert "app" in bundle.client_functions
-
-        assert "function app()" in bundle.code
-        assert '__jacJsx("div", {}, [__jacJsx("h2", {}, ["My Todos"])' in bundle.code
-        assert "root.render(/* @__PURE__ */ React.c" in bundle.code
-        assert "ar _useState = reactExports.useState([]), _useStat" in bundle.code
-        assert 'turn __jacSpawn("create_todo", ' in bundle.code
-        # Cleanup
-        builder.cleanup_temp_dir()

jac_client/tests/test_create_jac_app.py

@@ -1,131 +0,0 @@
-"""Test create-jac-app command."""
-
-import json
-import os
-import tempfile
-from subprocess import run
-
-
-def test_create_jac_app() -> None:
-    """Test create-jac-app command."""
-    test_project_name = "test-jac-app"
-
-    # Create a temporary directory for testing
-    with tempfile.TemporaryDirectory() as temp_dir:
-        original_cwd = os.getcwd()
-        try:
-            # Change to temp directory
-            os.chdir(temp_dir)
-
-            # Run create-jac-app command
-            result = run(
-                ["jac", "create_jac_app", test_project_name],
-                capture_output=True,
-                text=True,
-                check=True,
-            )
-
-            # Check that command succeeded
-            assert result.returncode == 0
-            assert (
-                f"Successfully created Jac application '{test_project_name}'!"
-                in result.stdout
-            )
-
-            # Verify project directory was created
-            project_path = os.path.join(temp_dir, test_project_name)
-            assert os.path.exists(project_path)
-            assert os.path.isdir(project_path)
-
-            # Verify package.json was created and has correct content
-            package_json_path = os.path.join(project_path, "package.json")
-            assert os.path.exists(package_json_path)
-
-            with open(package_json_path) as f:
-                package_data = json.load(f)
-
-            assert package_data["name"] == test_project_name
-            assert package_data["type"] == "module"
-            assert "vite" in package_data["devDependencies"]
-            assert "build" in package_data["scripts"]
-            assert "dev" in package_data["scripts"]
-            assert "preview" in package_data["scripts"]
-
-            # Verify app.jac file was created
-            app_jac_path = os.path.join(project_path, "app.jac")
-            assert os.path.exists(app_jac_path)
-
-            with open(app_jac_path) as f:
-                app_jac_content = f.read()
-
-            assert "app()" in app_jac_content
-
-            # Verify README.md was created
-            readme_path = os.path.join(project_path, "README.md")
-            assert os.path.exists(readme_path)
-
-            with open(readme_path) as f:
-                readme_content = f.read()
-
-            assert f"# {test_project_name}" in readme_content
-            assert "jac serve app.jac" in readme_content
-
-            # Verify node_modules was created (npm install ran)
-            node_modules_path = os.path.join(project_path, "node_modules")
-            assert os.path.exists(node_modules_path)
-
-        finally:
-            # Return to original directory
-            os.chdir(original_cwd)
-
-
-def test_create_jac_app_invalid_name() -> None:
-    """Test create-jac-app command with invalid project name."""
-    with tempfile.TemporaryDirectory() as temp_dir:
-        original_cwd = os.getcwd()
-        try:
-            os.chdir(temp_dir)
-
-            # Test with invalid name containing spaces
-            result = run(
-                ["jac", "create_jac_app", "invalid name with spaces"],
-                capture_output=True,
-                text=True,
-            )
-
-            # Should fail with non-zero exit code
-            assert result.returncode != 0
-            assert (
-                "Project name must contain only letters, numbers, hyphens, and underscores"
-                in result.stderr
-            )
-
-        finally:
-            os.chdir(original_cwd)
-
-
-def test_create_jac_app_existing_directory() -> None:
-    """Test create-jac-app command when directory already exists."""
-    test_project_name = "existing-test-app"
-
-    with tempfile.TemporaryDirectory() as temp_dir:
-        original_cwd = os.getcwd()
-        try:
-            os.chdir(temp_dir)
-
-            # Create the directory first
-            os.makedirs(test_project_name)
-
-            # Try to create app with same name
-            result = run(
-                ["jac", "create_jac_app", test_project_name],
-                capture_output=True,
-                text=True,
-            )
-
-            # Should fail with non-zero exit code
-            assert result.returncode != 0
-            assert f"Directory '{test_project_name}' already exists" in result.stderr
-
-        finally:
-            os.chdir(original_cwd)