jac-scale 0.1.1__py3-none-any.whl

jac_scale/tests/fixtures/test_api.jac

@@ -0,0 +1,159 @@
+"""Test API fixture for jac-scale serve tests."""
+
+# ============================================================================
+# Test Functions
+# ============================================================================
+def add_numbers(
+    a: int, b: int
+) -> int {
+    return a + b;
+}
+
+def greet(name: str = "World") -> str {
+    return "Hello, " + name + "!";
+}
+
+def multiply(x: int, y: int) -> int {
+    return x * y;
+}
+
+# ============================================================================
+# Test Data Models
+# ============================================================================
+node Task {
+    has title: str;
+    has priority: int = 1;
+    has completed: bool = False;
+}
+
+node TaskList {
+    has name: str = "My Tasks";
+}
+
+# ============================================================================
+# Test Walkers
+# ============================================================================
+walker CreateTask {
+    has title: str;
+    has priority: int = 1;
+
+    can create with `root entry {
+        new_task = here ++> Task(title=self.title, priority=self.priority);
+        report new_task ;
+    }
+}
+
+walker ListTasks {
+    can list with `root entry {
+        tasks = [-->];
+        report tasks ;
+    }
+}
+
+walker CompleteTask {
+    has title: str;
+
+    can complete with `root entry {
+        for task in [-->] {
+            if task.title == self.title {
+                visit task;
+            }
+        }
+    }
+
+    can mark_done with Task entry {
+        here.completed = True;
+        report here ;
+    }
+}
+
+walker GetTask {
+    can get with Task entry {
+        report here ;
+    }
+}
+
+walker : priv PrivateCreateTask {
+    has title: str;
+    has priority: int = 1;
+
+    can create with `root entry {
+        new_task = here ++> Task(title=self.title, priority=self.priority);
+        report {"message": "Private task created", "task": new_task} ;
+    }
+}
+
+walker : pub PublicInfo {
+    can get_info with `root entry {
+        report {"message": "This is a public endpoint", "auth_required": False} ;
+    }
+}
+
+# Async Walker Test
+import asyncio;
+
+"""Async walker that creates a task with simulated async delay."""
+async walker AsyncCreateTask {
+    has title: str;
+    has delay_ms: int = 100;
+
+    async can create with `root entry {
+        report {"status": "started", "title": self.title};
+        # Simulate async operation (e.g., external API call, DB operation)
+        delay_seconds = float(self.delay_ms) / 1000.0;
+        await asyncio.sleep(delay_seconds);
+        report {"status": "after_async_wait"};
+        new_task = here ++> Task(title=self.title, priority=1);
+        report {"status": "completed", "task": new_task};
+    }
+}
+
+# ============================================================================
+# File Upload Walkers
+# ============================================================================
+import from fastapi { UploadFile }
+
+"""Walker that handles single file upload."""
+walker UploadSingleFile {
+    has myfile: UploadFile;
+    has description: str = "";
+
+    can process with `root entry {
+        report {
+            "filename": self.myfile.filename,
+            "content_type": self.myfile.content_type,
+            "size": self.myfile.size,
+            "description": self.description
+        };
+    }
+}
+
+"""Walker with file upload that requires authentication (private by default)."""
+walker SecureFileUpload {
+    has document: UploadFile;
+    has notes: str = "";
+
+    can process with `root entry {
+        report {
+            "filename": self.document.filename,
+            "content_type": self.document.content_type,
+            "size": self.document.size,
+            "notes": self.notes,
+            "authenticated": True
+        };
+    }
+}
+
+"""Public walker with file upload (no auth required)."""
+walker : pub PublicFileUpload {
+    has attachment: UploadFile;
+
+    can process with `root entry {
+        report {
+            "filename": self.attachment.filename,
+            "content_type": self.attachment.content_type,
+            "size": self.attachment.size,
+            "public": True
+        };
+    }
+}

jac_scale/tests/fixtures/todo_app.jac

@@ -0,0 +1,68 @@
+node Task {
+    has id: int,
+        title: str,
+        completed: bool = False;
+}
+
+walker CreateTask {
+    has id: int,
+        title: str;
+
+    can create with `root entry {
+        new_task = here ++> Task(id=self.id, title=self.title);
+        report new_task ;
+    }
+}
+
+walker GetAllTasks {
+    can read with `root entry{
+        tasks = [-->];
+        report tasks;
+    }
+}
+
+walker GetTask {
+    has id: int;
+
+    can get with `root entry{
+        for task in [-->]{
+            if (self.id == task.id){
+                report task;
+            }
+        }
+    }
+}
+
+walker CompleteTask {
+    has id: int;
+
+    can complete with `root entry {
+        for task in [-->Task] {
+            if (self.id == task.id){
+                visit task;
+            }
+        }
+    }
+
+    can mark_complete with Task entry {
+        here.completed = True;
+        report here ;  # here is the visited task
+    }
+}
+
+walker DeleteTask {
+    has id: int;
+
+    can visit_node with `root entry {
+        for task in [-->] {
+            if (self.id == task.id){
+                visit task;
+            }
+        }
+    }
+
+    can delete with `root entry {
+        del here;
+        report {"deleted": True, "id": self.id};
+    }
+}

jac_scale/tests/test_abstractions.py

@@ -0,0 +1,88 @@
+"""Tests for abstraction base classes."""
+
+import pytest
+
+# Note: These imports will work once the Jac files are compiled to Python
+try:
+    from ..abstractions.config.app_config import AppConfig
+    from ..abstractions.models.deployment_result import DeploymentResult
+    from ..abstractions.models.resource_status import (
+        ResourceStatus,
+        ResourceStatusInfo,
+    )
+except ImportError:
+    # If Jac files aren't compiled yet, skip these tests
+    pytest.skip("Jac modules not compiled", allow_module_level=True)
+
+
+def test_deployment_result_success():
+    """Test DeploymentResult with success."""
+    result = DeploymentResult(
+        success=True,
+        service_url="http://localhost:8000",
+        message="Deployment successful",
+    )
+
+    assert result.success is True
+    assert result.is_successful() is True
+    assert result.service_url == "http://localhost:8000"
+    assert result.message == "Deployment successful"
+
+
+def test_deployment_result_failure():
+    """Test DeploymentResult with failure."""
+    result = DeploymentResult(
+        success=False,
+        message="Deployment failed",
+        details={"error": "Connection timeout"},
+    )
+
+    assert result.success is False
+    assert result.is_successful() is False
+    assert result.message == "Deployment failed"
+    assert "error" in result.details
+
+
+def test_resource_status_info_ready():
+    """Test ResourceStatusInfo when resource is ready."""
+    status = ResourceStatusInfo(
+        status=ResourceStatus.RUNNING,
+        replicas=3,
+        ready_replicas=3,
+    )
+
+    assert status.is_ready() is True
+    assert status.replicas == 3
+    assert status.ready_replicas == 3
+
+
+def test_resource_status_info_not_ready():
+    """Test ResourceStatusInfo when resource is not ready."""
+    status = ResourceStatusInfo(
+        status=ResourceStatus.PENDING,
+        replicas=3,
+        ready_replicas=1,
+    )
+
+    assert status.is_ready() is False
+    assert status.replicas == 3
+    assert status.ready_replicas == 1
+
+
+def test_resource_status_enum():
+    """Test ResourceStatus enum values."""
+    assert ResourceStatus.UNKNOWN == "unknown"
+    assert ResourceStatus.PENDING == "pending"
+    assert ResourceStatus.RUNNING == "running"
+    assert ResourceStatus.FAILED == "failed"
+    assert ResourceStatus.STOPPED == "stopped"
+
+
+def test_app_config_get_code_path():
+    """Test AppConfig.get_code_path() method."""
+    app_config = AppConfig(code_folder="/path/to/code")
+
+    path = app_config.get_code_path()
+
+    assert str(path) == "/path/to/code"
+    assert hasattr(path, "exists")  # Should be a Path object

jac_scale/tests/test_deploy_k8s.py

@@ -0,0 +1,265 @@
+"""Tests for Kubernetes deployment using new factory-based architecture."""
+
+import os
+import time
+from typing import Any
+
+import requests
+from kubernetes import client, config
+from kubernetes.client.exceptions import ApiException
+
+from ..abstractions.config.app_config import AppConfig
+from ..config_loader import get_scale_config
+from ..factories.deployment_factory import DeploymentTargetFactory
+from ..factories.utility_factory import UtilityFactory
+
+
+def _request_with_retry(
+    method: str,
+    url: str,
+    json: dict[str, Any] | None = None,
+    timeout: int = 10,
+    max_retries: int = 60,
+    retry_interval: float = 2.0,
+) -> requests.Response:
+    """Make an HTTP request with retry logic for 503 responses.
+
+    Args:
+        method: HTTP method (GET, POST, etc.)
+        url: The URL to request
+        json: JSON payload for the request
+        timeout: Request timeout in seconds
+        max_retries: Maximum number of retries for 503 responses
+        retry_interval: Time to wait between retries in seconds
+
+    Returns:
+        Response object
+    """
+    response = None
+    for attempt in range(max_retries):
+        response = requests.request(
+            method=method,
+            url=url,
+            json=json,
+            timeout=timeout,
+        )
+
+        if response.status_code == 503:
+            print(
+                f"[DEBUG] {url} returned 503, retrying ({attempt + 1}/{max_retries})..."
+            )
+            time.sleep(retry_interval)
+            continue
+
+        return response
+
+    # Return last response even if it was 503
+    assert response is not None, "No response received"
+    return response
+
+
+def test_deploy_all_in_one():
+    """
+    Test deployment using the new factory-based architecture.
+    Deploys the all-in-one app found in jac client examples against a live Kubernetes cluster.
+    Validates deployment, services, sends HTTP request, and tests cleanup.
+    """
+
+    # Load kubeconfig and initialize client
+    config.load_kube_config()
+    apps_v1 = client.AppsV1Api()
+    core_v1 = client.CoreV1Api()
+
+    namespace = "all-in-one"
+    app_name = namespace
+
+    # Set environment
+    os.environ.update({"APP_NAME": app_name, "K8s_NAMESPACE": namespace})
+
+    # Resolve the absolute path to the todo app folder
+    test_dir = os.path.dirname(os.path.abspath(__file__))
+    todo_app_path = os.path.join(
+        test_dir, "../../../jac-client/jac_client/examples/all-in-one"
+    )
+
+    # Get configuration
+    scale_config = get_scale_config()
+    target_config = scale_config.get_kubernetes_config()
+    target_config["app_name"] = app_name
+    target_config["namespace"] = namespace
+
+    # Create logger
+    logger = UtilityFactory.create_logger("standard")
+
+    # Create deployment target using factory
+    deployment_target = DeploymentTargetFactory.create(
+        "kubernetes", target_config, logger
+    )
+
+    # Create app config
+    app_config = AppConfig(
+        code_folder=todo_app_path,
+        file_name="main.jac",
+        build=False,
+    )
+
+    # Deploy using new architecture
+    result = deployment_target.deploy(app_config)
+
+    assert result.success is True
+    print(f"✓ Deployment successful: {result.message}")
+
+    # Wait a moment for services to stabilize
+    time.sleep(5)
+
+    # Validate the main deployment exists
+    deployment = apps_v1.read_namespaced_deployment(name=app_name, namespace=namespace)
+    assert deployment.metadata.name == app_name
+    assert deployment.spec.replicas == 1
+
+    # Validate main service
+    service = core_v1.read_namespaced_service(
+        name=f"{app_name}-service", namespace=namespace
+    )
+    assert service.spec.type == "NodePort"
+    node_port = service.spec.ports[0].node_port
+    print(f"✓ Service is exposed on NodePort: {node_port}")
+
+    # Validate MongoDB StatefulSet and Service
+    mongodb_stateful = apps_v1.read_namespaced_stateful_set(
+        name=f"{app_name}-mongodb", namespace=namespace
+    )
+    assert mongodb_stateful.metadata.name == f"{app_name}-mongodb"
+    assert mongodb_stateful.spec.service_name == f"{app_name}-mongodb-service"
+
+    mongodb_service = core_v1.read_namespaced_service(
+        name=f"{app_name}-mongodb-service", namespace=namespace
+    )
+    assert mongodb_service.spec.ports[0].port == 27017
+
+    # Validate Redis Deployment and Service
+    redis_deploy = apps_v1.read_namespaced_deployment(
+        name=f"{app_name}-redis", namespace=namespace
+    )
+    assert redis_deploy.metadata.name == f"{app_name}-redis"
+
+    redis_service = core_v1.read_namespaced_service(
+        name=f"{app_name}-redis-service", namespace=namespace
+    )
+    assert redis_service.spec.ports[0].port == 6379
+
+    # Test get_status
+    status = deployment_target.get_status(app_name)
+    assert status is not None
+    assert status.replicas >= 0
+    print(
+        f"✓ Deployment status: {status.status.value}, replicas: {status.replicas}/{status.ready_replicas}"
+    )
+
+    # Send POST request to create a todo (with retry for 503)
+    url = f"http://localhost:{node_port}/walker/create_todo"
+    payload = {"text": "first-task"}
+    response = _request_with_retry("POST", url, json=payload, timeout=10)
+    assert response.status_code == 200
+    print(f"✓ Successfully created todo at {url}")
+    print(f"  Response: {response.json()}")
+
+    url = f"http://localhost:{node_port}/cl/app"
+    response = _request_with_retry("GET", url, timeout=100)
+    print(f"Response status code for app page: {response.status_code}")
+    assert response.status_code == 200
+    print(f"✓ Successfully reached app page at {url}")
+
+    # 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:
+        apps_v1.read_namespaced_deployment(app_name, namespace=namespace)
+        raise AssertionError("Deployment should have been deleted")
+    except ApiException as e:
+        assert e.status == 404, f"Expected 404, got {e.status}"
+
+    try:
+        core_v1.read_namespaced_service(f"{app_name}-service", namespace=namespace)
+        raise AssertionError("Service should have been deleted")
+    except ApiException as e:
+        assert e.status == 404, f"Expected 404, got {e.status}"
+
+    try:
+        apps_v1.read_namespaced_stateful_set(f"{app_name}-mongodb", namespace=namespace)
+        raise AssertionError("MongoDB StatefulSet should have been deleted")
+    except ApiException as e:
+        assert e.status == 404, f"Expected 404, got {e.status}"
+
+    try:
+        core_v1.read_namespaced_service(
+            f"{app_name}-mongodb-service", namespace=namespace
+        )
+        raise AssertionError("MongoDB Service should have been deleted")
+    except ApiException as e:
+        assert e.status == 404, f"Expected 404, got {e.status}"
+
+    try:
+        apps_v1.read_namespaced_deployment(f"{app_name}-redis", namespace=namespace)
+        raise AssertionError("Redis Deployment should have been deleted")
+    except ApiException as e:
+        assert e.status == 404, f"Expected 404, got {e.status}"
+
+    try:
+        core_v1.read_namespaced_service(
+            f"{app_name}-redis-service", namespace=namespace
+        )
+        raise AssertionError("Redis Service should have been deleted")
+    except ApiException as e:
+        assert e.status == 404, f"Expected 404, got {e.status}"
+
+    # Verify PVC cleanup
+    pvcs = core_v1.list_namespaced_persistent_volume_claim(namespace=namespace)
+    for pvc in pvcs.items:
+        assert not pvc.metadata.name.startswith(app_name), (
+            f"PVC '{pvc.metadata.name}' should have been deleted"
+        )
+
+    print("✓ Cleanup verification complete - all resources properly deleted")
+
+
+def test_deployment_target_methods():
+    """Test individual methods of KubernetesTarget."""
+    # Load kubeconfig
+    config.load_kube_config()
+
+    namespace = "test-methods"
+    app_name = "test-methods-app"
+
+    # Set environment
+    os.environ.update({"APP_NAME": app_name, "K8s_NAMESPACE": namespace})
+
+    # Get configuration
+    scale_config = get_scale_config()
+    target_config = scale_config.get_kubernetes_config()
+    target_config["app_name"] = app_name
+    target_config["namespace"] = namespace
+
+    # Create deployment target
+    logger = UtilityFactory.create_logger("standard")
+    deployment_target = DeploymentTargetFactory.create(
+        "kubernetes", target_config, logger
+    )
+
+    # Test get_service_url (before deployment, should return None or handle gracefully)
+    service_url = deployment_target.get_service_url(app_name)
+    # Service URL may be None if service doesn't exist yet
+    assert service_url is None or isinstance(service_url, str)
+
+    # Test get_status (before deployment, should handle gracefully)
+    try:
+        status = deployment_target.get_status(app_name)
+        # Should return UNKNOWN or handle the error gracefully
+        assert status is not None
+    except Exception:
+        # It's okay if it raises an exception for non-existent deployment
+        pass
+
+    print("✓ Deployment target methods tested")