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

jac_scale/tests/fixtures/scale-feats/main.jac

@@ -0,0 +1,147 @@
+"""jac-scale features test fixture.
+
+Demonstrates jac-scale specific features that require FastAPI:
+- Storage abstraction with file uploads
+- UploadFile handling
+"""
+
+import from fastapi { UploadFile }
+import from uuid { uuid4 }
+
+# Initialize storage with custom base path
+glob storage = store(base_path="./uploads");
+
+# ============================================================================
+# Storage API Walkers
+# ============================================================================
+
+"""Upload a file to storage."""
+walker:pub upload_file {
+    has file: UploadFile;
+    has folder: str = "documents";
+
+    can process with `root entry {
+        # Generate unique filename
+        ext = self.file.filename.rsplit(".", 1)[-1] if "." in self.file.filename else "";
+        unique_name = f"{uuid4()}.{ext}" if ext else str(uuid4());
+        path = f"{self.folder}/{unique_name}";
+
+        # Upload file to storage
+        storage.upload(self.file.file, path);
+
+        # Get metadata
+        metadata = storage.get_metadata(path);
+
+        report {
+            "success": True,
+            "original_filename": self.file.filename,
+            "storage_path": path,
+            "size": metadata["size"],
+            "content_type": self.file.content_type
+        };
+    }
+}
+
+"""List files in storage."""
+walker:pub list_files {
+    has folder: str = "";
+    has recursive: bool = False;
+
+    can process with `root entry {
+        files = [];
+        for path in storage.list_files(self.folder, self.recursive) {
+            metadata = storage.get_metadata(path);
+            files.append({
+                "path": path,
+                "size": metadata["size"],
+                "modified": str(metadata["modified"])
+            });
+        }
+        report {"files": files, "count": len(files)};
+    }
+}
+
+"""Delete a file from storage."""
+walker:pub delete_file {
+    has path: str;
+
+    can process with `root entry {
+        if not storage.exists(self.path) {
+            report {"success": False, "error": "File not found"};
+            return;
+        }
+        deleted = storage.delete(self.path);
+        report {"success": deleted, "path": self.path};
+    }
+}
+
+"""Download a file from storage."""
+walker:pub download_file {
+    has path: str;
+
+    can process with `root entry {
+        if not storage.exists(self.path) {
+            report {"success": False, "error": "File not found"};
+            return;
+        }
+        content = storage.download(self.path);
+        metadata = storage.get_metadata(self.path);
+        report {
+            "success": True,
+            "path": self.path,
+            "size": metadata["size"],
+            "content_length": len(content) if content else 0
+        };
+    }
+}
+
+"""Check if a file exists in storage."""
+walker:pub file_exists {
+    has path: str;
+
+    can process with `root entry {
+        exists = storage.exists(self.path);
+        report {"path": self.path, "exists": exists};
+    }
+}
+
+"""Copy a file within storage."""
+walker:pub copy_file {
+    has source: str;
+    has destination: str;
+
+    can process with `root entry {
+        if not storage.exists(self.source) {
+            report {"success": False, "error": "Source file not found"};
+            return;
+        }
+        result = storage.copy(self.source, self.destination);
+        report {"success": result, "source": self.source, "destination": self.destination};
+    }
+}
+
+"""Move a file within storage."""
+walker:pub move_file {
+    has source: str;
+    has destination: str;
+
+    can process with `root entry {
+        if not storage.exists(self.source) {
+            report {"success": False, "error": "Source file not found"};
+            return;
+        }
+        result = storage.move(self.source, self.destination);
+        report {"success": result, "source": self.source, "destination": self.destination};
+    }
+}
+
+# ============================================================================
+# Health Check
+# ============================================================================
+
+"""Simple health check walker."""
+walker:pub health {
+    can check with `root entry {
+        report {"status": "ok", "features": ["storage", "file_upload"]};
+    }
+}

jac_scale/tests/fixtures/test_api.jac

@@ -89,6 +89,35 @@ walker : pub PublicInfo {
     }
 }
 
