jac-scale 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

jac_scale/tests/test_examples.py

@@ -19,6 +19,8 @@ JacClientExamples = (
     / "examples"
 )
 
+JacScaleFixtures = Path(__file__).parent / "fixtures"
+
 
 def get_free_port() -> int:
     """Get a free port by binding to port 0 and releasing it."""
@@ -184,6 +186,7 @@ class JacScaleTestRunner:
             "node_modules",
             ".jac",
             "package-lock.json",
+            "uploads",  # Storage API test uploads
         ]
         for dir_name in dirs_to_clean:
             dir_path = example_dir / dir_name
@@ -371,9 +374,7 @@ class JacScaleTestRunner:
             return response.text
         return f"Request failed after {max_retries} retries (all timeouts)"
 
-    def spawn_walker(
-        self, walker_name: str, **kwargs: dict[str, Any]
-    ) -> dict[str, Any]:
+    def spawn_walker(self, walker_name: str, **kwargs: object) -> dict[str, Any]:
         """Spawn a walker with the given parameters.
 
         Args:
@@ -387,9 +388,73 @@ class JacScaleTestRunner:
             "POST", f"/walker/{walker_name}", data=kwargs, use_token=True
         )
 
-    def call_function(
-        self, function_name: str, **kwargs: dict[str, Any]
+    def upload_file(
+        self,
+        walker_name: str,
+        file_field: str,
+        filename: str,
+        content: bytes,
+        content_type: str = "text/plain",
+        extra_data: dict[str, Any] | None = None,
+        timeout: int = 10,
     ) -> dict[str, Any]:
+        """Upload a file to a walker endpoint using multipart/form-data.
+
+        Args:
+            walker_name: Name of the walker to call
+            file_field: Name of the file field in the walker
+            filename: Name of the file being uploaded
+            content: File content as bytes
+            content_type: MIME type of the file
+            extra_data: Additional form data fields
+            timeout: Request timeout in seconds
+
+        Returns:
+            Walker execution response
+        """
+        import io
+
+        url = f"{self.base_url}/walker/{walker_name}"
+        headers = {}
+
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+
+        files = {file_field: (filename, io.BytesIO(content), content_type)}
+        data = extra_data or {}
+
+        response = requests.post(
+            url, headers=headers, files=files, data=data, timeout=timeout
+        )
+
+        json_response: Any = response.json()
+
+        # Handle jac-scale's tuple response format [status, body]
+        if isinstance(json_response, list) and len(json_response) == 2:
+            json_response = json_response[1]
+
+        # Handle TransportResponse envelope format
+        if (
+            isinstance(json_response, dict)
+            and "ok" in json_response
+            and "data" in json_response
+        ):
+            if json_response.get("ok") and json_response.get("data") is not None:
+                return json_response["data"]
+            elif not json_response.get("ok") and json_response.get("error"):
+                error_info = json_response["error"]
+                result: dict[str, Any] = {
+                    "error": error_info.get("message", "Unknown error")
+                }
+                if "code" in error_info:
+                    result["error_code"] = error_info["code"]
+                if "details" in error_info:
+                    result["error_details"] = error_info["details"]
+                return result
+
+        return json_response  # type: ignore[return-value]
+
+    def call_function(self, function_name: str, **kwargs: object) -> dict[str, Any]:
         """Call a function with the given parameters.
 
         Args:
@@ -482,3 +547,113 @@ class TestJacClientExamples:
         ) as runner:
             assert "/static/client.js" in runner.request_raw("GET", "/cl/app")
             assert "import styled from" in runner.request_raw("GET", "/styled.js")
