render 1.0.1__py3-none-any.whl

render/workflows/tests/test_registration.py

@@ -0,0 +1,293 @@
+#!/usr/bin/env python3
+"""Unit tests for task registration functionality."""
+
+import pytest
+
+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)
+
+
+# Task Registration Tests
+def test_basic_task_registration(task_registry, task_decorator):
+    """Test that basic tasks are registered correctly."""
+
+    @task_decorator
+    def simple_task(ctx, x: int) -> int:
+        return x * 2
+
+    # Verify task is registered
+    task_names = task_registry.get_task_names()
+    assert "simple_task" in task_names
+    assert len(task_names) == 1
+
+    # Verify task info
+    task_info = task_registry.get_task("simple_task")
+    assert task_info is not None
+    assert task_info.func.__name__ == "simple_task"
+    # Tasks always get an Options object, but with retry=None when no options provided
+    if task_info.options:
+        assert task_info.options.retry is None
+
+
+def test_context_parameter_is_not_a_declared_input(task_registry, task_decorator):
+    """The leading context is supplied by the runtime, not by the caller."""
+
+    @task_decorator
+    def simple_task(ctx, x: int, flag: bool = False) -> int:
+        return x * 2
+
+    task_info = task_registry.get_task("simple_task")
+    assert [p.name for p in task_info.parameters] == ["x", "flag"]
+    assert [p.type_hint for p in task_info.parameters] == ["int", "bool"]
+    assert [p.has_default for p in task_info.parameters] == [False, True]
+
+
+def test_task_with_only_a_context_has_no_declared_inputs(task_registry, task_decorator):
+    """A task that takes nothing but the context registers zero parameters."""
+
+    @task_decorator
+    def ping(ctx) -> str:
+        return "pong"
+
+    assert task_registry.get_task("ping").parameters == []
+
+
+def test_task_without_a_context_parameter_is_rejected(task_decorator):
+    """A task must be able to receive a context as its first argument."""
+
+    with pytest.raises(ValueError, match="must accept a TaskContext"):
+
+        @task_decorator
+        def no_context() -> int:
+            return 1
+
+
+def test_task_with_keyword_only_first_parameter_is_rejected(task_decorator):
+    """The context is passed positionally, so it cannot be keyword-only."""
+
+    with pytest.raises(ValueError, match="keyword-only"):
+
+        @task_decorator
+        def keyword_only(*, ctx) -> int:
+            return 1
+
+
+def test_definition_exposes_the_function_for_in_process_invocation(task_decorator):
+    """A definition hands back the undecorated function for direct calls."""
+
+    @task_decorator
+    def square(ctx, a: int) -> int:
+        return a * a
+
+    assert square.func(object(), 5) == 25
+    assert square.name == "square"
+
+
+def test_function_attributes_do_not_overwrite_definition_fields(task_decorator):
+    """
+    A function carrying its own `name` attribute must not clobber the task name.
+
+    functools.update_wrapper copies the function's __dict__ over the definition,
+    so the definition's own fields have to be assigned after it runs. This test
+    pins that ordering.
+    """
+
+    def tagged(ctx, a: int) -> int:
+        return a
+
+    tagged.name = "attribute-from-the-function"
+    tagged.func = "also-not-ours"
+
+    definition = task_decorator(tagged)
+
+    assert definition.name == "tagged"
+    assert definition.func is tagged
+
+
+def test_definition_is_not_callable(task_decorator):
+    """Running a task goes through a context, so a definition is inert."""
+
+    @task_decorator
+    def square(ctx, a: int) -> int:
+        return a * a
+
+    assert not callable(square)
+    with pytest.raises(TypeError):
+        square(object(), 5)
+
+
+def test_custom_name_registration(task_registry, task_decorator):
+    """Test task registration with custom name."""
+
+    @task_decorator(name="custom_name")
+    def original_function(ctx, data: str) -> str:
+        return data.upper()
+
+    # Verify custom name is used
+    task_names = task_registry.get_task_names()
+    assert "custom_name" in task_names
+    assert "original_function" not in task_names
+
+    task_info = task_registry.get_task("custom_name")
+    assert task_info.func.__name__ == "original_function"
+
+
+def test_duplicate_task_registration(task_registry, task_decorator):
+    """Test that duplicate task registration raises an error."""
+
+    @task_decorator
+    def duplicate_task(ctx, value: int) -> int:
+        return value + 1
+
+    with pytest.raises(ValueError, match="Task 'duplicate_task' already registered"):
+
+        @task_decorator
+        def duplicate_task(ctx, value: int) -> int:  # noqa: F811
+            return value + 2
+
+
+def test_task_registration_with_options_object():
+    """Test task registration with different Options configurations."""
+    registry = TaskRegistry()
+    task_decorator = create_task_decorator(registry)
+
+    # Task with None options
+    @task_decorator(options=None)
+    def task_with_none_options(ctx, x: int) -> int:
+        return x
+
+    # Task with empty options
+    @task_decorator(options=Options())
+    def task_with_empty_options(ctx, x: int) -> int:
+        return x
+
+    # Task with only retry options
+    @task_decorator(
+        options=Options(
+            retry=Retry(max_retries=1, wait_duration_ms=500, backoff_scaling=1.0)
+        ),
+    )
+    def task_with_retry_only(ctx, x: int) -> int:
+        return x
+
+    # Verify all tasks registered correctly
+    task_names = registry.get_task_names()
+    assert len(task_names) == 3
+
+    # Verify options are handled correctly
+    none_task = registry.get_task("task_with_none_options")
+    assert none_task.options is not None  # Always gets an Options object
+    assert none_task.options.retry is None
+
+    empty_task = registry.get_task("task_with_empty_options")
+    assert empty_task.options is not None
+    assert empty_task.options.retry is None
+
+    retry_task = registry.get_task("task_with_retry_only")
+    assert retry_task.options is not None
+    assert retry_task.options.retry is not None
+    assert retry_task.options.retry.max_retries == 1
+
+
+def test_options_coerces_dict_retry_to_retry():
+    """
+    Test that Options.__post_init__ coerces a dict retry config to a Retry instance.
+    """
+    options = Options(
+        retry={"max_retries": 5, "wait_duration_ms": 2000, "backoff_scaling": 2.0}
+    )
+    assert isinstance(options.retry, Retry)
+    assert options.retry.max_retries == 5
+    assert options.retry.wait_duration_ms == 2000
+    assert options.retry.backoff_scaling == 2.0
+
+
+def test_options_rejects_incomplete_dict_retry():
+    """Test that dict-to-Retry coercion raises KeyError for missing required keys."""
+    with pytest.raises(KeyError):
+        Options(retry={})
+
+
+def test_task_registration_preserves_function_attributes(task_registry, task_decorator):
+    """Test that task registration preserves original function attributes."""
+
+    @task_decorator
+    def documented_task(ctx, x: int) -> int:
+        """This is a documented function."""
+        return x * 3
+
+    # Verify the original function attributes are preserved
+    assert documented_task.__name__ == "documented_task"
+    assert documented_task.__doc__ == "This is a documented function."
+
+
+def test_task_registration_with_timeout_seconds():
+    """Test task registration with timeout_seconds option."""
+    registry = TaskRegistry()
+    task_decorator = create_task_decorator(registry)
+
+    # Task with timeout_seconds
+    @task_decorator(options=Options(timeout_seconds=120))
+    def task_with_timeout(ctx, x: int) -> int:
+        return x
+
+    # Verify task registered correctly
+    task_names = registry.get_task_names()
+    assert "task_with_timeout" in task_names
+
+    # Verify timeout_seconds is set
+    task_info = registry.get_task("task_with_timeout")
+    assert task_info.options is not None
+    assert task_info.options.timeout_seconds == 120
+
+
+def test_task_registration_without_timeout_seconds():
+    """Test task registration without timeout_seconds defaults to None."""
+    registry = TaskRegistry()
+    task_decorator = create_task_decorator(registry)
+
+    @task_decorator
+    def task_without_timeout(ctx, x: int) -> int:
+        return x
+
+    task_info = registry.get_task("task_without_timeout")
+    assert task_info.options is not None
+    assert task_info.options.timeout_seconds is None
+
+
+def test_task_registration_with_timeout_and_retry():
+    """Test task registration with both timeout_seconds and retry options."""
+    registry = TaskRegistry()
+    task_decorator = create_task_decorator(registry)
+
+    @task_decorator(
+        options=Options(
+            timeout_seconds=300,
+            retry=Retry(max_retries=3, wait_duration_ms=1000, backoff_scaling=2.0),
+        )
+    )
+    def task_with_both(ctx, x: int) -> int:
+        return x
+
+    task_info = registry.get_task("task_with_both")
+    assert task_info.options is not None
+    assert task_info.options.timeout_seconds == 300
+    assert task_info.options.retry is not None
+    assert task_info.options.retry.max_retries == 3

