render 1.0.1__py3-none-any.whl

render/workflows/tests/test_end_to_end.py

@@ -0,0 +1,307 @@
+#!/usr/bin/env python3
+"""End-to-end tests that simulate the full workflow."""
+
+import pytest
+
+from render.workflows._callback_models import TaskOptions
+from render.workflows.client import Status, UDSClient
+from render.workflows.executor import TaskExecutor
+from render.workflows.runner import register
+from render.workflows.task import (
+    Options,
+    Retry,
+    TaskRegistry,
+    create_task_decorator,
+)
+
+
+# Fixtures
+@pytest.fixture
+def task_registry():
+    """Create a fresh task registry for each test."""
+    return TaskRegistry()
+
+
+@pytest.fixture
+def task_decorator(task_registry):
+    """Create a task decorator bound to the test registry."""
+    return create_task_decorator(task_registry)
+
+
+@pytest.fixture
+def mock_client(mocker):
+    """Create a mock UDS client."""
+    mock = mocker.create_autospec(UDSClient, spec_set=True)
+    mock.post_callback = mocker.AsyncMock()
+    return mock
+
+
+@pytest.fixture
+def task_executor(task_registry, mock_client):
+    """Create a task executor with mocked client."""
+    return TaskExecutor(task_registry, mock_client)
+
+
+# End-to-end tests
+def test_task_registration_network_payload(task_registry, task_decorator, mocker):
+    """
+    Test that task registration actually sends the
+    correct payload over the network.
+    """
+
+    # Mock the UDSClient class
+    mock_uds_client_class = mocker.patch("render.workflows.runner.UDSClient")
+
+    # Set up the mock instance
+    mock_client_instance = mocker.Mock()
+    mock_uds_client_class.return_value = mock_client_instance
+    mock_client_instance.register_tasks = mocker.AsyncMock(
+        return_value={"status": "success"},
+    )
+    mock_client_instance.disconnect = mocker.AsyncMock()
+
+    # Define tasks with various configurations
+    @task_decorator
+    def simple_task(ctx, x: int) -> int:
+        return x * 2
+
+    @task_decorator(name="custom_name")
+    def renamed_task(ctx, msg: str) -> str:
+        return f"Hello {msg}"
+
+    @task_decorator(
+        options=Options(
+            retry=Retry(max_retries=3, wait_duration_ms=1000, backoff_scaling=1.5)
+        ),
+    )
+    def retry_task(ctx, data: str) -> str:
+        return data.upper()
+
+    # Mock get_task_registry to return our test registry
+    mock_get_registry = mocker.patch("render.workflows.runner.get_task_registry")
+    mock_get_registry.return_value = task_registry
+
+    register("/tmp/test.sock")  # noqa:S108
+
+    # Verify that UDSClient was instantiated with correct socket path
+    mock_uds_client_class.assert_called_once_with("/tmp/test.sock")  # noqa:S108
+
+    # Verify that register_tasks was called exactly once
+    mock_client_instance.register_tasks.assert_called_once()
+
+    # Get the actual payload that was sent
+    sent_tasks = mock_client_instance.register_tasks.call_args[0][0]
+
+    # Verify we have the expected number of tasks
+    assert len(sent_tasks.tasks) == 3
+
+    # Find tasks by name to verify their structure
+    task_by_name = {task.name: task for task in sent_tasks.tasks}
+
+    # Verify simple task
+    assert "simple_task" in task_by_name
+    simple_task_payload = task_by_name["simple_task"]
+    assert simple_task_payload.name == "simple_task"
+    assert isinstance(simple_task_payload.options, TaskOptions)
+
+    # The context is supplied by the runtime, so it is not a declared input
+    assert [p.name for p in simple_task_payload.parameters] == ["x"]
+
+    # Verify renamed task
+    assert "custom_name" in task_by_name
+    renamed_task_payload = task_by_name["custom_name"]
+    assert renamed_task_payload.name == "custom_name"
+    assert isinstance(renamed_task_payload.options, TaskOptions)
+
+    # Verify retry task with options
+    assert "retry_task" in task_by_name
+    retry_task_payload = task_by_name["retry_task"]
+    assert retry_task_payload.name == "retry_task"
+
+    # Verify retry options structure
+    retry_options = retry_task_payload.options.retry
+    assert retry_options.max_retries == 3
+    assert retry_options.wait_duration_ms == 1000
+    assert retry_options.factor == 1.5
+
+
+def test_task_registration_with_timeout_seconds(task_registry, task_decorator, mocker):
+    """
+    Test that task registration correctly serializes timeout_seconds
+    in the network payload.
+    """
+    from render.workflows._callback_models import UNSET
+
+    # Mock the UDSClient class
+    mock_uds_client_class = mocker.patch("render.workflows.runner.UDSClient")
+
+    # Set up the mock instance
+    mock_client_instance = mocker.Mock()
+    mock_uds_client_class.return_value = mock_client_instance
+    mock_client_instance.register_tasks = mocker.AsyncMock(
+        return_value={"status": "success"},
+    )
+    mock_client_instance.disconnect = mocker.AsyncMock()
+
+    # Define a task with timeout_seconds
+    @task_decorator(options=Options(timeout_seconds=120))
+    def timeout_task(ctx, x: int) -> int:
+        return x * 2
+
+    # Define a task without timeout_seconds
+    @task_decorator
+    def no_timeout_task(ctx, x: int) -> int:
+        return x * 3
+
+    # Define a task with both timeout_seconds and retry
+    @task_decorator(
+        options=Options(
+            timeout_seconds=300,
+            retry=Retry(max_retries=2, wait_duration_ms=500, backoff_scaling=1.5),
+        )
+    )
+    def timeout_and_retry_task(ctx, x: int) -> int:
+        return x * 4
+
+    # Mock get_task_registry to return our test registry
+    mock_get_registry = mocker.patch("render.workflows.runner.get_task_registry")
+    mock_get_registry.return_value = task_registry
+
+    register("/tmp/test.sock")  # noqa:S108
+
+    # Get the actual payload that was sent
+    sent_tasks = mock_client_instance.register_tasks.call_args[0][0]
+
+    # Find tasks by name
+    task_by_name = {task.name: task for task in sent_tasks.tasks}
+
+    # Verify task with timeout_seconds
+    assert "timeout_task" in task_by_name
+    timeout_task_payload = task_by_name["timeout_task"]
+    assert timeout_task_payload.options.timeout_seconds == 120
+
+    # Verify task without timeout_seconds has UNSET timeout
+    assert "no_timeout_task" in task_by_name
+    no_timeout_payload = task_by_name["no_timeout_task"]
+    assert no_timeout_payload.options.timeout_seconds is UNSET
+
+    # Verify task with both timeout and retry
+    assert "timeout_and_retry_task" in task_by_name
+    combined_payload = task_by_name["timeout_and_retry_task"]
+    assert combined_payload.options.timeout_seconds == 300
+    assert combined_payload.options.retry is not UNSET
+    assert combined_payload.options.retry.max_retries == 2
+
+
+def test_task_registration_with_dict_retry_config(
+    task_registry, task_decorator, mocker
+):
+    """
+    Test that registration handles dict retry configs passed to Options().
+    A caller may construct Options(retry={...}) with a plain dict instead
+    of a Retry instance. Options.__post_init__ should coerce it.
+    """
+    mock_uds_client_class = mocker.patch("render.workflows.runner.UDSClient")
+    mock_client_instance = mocker.Mock()
+    mock_uds_client_class.return_value = mock_client_instance
+    mock_client_instance.register_tasks = mocker.AsyncMock(
+        return_value={"status": "success"},
+    )
+    mock_client_instance.disconnect = mocker.AsyncMock()
+
+    # Options receives a plain dict instead of a Retry instance
+    dict_retry = {
+        "max_retries": 5,
+        "wait_duration_ms": 2000,
+        "backoff_scaling": 2.0,
+    }
+    options = Options(retry=dict_retry)
+
+    @task_decorator(options=options)
+    def my_task(ctx, x: int) -> int:
+        return x
+
+    mock_get_registry = mocker.patch("render.workflows.runner.get_task_registry")
+    mock_get_registry.return_value = task_registry
+
+    register("/tmp/test.sock")  # noqa:S108
+
+    sent_tasks = mock_client_instance.register_tasks.call_args[0][0]
+    task_payload = sent_tasks.tasks[0]
+
+    assert task_payload.options.retry.max_retries == 5
+    assert task_payload.options.retry.wait_duration_ms == 2000
+    assert task_payload.options.retry.factor == 2.0
+
+
+def test_task_registration_without_retry_config(task_registry, task_decorator, mocker):
+    """
+    Test that tasks with no retry config register successfully. This is the
+    common case that was unaffected by the dict retry bug.
+    """
+    from render.workflows._callback_models import UNSET
+
+    mock_uds_client_class = mocker.patch("render.workflows.runner.UDSClient")
+    mock_client_instance = mocker.Mock()
+    mock_uds_client_class.return_value = mock_client_instance
+    mock_client_instance.register_tasks = mocker.AsyncMock(
+        return_value={"status": "success"},
+    )
+    mock_client_instance.disconnect = mocker.AsyncMock()
+
+    @task_decorator
+    def my_task(ctx, x: int) -> int:
+        return x
+
+    mock_get_registry = mocker.patch("render.workflows.runner.get_task_registry")
+    mock_get_registry.return_value = task_registry
+
+    register("/tmp/test.sock")  # noqa:S108
+
+    sent_tasks = mock_client_instance.register_tasks.call_args[0][0]
+    task_payload = sent_tasks.tasks[0]
+
+    assert task_payload.options.retry is UNSET
+
+
+@pytest.mark.asyncio
+async def test_callback_payloads_with_mocked_client(
+    task_registry,
+    task_decorator,
+    mock_client,
+):
+    """Test that callback payloads are correctly formatted and sent."""
+
+    @task_decorator
+    def test_task(ctx, value: int) -> int:
+        return value * 10
+
+    @task_decorator
+    def failing_task(ctx, should_fail: bool) -> str:
+        if should_fail:
+            raise ValueError("Test failure")
+        return "success"
+
+    # Test success callback
+    executor = TaskExecutor(task_registry, mock_client)
+
+    result = await executor.execute("test_task", [5])
+    assert result == 50
+
+    # Verify success callback was sent with correct payload
+    mock_client.post_callback.assert_called_once()
+    success_payload = mock_client.post_callback.call_args[0][0]
+    assert success_payload.status == Status.SUCCESS
+    assert success_payload.result == 50
+
+    # Reset mock and test error callback
+    mock_client.reset_mock()
+
+    with pytest.raises(ValueError):
+        await executor.execute("failing_task", [True])
+
+    # Verify error callback was sent with correct payload
+    mock_client.post_callback.assert_called_once()
+    error_payload = mock_client.post_callback.call_args[0][0]
+    assert error_payload.status == Status.ERROR
+    assert "Test failure" in error_payload.error