+
+
+class TestJacScaleFeatures:
+    """Test jac-scale specific features using dedicated fixtures."""
+
+    def test_storage_api(self) -> None:
+        """Test Storage API with file upload, list, download, copy, move, delete."""
+        example_file = JacScaleFixtures / "scale-feats" / "main.jac"
+        with JacScaleTestRunner(
+            example_file, session_name="storage_api_test", setup_npm=False
+        ) as runner:
+            # Health check
+            health = runner.spawn_walker("health")
+            assert health.get("reports", [[]])[0].get("status") == "ok"
+
+            # Register user for auth
+            runner.create_user("storage_user", "testpass123")
+
+            # Test file upload
+            test_content = b"Test content for storage API"
+            upload_result = runner.upload_file(
+                walker_name="upload_file",
+                file_field="file",
+                filename="test_file.txt",
+                content=test_content,
+                content_type="text/plain",
+                extra_data={"folder": "test_docs"},
+            )
+            reports = upload_result.get("reports", [])
+            assert len(reports) > 0, "Upload should return reports"
+            file_info = reports[0]
+            assert file_info["success"] is True
+            assert file_info["original_filename"] == "test_file.txt"
+            assert "storage_path" in file_info
+            uploaded_path = file_info["storage_path"]
+            assert uploaded_path.startswith("test_docs/")
+            assert file_info["size"] == len(test_content)
+
+            # Test file exists
+            exists_result = runner.spawn_walker("file_exists", path=uploaded_path)
+            reports = exists_result.get("reports", [])
+            assert len(reports) > 0
+            assert reports[0]["exists"] is True
+
+            # Test list files
+            list_result = runner.spawn_walker("list_files", folder="", recursive=True)
+            reports = list_result.get("reports", [])
+            assert len(reports) > 0
+            list_info = reports[0]
+            assert "files" in list_info
+            assert list_info["count"] >= 1
+            file_paths = [f["path"] for f in list_info["files"]]
+            assert uploaded_path in file_paths
+
+            # Test download file
+            download_result = runner.spawn_walker("download_file", path=uploaded_path)
+            reports = download_result.get("reports", [])
+            assert len(reports) > 0
+            assert reports[0]["success"] is True
+            assert reports[0]["content_length"] == len(test_content)
+
+            # Test copy file
+            copy_dest = "test_docs/copied_file.txt"
+            copy_result = runner.spawn_walker(
+                "copy_file", source=uploaded_path, destination=copy_dest
+            )
+            reports = copy_result.get("reports", [])
+            assert len(reports) > 0
+            assert reports[0]["success"] is True
+
+            # Verify copy exists
+            exists_result = runner.spawn_walker("file_exists", path=copy_dest)
+            assert exists_result.get("reports", [[]])[0]["exists"] is True
+
+            # Test move file
+            move_dest = "test_docs/moved_file.txt"
+            move_result = runner.spawn_walker(
+                "move_file", source=copy_dest, destination=move_dest
+            )
+            reports = move_result.get("reports", [])
+            assert len(reports) > 0
+            assert reports[0]["success"] is True
+
+            # Verify move: source gone, dest exists
+            exists_result = runner.spawn_walker("file_exists", path=copy_dest)
+            assert exists_result.get("reports", [[]])[0]["exists"] is False
+            exists_result = runner.spawn_walker("file_exists", path=move_dest)
+            assert exists_result.get("reports", [[]])[0]["exists"] is True
+
+            # Test delete file
+            delete_result = runner.spawn_walker("delete_file", path=uploaded_path)
+            reports = delete_result.get("reports", [])
+            assert len(reports) > 0
+            assert reports[0]["success"] is True
+
+            # Verify deleted
+            exists_result = runner.spawn_walker("file_exists", path=uploaded_path)
+            assert exists_result.get("reports", [[]])[0]["exists"] is False
+
+            # Test delete nonexistent file
+            delete_result = runner.spawn_walker(
+                "delete_file", path="nonexistent/file.txt"
+            )
+            reports = delete_result.get("reports", [])
+            assert len(reports) > 0
+            assert reports[0]["success"] is False
+            assert reports[0]["error"] == "File not found"
+
+            # Cleanup: delete moved file
+            runner.spawn_walker("delete_file", path=move_dest)

jac_scale/tests/test_hooks.py

@@ -0,0 +1,39 @@
+"""Test hook registration for JacScale."""
+
+from jac_scale.plugin import JacScalePlugin
+from jac_scale.user_manager import JacScaleUserManager
+from jaclang.pycore.runtime import plugin_manager as pm
+
+
+def test_get_user_manager_implementation():
+    """Test that the plugin method returns the correct class instance."""
+    # It returns an Instance, as seen in plugin.jac implementation
+    user_manager = JacScalePlugin.get_user_manager(base_path="")
+    assert isinstance(user_manager, JacScaleUserManager)
+
+
+def test_hook_registration():
+    """Test that the hook is registered with Jac plugin manager."""
+    # Create plugin instance
+    plugin = JacScalePlugin()
+
+    # Register manually for the test
+    if not pm.is_registered(plugin):
+        pm.register(plugin)
+
+    # Check hook implementations
+    hook_impls = pm.hook.get_user_manager.get_hookimpls()
+
+    # Verify our plugin's method is in the implementations
+    found = False
+    for impl in hook_impls:
+        # Check if the function belongs to our plugin class or module
+        if (
+            impl.plugin_name == "scale"
+            or isinstance(impl.plugin, JacScalePlugin)
+            or impl.function.__qualname__ == "JacScalePlugin.get_user_manager"
+        ):
+            found = True
+            break
+
+    assert found, "JacScalePlugin.get_user_manager not found in hook implementations"