render/workflows/tests/test_translate_errors.py

@@ -0,0 +1,126 @@
+"""Unit tests for the ``_translate_errors`` decorator in client.py."""
+
+from __future__ import annotations
+
+import http.client
+import json
+
+import pytest
+
+from render.client.errors import (
+    ClientError,
+    RateLimitError,
+    RenderError,
+    ServerError,
+)
+from render.client.errors import TimeoutError as SdkTimeoutError
+from render.workflows._uds_http import HttpStatusError
+from render.workflows.client import _translate_errors
+
+
+def _wrap_raises(operation: str, exc: BaseException):
+    """Build a ``_translate_errors``-decorated coroutine that raises ``exc``."""
+
+    @_translate_errors(operation)
+    async def fn():
+        raise exc
+
+    return fn
+
+
+@pytest.mark.asyncio
+async def test_builtin_timeout_becomes_sdk_timeout():
+    fn = _wrap_raises("get input", TimeoutError("read timed out"))
+    with pytest.raises(SdkTimeoutError) as exc_info:
+        await fn()
+    assert "get input timed out" in str(exc_info.value)
+    assert "read timed out" in str(exc_info.value)
+
+
+@pytest.mark.asyncio
+async def test_connection_refused_becomes_server_error():
+    fn = _wrap_raises("get input", ConnectionRefusedError("no such file"))
+    with pytest.raises(ServerError) as exc_info:
+        await fn()
+    assert "get input failed to connect" in str(exc_info.value)
+
+
+@pytest.mark.asyncio
+async def test_file_not_found_becomes_server_error():
+    fn = _wrap_raises("get input", FileNotFoundError("missing socket"))
+    with pytest.raises(ServerError):
+        await fn()
+
+
+@pytest.mark.asyncio
+async def test_generic_oserror_becomes_server_error():
+    fn = _wrap_raises("get input", OSError("network blip"))
+    with pytest.raises(ServerError) as exc_info:
+        await fn()
+    assert "get input network error" in str(exc_info.value)
+
+
+@pytest.mark.asyncio
+async def test_http_exception_becomes_server_error():
+    fn = _wrap_raises("get input", http.client.BadStatusLine("garbled\r\n"))
+    with pytest.raises(ServerError) as exc_info:
+        await fn()
+    assert "get input got invalid HTTP response" in str(exc_info.value)
+
+
+@pytest.mark.asyncio
+async def test_4xx_status_becomes_client_error():
+    fn = _wrap_raises("run subtask", HttpStatusError(400, b'{"message": "bad input"}'))
+    with pytest.raises(ClientError) as exc_info:
+        await fn()
+    msg = str(exc_info.value)
+    assert "run subtask failed with status 400" in msg
+    assert "bad input" in msg
+
+
+@pytest.mark.asyncio
+async def test_429_status_becomes_rate_limit_error():
+    fn = _wrap_raises("get input", HttpStatusError(429, b""))
+    with pytest.raises(RateLimitError) as exc_info:
+        await fn()
+    assert "429" in str(exc_info.value)
+
+
+@pytest.mark.asyncio
+async def test_5xx_status_becomes_server_error():
+    fn = _wrap_raises("get input", HttpStatusError(503, b'{"error": "boom"}'))
+    with pytest.raises(ServerError) as exc_info:
+        await fn()
+    msg = str(exc_info.value)
+    assert "503" in msg
+    assert "boom" in msg
+
+
+@pytest.mark.asyncio
+async def test_status_error_with_non_json_body_uses_raw_text():
+    fn = _wrap_raises("get input", HttpStatusError(503, b"raw error string"))
+    with pytest.raises(ServerError) as exc_info:
+        await fn()
+    assert "raw error string" in str(exc_info.value)
+
+
+@pytest.mark.asyncio
+async def test_json_decode_error_becomes_render_error():
+    fn = _wrap_raises("get input", json.JSONDecodeError("expecting value", "doc", 0))
+    with pytest.raises(RenderError) as exc_info:
+        await fn()
+    msg = str(exc_info.value)
+    assert "get input failed" in msg
+    assert "non-JSON response" in msg
+
+
+@pytest.mark.asyncio
+async def test_render_error_propagates_unchanged():
+    """RenderError subclasses raised inside the wrapped function (e.g.,
+    a method's own "unexpected response shape" guard) pass through with
+    their original identity — no re-wrapping."""
+    original = ClientError("already typed")
+    fn = _wrap_raises("op", original)
+    with pytest.raises(ClientError) as exc_info:
+        await fn()
+    assert exc_info.value is original