+# Streaming Walker Test
+walker : pub WalkerStream {
+    has count: int = 3;
+
+    can stream_reports with `root entry {
+        def stream -> str {
+            import time;
+            for i in range(self.count) {
+                time.sleep(0.5);
+                yield f"Report {i}";
+            }
+        }
+        report stream();
+    }
+}
+
+import from typing { Generator }
+# Streaming function test
+def : pub FunctionStream(count: int = 3) -> Generator {
+    import time;
+    def stream -> Generator {
+        for i in range(count) {
+            time.sleep(0.5);
+            yield f"Func {i}";
+        }
+    }
+    report stream();
+}
+
 # Async Walker Test
 import asyncio;
 
@@ -157,3 +186,63 @@ walker : pub PublicFileUpload {
         };
     }
 }
+
+# ============================================================================
+# Webhook Walkers
+# ============================================================================
+"""Test 1: Webhook walker with multiple fields using @restspec(webhook=True).
+This walker should be accessible ONLY via /webhook/PaymentReceived endpoint."""
+@restspec(webhook=True)
+walker PaymentReceived {
+    has payment_id: str,
+        order_id: str,
+        amount: float,
+        currency: str = 'USD';
+
+    can process with `root entry {
+        response = {
+            "status": "success",
+            "message": f"Payment {self.payment_id} processed successfully.",
+            "payment_id": self.payment_id,
+            "order_id": self.order_id,
+            "amount": self.amount,
+            "currency": self.currency
+        };
+        report response;
+    }
+}
+
+"""Test 2: Normal walker without @restspec(webhook=True) (defaults to HTTP).
+This walker should be accessible via /walker/NormalPayment endpoint, NOT /webhook/."""
+walker NormalPayment {
+    has payment_id: str,
+        order_id: str,
+        amount: float,
+        currency: str = 'USD';
+
+    can process with `root entry {
+        response = {
+            "status": "success",
+            "message": f"Normal payment {self.payment_id} processed.",
+            "payment_id": self.payment_id,
+            "order_id": self.order_id,
+            "amount": self.amount,
+            "currency": self.currency,
+            "transport": "http"
+        };
+        report response;
+    }
+}
+
+"""Test 3: Minimal webhook walker with ONLY @restspec(webhook=True).
+This walker should be accessible ONLY via /webhook/MinimalWebhook endpoint."""
+@restspec(webhook=True)
+walker MinimalWebhook {
+    can process with `root entry {
+        report {
+            "status": "received",
+            "message": "Minimal webhook executed successfully",
+            "transport": "webhook"
+        };
+    }
+}

jac_scale/tests/fixtures/test_restspec.jac

@@ -0,0 +1,88 @@
+
+"""Test API fixture for restspec decorator tests."""
+
+import from jaclang.runtimelib.builtin { restspec }
+import from http { HTTPMethod }
+
+# ============================================================================
+# RestSpec Decorator Tests
+# ============================================================================
+
+"""Walker with GET method via restspec decorator."""
+@restspec(method=HTTPMethod.GET)
+walker : pub GetWalker {
+    can get_data with `root entry {
+        report {"message": "GetWalker executed", "method": "GET"};
+    }
+}
+
+"""Walker with custom path."""
+@restspec(method=HTTPMethod.GET, path="/custom/walker")
+walker : pub CustomPathWalker {
+    can get_data with `root entry {
+        report {"message": "CustomPathWalker executed", "path": "/custom/walker"};
+    }
+}
+
+"""Function with GET method via restspec decorator."""
+@restspec(method=HTTPMethod.GET)
+def get_func() -> dict {
+    return {"message": "get_func executed", "method": "GET"};
+}
+
+"""Function with custom path."""
+@restspec(method=HTTPMethod.GET, path="/custom/func")
+def custom_path_func() -> dict {
+    return {"message": "custom_path_func executed", "path": "/custom/func"};
+}
+
+"""Walker with POST method via restspec decorator."""
+@restspec(method=HTTPMethod.POST)
+walker : pub PostWalker {
+    can post_data with `root entry {
+        report {"message": "PostWalker executed", "method": "POST"};
+    }
+}
+
+"""Walker with default method (POST)."""
+walker : pub DefaultWalker {
+    can post_data with `root entry {
+        report {"message": "DefaultWalker executed", "method": "DEFAULT"};
+    }
+}
+
+"""Function with POST method via restspec decorator."""
+@restspec(method=HTTPMethod.POST)
+def post_func() -> dict {
+    return {"message": "post_func executed", "method": "POST"};
+}
+
+"""Function with default method (POST)."""
+def default_func() -> dict {
+    return {"message": "default_func executed", "method": "DEFAULT"};
+}
+
+"""Walker with GET method and parameters."""
+@restspec(method=HTTPMethod.GET)
+walker : pub GetWalkerWithParams {
+    has name: str;
+    has age: int;
+
+    can get_data with `root entry {
+        report {
+            "message": "GetWalkerWithParams executed",
+            "name": self.name,
+            "age": self.age
+        };
+    }
+}
+
+"""Function with GET method and parameters."""
+@restspec(method=HTTPMethod.GET)
+def get_func_with_params(name: str, age: int) -> dict {
+    return {
+        "message": "get_func_with_params executed",
+        "name": name,
+        "age": age
+    };
+}

jac_scale/tests/test_deploy_k8s.py

@@ -97,10 +97,12 @@ def test_deploy_all_in_one():
     )
 
     # Create app config
+    # Use experimental=True to install from repo (PyPI packages may not be available)
     app_config = AppConfig(
         code_folder=todo_app_path,
         file_name="main.jac",
         build=False,
+        experimental=True,
     )
 
     # Deploy using new architecture
@@ -172,7 +174,6 @@ def test_deploy_all_in_one():
 
     # Cleanup using new architecture
     deployment_target.destroy(app_name)
-    time.sleep(60)  # Wait for deletion to propagate
 
     # Verify cleanup - resources should no longer exist
     try:

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"