render/workflows/tests/test_executor.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+"""Tests for the task executor functionality."""
+
+from unittest.mock import AsyncMock
+
+import pytest
+
+from render.client.errors import ClientError, ServerError, TimeoutError
+from render.workflows.client import Status, UDSClient, _retry_transient_errors
+from render.workflows.executor import TaskExecutor
+from render.workflows.task import TaskRegistry, create_task_decorator
+
+
+# Fixtures
+@pytest.fixture
+def task_registry():
+    """Create a fresh task registry for each test."""
+    return TaskRegistry()
+
+
+@pytest.fixture
+def task_decorator(task_registry):
+    """Create a task decorator bound to the test registry."""
+    return create_task_decorator(task_registry)
+
+
+@pytest.fixture
+def mock_client(mocker):
+    """Create a mock UDS client."""
+    mock = mocker.create_autospec(UDSClient, spec_set=True)
+    mock.post_callback = mocker.AsyncMock()
+    return mock
+
+
+@pytest.fixture
+def task_executor(task_registry, mock_client):
+    """Create a task executor with mocked client."""
+    return TaskExecutor(task_registry, mock_client)
+
+
+# Basic Task Execution Tests
+@pytest.mark.asyncio
+async def test_simple_task_execution(task_decorator, task_executor, mock_client):
+    """Test executing a simple task without subtasks."""
+
+    @task_decorator
+    def add_numbers(ctx, a: int, b: int) -> int:
+        return a + b
+
+    result = await task_executor.execute("add_numbers", [5, 3])
+
+    assert result == 8
+    mock_client.post_callback.assert_called_once()
+    call_args = mock_client.post_callback.call_args[0][0]
+    assert call_args.status == Status.SUCCESS
+    assert call_args.result == 8
+
+
+@pytest.mark.asyncio
+async def test_task_with_string_result(task_decorator, task_executor, mock_client):
+    """Test task that returns a string."""
+
+    @task_decorator
+    def greet(ctx, name: str) -> str:
+        return f"Hello, {name}!"
+
+    result = await task_executor.execute("greet", ["World"])
+
+    assert result == "Hello, World!"
+    mock_client.post_callback.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_task_execution_error(task_decorator, task_executor, mock_client):
+    """Test task execution that raises an error."""
+
+    @task_decorator
+    def failing_task(ctx, x: int) -> int:
+        if x < 0:
+            raise ValueError("Negative numbers not allowed")
+        return x * 2
+
+    with pytest.raises(ValueError):
+        await task_executor.execute("failing_task", [-5])
+
+    mock_client.post_callback.assert_called_once()
+    call_args = mock_client.post_callback.call_args[0][0]
+    assert call_args.status == Status.ERROR
+    assert "Negative numbers not allowed" in call_args.error
+
+
+@pytest.mark.asyncio
+async def test_nonexistent_task(task_executor, mock_client):
+    """Test executing a task that doesn't exist."""
+    with pytest.raises(ValueError):
+        await task_executor.execute("nonexistent_task", [])
+
+    mock_client.post_callback.assert_called_once()
+    call_args = mock_client.post_callback.call_args[0][0]
+    assert call_args.status == Status.ERROR
+
+
+# Integration Tests
+@pytest.mark.asyncio
+async def test_complex_task_chain(task_registry, task_decorator, mock_client, mocker):
+    """Test a complex chain of task executions."""
+
+    @task_decorator
+    def increment(ctx, x: int) -> int:
+        return x + 1
+
+    @task_decorator
+    def double(ctx, x: int) -> int:
+        return x * 2
+
+    @task_decorator
+    async def complex_calculation(ctx, start: int) -> int:
+        # Reach subtasks through the context
+        step1 = await ctx.run(increment, start)
+        step2 = await ctx.run(double, step1)
+        step3 = await ctx.run(increment, step2)
+        return step3
+
+    # Configure mock to simulate subtask execution
+    def mock_run_subtask(task_name, args):
+        if task_name == "increment":
+            return args[0] + 1
+        elif task_name == "double":
+            return args[0] * 2
+        else:
+            raise ValueError(f"Unknown task: {task_name}")
+
+    mock_client.run_subtask = mocker.AsyncMock(side_effect=mock_run_subtask)
+
+    executor = TaskExecutor(task_registry, mock_client)
+    result = await executor.execute("complex_calculation", [5])
+
+    # Should compute: ((5 + 1) * 2) + 1 = (6 * 2) + 1 = 12 + 1 = 13
+    assert result == 13
+
+
+@pytest.mark.asyncio
+async def test_callback_format(task_registry, task_decorator, mock_client):
+    """Test that callbacks are formatted correctly."""
+
+    @task_decorator
+    def simple_task(ctx, value: str) -> str:
+        return f"processed: {value}"
+
+    executor = TaskExecutor(task_registry, mock_client)
+    await executor.execute("simple_task", ["test"])
+
+    # Check that callback was called with correct format
+    mock_client.post_callback.assert_called_once()
+    call_args = mock_client.post_callback.call_args[0][0]
+    assert call_args.status == Status.SUCCESS
+    assert call_args.result == "processed: test"
+
+
+# UDS Retry Tests
+@pytest.fixture(autouse=False)
+def _no_sleep(mocker):
+    """Patch asyncio.sleep in the client module to avoid real delays."""
+    mocker.patch("render.workflows.client.asyncio.sleep", new_callable=AsyncMock)
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("_no_sleep")
+async def test_retry_on_server_error_then_succeed():
+    """Test that transient ServerError triggers retries and eventually succeeds."""
+    mock_fn = AsyncMock(
+        side_effect=[
+            ServerError("connection refused"),
+            ServerError("connection refused"),
+            "ok",
+        ]
+    )
+    decorated = _retry_transient_errors(mock_fn)
+
+    result = await decorated()
+
+    assert result == "ok"
+    assert mock_fn.call_count == 3
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("_no_sleep")
+async def test_retry_on_timeout_error_then_succeed():
+    """Test that TimeoutError triggers retries and eventually succeeds."""
+    mock_fn = AsyncMock(side_effect=[TimeoutError("timed out"), "ok"])
+    decorated = _retry_transient_errors(mock_fn)
+
+    result = await decorated()
+
+    assert result == "ok"
+    assert mock_fn.call_count == 2
+
+
+@pytest.mark.asyncio
+async def test_no_retry_on_client_error():
+    """Test that ClientError (4xx) is raised immediately without retry."""
+    mock_fn = AsyncMock(side_effect=ClientError("bad request"))
+    decorated = _retry_transient_errors(mock_fn)
+
+    with pytest.raises(ClientError):
+        await decorated()
+
+    assert mock_fn.call_count == 1
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("_no_sleep")
+async def test_retry_exhausted_raises_last_error():
+    """Test that after exhausting all retries, the last error is raised."""
+    mock_fn = AsyncMock(side_effect=ServerError("connection refused"))
+    decorated = _retry_transient_errors(mock_fn)
+
+    with pytest.raises(ServerError):
+        await decorated()
+
+    assert mock_fn.call_count == 25  # _UDS_MAX_RETRIES