render/workflows/tests/test_uds_http.py

@@ -0,0 +1,199 @@
+"""Integration tests for the hand-rolled UDS HTTP transport.
+
+These tests bring up a real ``aiohttp`` server bound to a Unix Domain
+Socket so they exercise the actual ``http.client``-based transport
+end-to-end against a real socket.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import tempfile
+
+import pytest
+from aiohttp import web
+
+from render.workflows._uds_http import HttpStatusError, request_json
+
+# Note: we deliberately do NOT import ``TimeoutError`` from
+# render.client.errors here, so the built-in ``TimeoutError`` stays
+# in scope for the timeout assertion below (socket.timeout aliases it).
+
+
+@pytest.fixture
+def socket_path(tmp_path):
+    """Returns a path suitable for binding a UDS server to."""
+    # tmp_path can be longer than the OS-level UDS path limit (~104 chars on
+    # macOS), so fall back to a short path under /tmp when needed.
+    candidate = str(tmp_path / "render-sdk-test.sock")
+    if len(candidate) >= 100:
+        with tempfile.NamedTemporaryFile(
+            prefix="render-sdk-", suffix=".sock", delete=True
+        ) as f:
+            candidate = f.name
+        if os.path.exists(candidate):
+            os.unlink(candidate)
+    return candidate
+
+
+async def _start_server(handler, socket_path: str) -> web.AppRunner:
+    app = web.Application()
+    app.router.add_route("*", "/{tail:.*}", handler)
+    runner = web.AppRunner(app)
+    await runner.setup()
+    site = web.UnixSite(runner, socket_path)
+    await site.start()
+    return runner
+
+
+@pytest.mark.asyncio
+async def test_request_json_get_returns_parsed_body(socket_path):
+    async def handler(request: web.Request) -> web.Response:
+        assert request.method == "GET"
+        assert request.path == "/input"
+        return web.json_response({"task_name": "t", "input": "blob"})
+
+    runner = await _start_server(handler, socket_path)
+    try:
+        result = await request_json(
+            socket_path,
+            "GET",
+            "/input",
+            body=None,
+            user_agent="test",
+            timeout=5.0,
+        )
+        assert result == {"task_name": "t", "input": "blob"}
+    finally:
+        await runner.cleanup()
+
+
+@pytest.mark.asyncio
+async def test_request_json_post_sends_json_body(socket_path):
+    received: dict = {}
+
+    async def handler(request: web.Request) -> web.Response:
+        received["method"] = request.method
+        received["path"] = request.path
+        received["content_type"] = request.headers.get("Content-Type")
+        received["body"] = await request.json()
+        return web.json_response({"task_run_id": "tr-1"})
+
+    runner = await _start_server(handler, socket_path)
+    try:
+        result = await request_json(
+            socket_path,
+            "POST",
+            "/run-subtask",
+            body={"task_name": "x", "input": "y"},
+            user_agent="test",
+            timeout=5.0,
+        )
+        assert result == {"task_run_id": "tr-1"}
+        assert received["method"] == "POST"
+        assert received["path"] == "/run-subtask"
+        assert received["content_type"] == "application/json"
+        assert received["body"] == {"task_name": "x", "input": "y"}
+    finally:
+        await runner.cleanup()
+
+
+@pytest.mark.asyncio
+async def test_request_json_empty_response_returns_none(socket_path):
+    async def handler(request: web.Request) -> web.Response:
+        return web.Response(status=200, body=b"")
+
+    runner = await _start_server(handler, socket_path)
+    try:
+        result = await request_json(
+            socket_path,
+            "POST",
+            "/callback",
+            body={"complete": {"output": "ok"}},
+            user_agent="test",
+            timeout=5.0,
+        )
+        assert result is None
+    finally:
+        await runner.cleanup()
+
+
+@pytest.mark.asyncio
+async def test_request_json_error_status_raises_http_status_error(socket_path):
+    async def handler(request: web.Request) -> web.Response:
+        return web.json_response({"message": "bad input"}, status=400)
+
+    runner = await _start_server(handler, socket_path)
+    try:
+        with pytest.raises(HttpStatusError) as exc_info:
+            await request_json(
+                socket_path,
+                "POST",
+                "/run-subtask",
+                body={},
+                user_agent="test",
+                timeout=5.0,
+            )
+        assert exc_info.value.status == 400
+        assert b"bad input" in exc_info.value.body
+    finally:
+        await runner.cleanup()
+
+
+@pytest.mark.asyncio
+async def test_request_json_connection_refused_raises_oserror():
+    # Path that doesn't exist -> connection refused / no such file. The
+    # transport propagates the OSError unchanged; translation is the
+    # caller's responsibility.
+    with pytest.raises((ConnectionError, FileNotFoundError)):
+        await request_json(
+            "/tmp/does-not-exist-render-sdk.sock",  # noqa: S108
+            "GET",
+            "/input",
+            body=None,
+            user_agent="test",
+            timeout=5.0,
+        )
+
+
+@pytest.mark.asyncio
+async def test_request_json_non_json_body_raises_json_decode_error(socket_path):
+    async def handler(request: web.Request) -> web.Response:
+        return web.Response(status=200, body=b"not json", content_type="text/plain")
+
+    runner = await _start_server(handler, socket_path)
+    try:
+        with pytest.raises(json.JSONDecodeError):
+            await request_json(
+                socket_path,
+                "GET",
+                "/input",
+                body=None,
+                user_agent="test",
+                timeout=5.0,
+            )
+    finally:
+        await runner.cleanup()
+
+
+@pytest.mark.asyncio
+async def test_request_json_timeout_raises_timeout_error(socket_path):
+    async def handler(request: web.Request) -> web.Response:
+        await asyncio.sleep(2.0)
+        return web.json_response({})
+
+    runner = await _start_server(handler, socket_path)
+    try:
+        with pytest.raises(TimeoutError):
+            await request_json(
+                socket_path,
+                "GET",
+                "/input",
+                body=None,
+                user_agent="test",
+                timeout=0.2,
+            )
+    finally:
+        await runner.cleanup()

render/workflows/tests/test_version.py

@@ -0,0 +1,15 @@
+"""Guard against version drift between render.__version__ and pyproject.toml.
+
+The two values are maintained separately and once diverged for months
+(__version__ reported 0.8.0 while the distribution was published as 1.0.0).
+importlib.metadata reads the installed dist-info, which comes from
+pyproject.toml, so this test fails whenever one is bumped without the other.
+"""
+
+import importlib.metadata
+
+import render
+
+
+def test_version_matches_distribution_metadata() -> None:
+    assert render.__version__ == importlib.metadata.version("render")