jac_scale/tests/test_restspec.py

@@ -0,0 +1,192 @@
+"""Test for restspec decorator functionality."""
+
+import contextlib
+import gc
+import glob
+import socket
+import subprocess
+import time
+from pathlib import Path
+from typing import Any
+
+import requests
+
+
+def get_free_port() -> int:
+    """Get a free port by binding to port 0 and releasing it."""
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("", 0))
+        s.listen(1)
+        port = s.getsockname()[1]
+    return port
+
+
+class TestRestSpec:
+    """Test restspec decorator functionality."""
+
+    fixtures_dir: Path
+    test_file: Path
+    port: int
+    base_url: str
+    server_process: subprocess.Popen[str] | None = None
+
+    @classmethod
+    def setup_class(cls) -> None:
+        """Set up test class - runs once for all tests."""
+        cls.fixtures_dir = Path(__file__).parent / "fixtures"
+        cls.test_file = cls.fixtures_dir / "test_restspec.jac"
+
+        if not cls.test_file.exists():
+            raise FileNotFoundError(f"Test fixture not found: {cls.test_file}")
+
+        cls.port = get_free_port()
+        cls.base_url = f"http://localhost:{cls.port}"
+
+        cls._cleanup_db_files()
+        cls._start_server()
+
+    @classmethod
+    def teardown_class(cls) -> None:
+        """Tear down test class - runs once after all tests."""
+        if cls.server_process:
+            cls.server_process.terminate()
+            try:
+                cls.server_process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                cls.server_process.kill()
+                cls.server_process.wait()
+
+        time.sleep(0.5)
+        gc.collect()
+        cls._cleanup_db_files()
+
+    @classmethod
+    def _start_server(cls) -> None:
+        """Start the jac-scale server in a subprocess."""
+        import sys
+
+        jac_executable = Path(sys.executable).parent / "jac"
+        cmd = [
+            str(jac_executable),
+            "start",
+            cls.test_file.name,
+            "--port",
+            str(cls.port),
+        ]
+
+        cls.server_process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            cwd=str(cls.fixtures_dir),
+        )
+
+        # Wait for server
+        max_attempts = 50
+        for _ in range(max_attempts):
+            if cls.server_process.poll() is not None:
+                stdout, stderr = cls.server_process.communicate()
+                raise RuntimeError(f"Server died: {stdout}\n{stderr}")
+            try:
+                requests.get(f"{cls.base_url}/docs", timeout=1)
+                return
+            except requests.RequestException:
+                time.sleep(0.5)
+
+        cls.server_process.kill()
+        raise RuntimeError("Server failed to start")
+
+    @classmethod
+    def _cleanup_db_files(cls) -> None:
+        """Cleanup database files."""
+        import shutil
+
+        for pattern in ["*.db", "*.db-wal", "*.db-shm", "anchor_store*"]:
+            for f in glob.glob(pattern):
+                with contextlib.suppress(Exception):
+                    Path(f).unlink()
+        for pattern in ["*.db", "*.db-wal", "*.db-shm"]:
+            for f in glob.glob(str(cls.fixtures_dir / pattern)):
+                with contextlib.suppress(Exception):
+                    Path(f).unlink()
+        client_dir = cls.fixtures_dir / ".jac"
+        if client_dir.exists():
+            with contextlib.suppress(Exception):
+                shutil.rmtree(client_dir)
+
+    def _extract_data(self, response: dict[str, Any] | list[Any]) -> Any:  # noqa: ANN401
+        # Handle tuple response [status, body]
+        if isinstance(response, list) and len(response) == 2:
+            response = response[1]
+
+        if isinstance(response, dict) and "data" in response:
+            return response["data"]
+        return response
+
+    def test_custom_method_walker(self) -> None:
+        """Test walker with custom GET method."""
+        response = requests.get(f"{self.base_url}/walker/GetWalker", timeout=5)
+        assert response.status_code == 200
+        data = self._extract_data(response.json())
+        assert data["reports"][0]["message"] == "GetWalker executed"
+
+    def test_custom_path_walker(self) -> None:
+        """Test walker with custom path."""
+        response = requests.get(f"{self.base_url}/custom/walker", timeout=5)
+        assert response.status_code == 200
+        data = self._extract_data(response.json())
+        assert data["reports"][0]["message"] == "CustomPathWalker executed"
+        assert data["reports"][0]["path"] == "/custom/walker"
+
+    def test_custom_method_func(self) -> None:
+        """Test function with custom GET method."""
+        requests.post(
+            f"{self.base_url}/user/register", json={"username": "u1", "password": "p1"}
+        )
+        login = requests.post(
+            f"{self.base_url}/user/login", json={"username": "u1", "password": "p1"}
+        )
+        token = self._extract_data(login.json())["token"]
+
+        response = requests.get(
+            f"{self.base_url}/function/get_func",
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=5,
+        )
+        assert response.status_code == 200
+        data = self._extract_data(response.json())
+        assert data["result"]["message"] == "get_func executed"
+
+    def test_custom_path_func(self) -> None:
+        """Test function with custom path."""
+        # Use existing user token if possible, but simplest is fresh login
+        login = requests.post(
+            f"{self.base_url}/user/login", json={"username": "u1", "password": "p1"}
+        )
+        token = self._extract_data(login.json())["token"]
+
+        response = requests.get(
+            f"{self.base_url}/custom/func",
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=5,
+        )
+        assert response.status_code == 200
+        data = self._extract_data(response.json())
+        assert data["result"]["message"] == "custom_path_func executed"
+        assert data["result"]["path"] == "/custom/func"
+
+    def test_openapi_specs(self) -> None:
+        """Verify OpenAPI documentation reflects custom paths and methods."""
+        spec = requests.get(f"{self.base_url}/openapi.json").json()
+        paths = spec["paths"]
+
+        assert "/custom/walker" in paths
+        assert "get" in paths["/custom/walker"]
+
+        assert "/custom/func" in paths
+        assert "get" in paths["/custom/func"]
+
+        assert "/walker/GetWalker" in paths
+        assert "get" in paths["/walker/GetWalker"]
+        assert "post" not in paths["/walker/GetWalker"]