render/workflows/tests/test_lazy_imports.py

@@ -0,0 +1,100 @@
+"""Regression guard for the worker import graph.
+
+The worker path (``from render import Workflows``) deliberately avoids
+loading the REST API client, the public_api models, the auto-generated
+callback API, the experimental object storage code, ``httpx``, and
+``attrs`` — none of those are needed to define or run a task. Keeping
+the import graph slim is what keeps the workflow path fast.
+
+If you find yourself adding an eager top-level ``from render.<heavy>
+import ...`` to a module on the worker path, lazy-load it instead — see
+``render/__init__.py`` and ``render/client/__init__.py`` for the
+pattern. If a fresh module truly belongs on the worker path, add it here
+and document why.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+
+# Modules that must NOT be loaded by `from render import Workflows`.
+# Each entry matches the module itself and any submodule under it.
+_FORBIDDEN_ON_WORKER_PATH: tuple[str, ...] = (
+    # The REST API surface (Render / RenderAsync).
+    "render.render",
+    "render.render_async",
+    # The auto-generated REST client + every model in it.
+    "render.public_api",
+    # The hand-written REST client wrappers (Client, WorkflowsService, etc.)
+    # plus client.types and client.sse. Worker-path leaf modules are listed
+    # in _ALLOWED_ON_WORKER_PATH below.
+    "render.client",
+    # Object storage / experimental APIs.
+    "render.experimental",
+    # Third-party HTTP/attribute libraries — only the REST/experimental
+    # paths should pull these in, never the worker path.
+    "httpx",
+    "httpcore",
+    "attr",
+    "attrs",
+)
+
+# Submodules of forbidden packages that ARE allowed on the worker path.
+_ALLOWED_ON_WORKER_PATH: frozenset[str] = frozenset(
+    {
+        # The errors module is shared between the REST client and the
+        # hand-rolled UDS HTTP transport. The package init itself is
+        # lazy, so loading it carries no other cost.
+        "render.client",
+        "render.client.errors",
+    }
+)
+
+
+def _modules_loaded_by(import_statement: str) -> set[str]:
+    """Run the given import in a fresh interpreter and return sys.modules."""
+    code = f"import sys\n{import_statement}\nimport json\nprint(json.dumps(sorted(sys.modules.keys())))\n"
+    result = subprocess.run(  # noqa: S603 — code is a constructed literal, not user input
+        [sys.executable, "-c", code],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return set(json.loads(result.stdout))
+
+
+def test_worker_path_does_not_load_rest_or_experimental_modules() -> None:
+    loaded = _modules_loaded_by("from render import Workflows")
+
+    leaked: list[str] = []
+    for module in sorted(loaded):
+        if module in _ALLOWED_ON_WORKER_PATH:
+            continue
+        for forbidden in _FORBIDDEN_ON_WORKER_PATH:
+            if module == forbidden or module.startswith(forbidden + "."):
+                leaked.append(module)
+                break
+
+    assert not leaked, (
+        "Importing `render.Workflows` eagerly loaded modules that are "
+        "off the worker hot path:\n  - "
+        + "\n  - ".join(leaked)
+        + "\n\nLazy-load the offending imports or move them inside the "
+        "function bodies where they're used. See the module docstring of "
+        "test_lazy_imports.py for the contract."
+    )
+
+
+def test_lazy_attrs_still_resolve_when_explicitly_accessed() -> None:
+    """Smoke check: the lazy machinery must keep `from render import
+    Render` working — otherwise the leak guard above could be satisfied by
+    simply breaking the symbol."""
+    loaded = _modules_loaded_by(
+        "from render import Render, RenderAsync, Workflows; "
+        "assert Render is not None and RenderAsync is not None "
+        "and Workflows is not None"
+    )
+    assert "render.render" in loaded
+    assert "render.render_async" in loaded