jac_scale/tests/test_serve.py

@@ -1833,3 +1833,57 @@ class TestJacScaleServeDevMode:
         assert reports[1]["status"] == "after_async_wait"
         assert reports[2]["status"] == "completed"
         assert "task" in reports[2]
+
+    def test_walker_stream_response(self) -> None:
+        """Test that walker streaming responses work correctly."""
+        response = requests.post(
+            f"{self.base_url}/walker/WalkerStream",
+            json={"count": 3},
+            timeout=30,
+            stream=True,
+        )
+
+        assert response.status_code == 200, (
+            f"Failed with status {response.status_code}: {response.text}"
+        )
+        assert response.headers["content-type"] == "text/event-stream; charset=utf-8"
+        assert response.headers.get("cache-control") == "no-cache"
+        assert response.headers.get("connection") == "close"
+
+        # Collect streaming content
+        content = ""
+        for chunk in response.iter_content(chunk_size=1024, decode_unicode=True):
+            if chunk:
+                content += chunk
+
+        # The generator yields "Report 0", "Report 1", "Report 2" without delimiters
+        # They get concatenated together in the stream
+        expected = "Report 0Report 1Report 2"
+        assert content == expected, f"Expected '{expected}', got '{content}'"
+
+    def test_function_stream_response(self) -> None:
+        """Test that function streaming responses work correctly."""
+        response = requests.post(
+            f"{self.base_url}/function/FunctionStream",
+            json={"count": 2},
+            timeout=30,
+            stream=True,
+        )
+
+        assert response.status_code == 200, (
+            f"Failed with status {response.status_code}: {response.text}"
+        )
+        assert response.headers["content-type"] == "text/event-stream; charset=utf-8"
+        assert response.headers.get("cache-control") == "no-cache"
+        assert response.headers.get("connection") == "close"
+
+        # Collect streaming content
+        content = ""
+        for chunk in response.iter_content(chunk_size=1024, decode_unicode=True):
+            if chunk:
+                content += chunk
+
+        # The generator yields "Func 0", "Func 1" without delimiters
+        # They get concatenated together in the stream
+        expected = "Func 0Func 1"
+        assert content == expected, f"Expected '{expected}', got '{content}'"