render 1.0.1__py3-none-any.whl

render/client/tests/test_client.py

@@ -0,0 +1,379 @@
+#!/usr/bin/env python3
+"""Unit tests for the Render REST API client functionality."""
+
+import datetime
+import json
+
+import pytest
+
+from render.client import Client, ListTaskRunsParams, WorkflowsService
+from render.client.errors import ClientError, ServerError
+from render.client.workflows import AwaitableTaskRun
+from render.public_api.models.error import Error
+from render.public_api.models.task_run import TaskRun
+from render.public_api.models.task_run_details import TaskRunDetails
+from render.public_api.models.task_run_status import TaskRunStatus
+from render.public_api.types import Response
+
+
+# Fixtures
+@pytest.fixture
+def mock_task_run(mocker):
+    return TaskRun(
+        id="trn-test123",
+        status=TaskRunStatus.RUNNING,
+        completed_at=None,
+        parent_task_run_id=None,
+        root_task_run_id=None,
+        retries=0,
+        attempts=[],
+        started_at=None,
+        task_id=None,
+    )
+
+
+@pytest.fixture
+def mock_task_run_details(mocker):
+    return TaskRunDetails(
+        id="trn-test123",
+        status=TaskRunStatus.COMPLETED,
+        error=None,
+        completed_at=datetime.datetime.now(),
+        results=[42],
+        input_=[42],
+        parent_task_run_id=None,
+        root_task_run_id=None,
+        retries=0,
+        attempts=[],
+        started_at=None,
+        task_id=None,
+    )
+
+
+@pytest.fixture
+def mock_authenticated_client(mocker):
+    """Create a mock authenticated client."""
+    client = mocker.Mock()
+    client._base_url = "https://api.test.com/v1"
+    return client
+
+
+@pytest.fixture
+def client(mocker, mock_authenticated_client):
+    """Create a Client instance with mocked dependencies."""
+    mocker.patch(
+        "render.client.client.AuthenticatedClient",
+        return_value=mock_authenticated_client,
+    )
+    return Client("test-token", base_url="https://api.test.com")
+
+
+@pytest.fixture
+def workflows_service(client):
+    """Create a WorkflowsService instance."""
+    return client.workflows
+
+
+@pytest.fixture
+def mock_cancel_task_run_asyncio(mocker):
+    return mocker.patch(
+        "render.public_api.api.workflow_tasks_beta.cancel_task_run.asyncio_detailed"
+    )
+
+
+@pytest.fixture
+def mock_list_task_runs_asyncio(mocker):
+    return mocker.patch(
+        "render.public_api.api.workflow_tasks_beta.list_task_runs.asyncio_detailed"
+    )
+
+
+@pytest.fixture
+def mock_create_task_asyncio(mocker):
+    return mocker.patch(
+        "render.public_api.api.workflow_tasks_beta.create_task.asyncio_detailed"
+    )
+
+
+@pytest.fixture
+def mock_get_task_run_asyncio(mocker):
+    return mocker.patch(
+        "render.public_api.api.workflow_tasks_beta.get_task_run.asyncio_detailed"
+    )
+
+
+@pytest.mark.asyncio
+async def test_start_task_success(
+    mock_create_task_asyncio, workflows_service, mock_task_run
+):
+    """Test successful task start."""
+    mock_create_task_asyncio.return_value = Response(
+        status_code=202, content=b"", headers={}, parsed=mock_task_run
+    )
+
+    result = await workflows_service.start_task("test-task", {"input": "data"})
+
+    assert isinstance(result, AwaitableTaskRun)
+    assert result.id == "trn-test123"
+    mock_create_task_asyncio.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_start_task_failure(mock_create_task_asyncio, workflows_service):
+    """Test task start failure."""
+
+    error = Error(message="Task creation failed")
+    mock_create_task_asyncio.return_value = Response(
+        status_code=400, content=b"", headers={}, parsed=error
+    )
+
+    with pytest.raises(ClientError, match="create task failed: Task creation failed"):
+        await workflows_service.start_task("test-task", {"input": "data"})
+
+
+@pytest.mark.asyncio
+async def test_run_task_returns_task_run_details(
+    mocker,
+    mock_create_task_asyncio,
+    workflows_service,
+    mock_task_run,
+    mock_task_run_details,
+):
+    """Test that run_task starts a task and waits for completion."""
+    mock_create_task_asyncio.return_value = Response(
+        status_code=202, content=b"", headers={}, parsed=mock_task_run
+    )
+    mocker.patch.object(
+        AwaitableTaskRun,
+        "_wait_for_completion",
+        new_callable=mocker.AsyncMock,
+        return_value=mock_task_run_details,
+    )
+
+    result = await workflows_service.run_task("test-task", {"input": "data"})
+
+    assert isinstance(result, TaskRunDetails)
+    assert result.id == "trn-test123"
+    assert result.status.value == TaskRunStatus.COMPLETED
+
+
+@pytest.mark.asyncio
+async def test_run_task_failure(mock_create_task_asyncio, workflows_service):
+    """Test that run_task propagates errors from start_task."""
+    error = Error(message="Task creation failed")
+    mock_create_task_asyncio.return_value = Response(
+        status_code=400, content=b"", headers={}, parsed=error
+    )
+
+    with pytest.raises(ClientError, match="create task failed: Task creation failed"):
+        await workflows_service.run_task("test-task", {"input": "data"})
+
+
+@pytest.mark.asyncio
+async def test_get_task_run_success(
+    mock_get_task_run_asyncio, workflows_service, mock_task_run_details
+):
+    """Test successful task run retrieval."""
+    mock_get_task_run_asyncio.return_value = Response(
+        status_code=200, content=b"", headers={}, parsed=mock_task_run_details
+    )
+
+    result = await workflows_service.get_task_run("trn-test123")
+
+    assert result.id == "trn-test123"
+    assert result.status.value == TaskRunStatus.COMPLETED
+    mock_get_task_run_asyncio.assert_called_once_with(
+        client=workflows_service.client.internal, task_run_id="trn-test123"
+    )
+
+
+@pytest.mark.asyncio
+async def test_get_task_run_failure(mock_get_task_run_asyncio, workflows_service):
+    """Test task run retrieval failure."""
+    error = Error(message="Task not found")
+    mock_get_task_run_asyncio.return_value = Response(
+        status_code=400, content=b"", headers={}, parsed=error
+    )
+
+    with pytest.raises(ClientError, match="get task run failed: Task not found"):
+        await workflows_service.get_task_run("trn-test123")
+
+
+@pytest.mark.asyncio
+async def test_cancel_task_run_success(mock_cancel_task_run_asyncio, workflows_service):
+    """Test successful task run cancellation."""
+    mock_cancel_task_run_asyncio.return_value = Response(
+        status_code=204, content=b"", headers={}, parsed=None
+    )
+
+    await workflows_service.cancel_task_run("trn-test123")
+
+    mock_cancel_task_run_asyncio.assert_called_once_with(
+        client=workflows_service.client.internal, task_run_id="trn-test123"
+    )
+
+
+@pytest.mark.asyncio
+async def test_cancel_task_run_failure(mock_cancel_task_run_asyncio, workflows_service):
+    """Test task run cancellation failure."""
+    error = Error(message="Cannot cancel task")
+    mock_cancel_task_run_asyncio.return_value = Response(
+        status_code=400, content=b"", headers={}, parsed=error
+    )
+
+    with pytest.raises(ClientError, match="cancel task run failed: Cannot cancel task"):
+        await workflows_service.cancel_task_run("trn-test123")
+
+
+@pytest.mark.asyncio
+async def test_list_task_runs_success(
+    mocker, mock_list_task_runs_asyncio, workflows_service, mock_task_run
+):
+    """Test successful task runs listing."""
+    task_runs = [mock_task_run]
+    mock_list_task_runs_asyncio.return_value = Response(
+        status_code=200, content=b"", headers={}, parsed=task_runs
+    )
+
+    params = ListTaskRunsParams(limit=5, owner_id="test-owner")
+    result = await workflows_service.list_task_runs(params)
+
+    assert len(result) == 1
+    assert result[0].id == "trn-test123"
+    mock_list_task_runs_asyncio.assert_called_once_with(
+        client=workflows_service.client.internal,
+        limit=5,
+        cursor=mocker.ANY,
+        owner_id="test-owner",
+    )
+
+
+@pytest.fixture
+def mock_workflows_service(mocker, client):
+    """Create a mock workflows service."""
+    return mocker.Mock(spec=WorkflowsService, client=client)
+
+
+@pytest.fixture
+def awaitable_task_run(mock_task_run, mock_workflows_service):
+    """Create an AwaitableTaskRun instance."""
+    return AwaitableTaskRun(mock_task_run, mock_workflows_service)
+
+
+def test_task_run_properties(awaitable_task_run):
+    """Test AwaitableTaskRun properties."""
+    assert awaitable_task_run.id == "trn-test123"
+    assert awaitable_task_run.status == TaskRunStatus.RUNNING
+
+
+@pytest.mark.parametrize(
+    "status,expected",
+    [
+        (TaskRunStatus.RUNNING, False),
+        (TaskRunStatus.COMPLETED, True),
+        (TaskRunStatus.FAILED, True),
+        (TaskRunStatus.CANCELED, True),
+    ],
+)
+def test_is_terminal_status(mock_task_run, mock_workflows_service, status, expected):
+    """Test terminal status detection."""
+    mock_task_run.status = status
+    awaitable_task_run = AwaitableTaskRun(mock_task_run, mock_workflows_service)
+    assert awaitable_task_run.is_terminal_status() == expected
+
+
+@pytest.mark.asyncio
+async def test_await_already_completed_task(
+    mocker, mock_task_run, mock_workflows_service, mock_task_run_details
+):
+    """Test awaiting an already completed task."""
+    # Set task as completed
+    mock_task_run.status = TaskRunStatus.COMPLETED
+    awaitable_task_run = AwaitableTaskRun(mock_task_run, mock_workflows_service)
+
+    # Mock the get_task_run call
+    mock_workflows_service.get_task_run = mocker.AsyncMock(
+        return_value=mock_task_run_details
+    )
+
+    result = await awaitable_task_run
+
+    assert result.id == "trn-test123"
+    assert result.status.value == TaskRunStatus.COMPLETED
+    mock_workflows_service.get_task_run.assert_called_once_with("trn-test123")
+
+
+@pytest.fixture
+def mock_httpx_stream(mocker):
+    """Mock httpx.AsyncClient to return a controllable SSE stream.
+
+    Returns a list that tests populate with bytes chunks before calling
+    task_run_events(). The mock wires up the nested async context managers
+    (AsyncClient → stream → response.aiter_bytes).
+    """
+    chunks: list[bytes] = []
+
+    async def aiter_bytes():
+        for chunk in chunks:
+            yield chunk
+
+    mock_response = mocker.Mock()
+    mock_response.status_code = 200
+    mock_response.aiter_bytes = aiter_bytes
+
+    stream_cm = mocker.AsyncMock()
+    stream_cm.__aenter__.return_value = mock_response
+
+    mock_http_client = mocker.Mock()
+    mock_http_client.stream.return_value = stream_cm
+
+    client_cm = mocker.AsyncMock()
+    client_cm.__aenter__.return_value = mock_http_client
+
+    mocker.patch("render.client.workflows.httpx.AsyncClient", return_value=client_cm)
+
+    return chunks, mock_response
+
+
+@pytest.mark.asyncio
+async def test_task_run_events_yields_events(workflows_service, mock_httpx_stream):
+    """Test that task_run_events streams and yields TaskRunDetails."""
+    chunks, _ = mock_httpx_stream
+
+    details = TaskRunDetails(
+        id="trn-test123",
+        task_id="tsk-test123",
+        status=TaskRunStatus.COMPLETED,
+        results=[42],
+        input_=[],
+        parent_task_run_id=None,
+        root_task_run_id=None,
+        retries=0,
+        attempts=[],
+    )
+    sse_payload = json.dumps(details.to_dict()).encode()
+    chunks.append(b"event: task.completed\ndata: " + sse_payload + b"\n\n")
+
+    events = []
+    async for event in workflows_service.task_run_events(["trn-test123"]):
+        events.append(event)
+
+    assert len(events) == 1
+    assert events[0].id == "trn-test123"
+    assert events[0].status.value == TaskRunStatus.COMPLETED
+
+
+@pytest.mark.asyncio
+async def test_task_run_events_raises_on_http_error(
+    workflows_service, mock_httpx_stream
+):
+    """Test that task_run_events raises on HTTP errors."""
+    _, mock_response = mock_httpx_stream
+
+    mock_response.status_code = 500
+    mock_response.text = "Internal Server Error"
+    mock_response.json.return_value = {"message": "Internal Server Error"}
+
+    with pytest.raises(ServerError):
+        async for _ in workflows_service.task_run_events(["trn-test123"]):
+            pass

render/client/tests/test_method_parity.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""Method parity tests between async and sync service classes.
+
+These tests catch drift: a method added to one class but not its sync
+counterpart, or a new async class added without a sync counterpart.
+"""
+
+import inspect
+
+import pytest
+
+from render.client.workflows import WorkflowsService
+from render.client.workflows_sync import SyncWorkflowsService
+from render.experimental.experimental import ExperimentalService, StorageService
+from render.experimental.experimental_sync import (
+    SyncExperimentalService,
+    SyncStorageService,
+)
+from render.experimental.object.api import ObjectApi
+from render.experimental.object.api_sync import SyncObjectApi
+from render.experimental.object.client import ObjectClient, ScopedObjectClient
+from render.experimental.object.client_sync import (
+    SyncObjectClient,
+    SyncScopedObjectClient,
+)
+from render.experimental.sandbox.api import SandboxApi
+from render.experimental.sandbox.api_sync import SyncSandboxApi
+from render.experimental.sandbox.client import SandboxClient
+from render.experimental.sandbox.client_sync import SyncSandboxClient
+
+# All async/sync class pairs. Add new pairs here when creating a new service.
+ASYNC_SYNC_PAIRS = [
+    (WorkflowsService, SyncWorkflowsService),
+    (ExperimentalService, SyncExperimentalService),
+    (StorageService, SyncStorageService),
+    (ObjectApi, SyncObjectApi),
+    (ObjectClient, SyncObjectClient),
+    (ScopedObjectClient, SyncScopedObjectClient),
+    (SandboxApi, SyncSandboxApi),
+    (SandboxClient, SyncSandboxClient),
+]
+
+# Modules that contain async service classes. If you add a new module with
+# async services, add it here so the discovery test catches missing pairs.
+_ASYNC_SERVICE_MODULES = [
+    "render.client.workflows",
+    "render.experimental.experimental",
+    "render.experimental.object.api",
+    "render.experimental.object.client",
+    "render.experimental.sandbox.api",
+    "render.experimental.sandbox.client",
+]
+
+
+def _public_methods(cls):
+    return {
+        name
+        for name in dir(cls)
+        if not name.startswith("_") and callable(getattr(cls, name))
+    }
+
+
+def _assert_parity(async_cls, sync_cls):
+    async_methods = _public_methods(async_cls)
+    sync_methods = _public_methods(sync_cls)
+    assert async_methods == sync_methods, (
+        f"Method mismatch between {async_cls.__name__} and {sync_cls.__name__}.\n"
+        f"  Only in async: {async_methods - sync_methods}\n"
+        f"  Only in sync: {sync_methods - async_methods}"
+    )
+
+
+def _has_async_methods(cls):
+    """Check if a class has any public async methods."""
+    return any(
+        inspect.iscoroutinefunction(getattr(cls, name))
+        for name in dir(cls)
+        if not name.startswith("_") and callable(getattr(cls, name))
+    )
+
+
+@pytest.mark.parametrize(
+    "async_cls,sync_cls",
+    ASYNC_SYNC_PAIRS,
+    ids=[f"{a.__name__}" for a, _ in ASYNC_SYNC_PAIRS],
+)
+def test_method_parity(async_cls, sync_cls):
+    """Each async class must have the same public methods as its sync counterpart."""
+    _assert_parity(async_cls, sync_cls)
+
+
+def test_all_async_classes_have_sync_counterparts():
+    """Every async service class in the known modules must appear in ASYNC_SYNC_PAIRS.
+
+    If this test fails, you added a new async service class without adding it
+    to ASYNC_SYNC_PAIRS above (and without creating its sync counterpart).
+    """
+    import importlib
+
+    tested_async_classes = {pair[0] for pair in ASYNC_SYNC_PAIRS}
+    missing = []
+
+    for module_path in _ASYNC_SERVICE_MODULES:
+        module = importlib.import_module(module_path)
+        for name in dir(module):
+            obj = getattr(module, name)
+            if (
+                inspect.isclass(obj)
+                and obj.__module__ == module_path
+                and _has_async_methods(obj)
+                and obj not in tested_async_classes
+            ):
+                missing.append(f"{module_path}.{name}")
+
+    assert not missing, (
+        f"Async service classes without sync parity tests: {missing}. "
+        f"Add them to ASYNC_SYNC_PAIRS in test_method_parity.py."
+    )

render/client/tests/test_render.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""Unit tests for the Render entry point."""
+
+import pytest
+
+from render.client.workflows_sync import SyncWorkflowsService
+from render.experimental.experimental_sync import SyncExperimentalService
+from render.render import Render
+
+
+@pytest.fixture
+def mock_authenticated_client(mocker):
+    client = mocker.Mock()
+    client._base_url = "https://api.test.com/v1"
+    return client
+
+
+@pytest.fixture
+def render(mocker, mock_authenticated_client):
+    mocker.patch(
+        "render.client.client.AuthenticatedClient",
+        return_value=mock_authenticated_client,
+    )
+    return Render(token="test-token", base_url="https://api.test.com")
+
+
+def test_render_creates_sync_workflows_service(render):
+    assert isinstance(render.workflows, SyncWorkflowsService)
+
+
+def test_render_creates_sync_experimental_service(render):
+    assert isinstance(render.experimental, SyncExperimentalService)
+
+
+def test_render_exposes_client(render):
+    from render.client.client import Client
+
+    assert isinstance(render.client, Client)
+
+
+def test_render_requires_token():
+    """Render raises when no token is provided and env var is unset."""
+    import os
+
+    # Ensure the env var is not set
+    old = os.environ.pop("RENDER_API_KEY", None)
+    try:
+        with pytest.raises(ValueError, match="provide a token"):
+            Render()
+    finally:
+        if old is not None:
+            os.environ["RENDER_API_KEY"] = old

render/client/tests/test_sse.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+"""Unit tests for SSE parsing functionality."""
+
+import json
+
+import pytest
+
+from render.client import TaskRunDetails, TaskRunStatus
+from render.client.sse import parse_stream
+
+
+class BytesAiter:
+    def __init__(self, data: bytes):
+        self.data = data
+
+    def __aiter__(self):
+        self.pos = 0
+        return self
+
+    async def __anext__(self):
+        if self.pos >= len(self.data):
+            raise StopAsyncIteration
+        chunk = self.data[self.pos]
+        self.pos += 1
+        return chunk
+
+
+@pytest.mark.asyncio
+async def test_parse_stream_completed():
+    """Test parsing of SSE stream."""
+
+    details = TaskRunDetails(
+        id="trn-test123",
+        task_id="tsk-test123",
+        status=TaskRunStatus.COMPLETED,
+        results=[42],
+        input_=[],
+        parent_task_run_id="trn-test123",
+        root_task_run_id="trn-test123",
+        retries=0,
+        attempts=[],
+    )
+    sse_data = [
+        b"event: task.completed\ndata: "
+        + json.dumps(details.to_dict()).encode("utf-8")
+        + b"\n\n"
+    ]
+
+    count = 0
+    async for event in parse_stream(BytesAiter(sse_data)):
+        assert event.id == "trn-test123"
+        assert event.status.value == TaskRunStatus.COMPLETED
+        count += 1
+
+    assert count == 1
+
+
+@pytest.mark.asyncio
+async def test_parse_stream_malformed():
+    """Test parsing of SSE malformedstream."""
+    sse_data = [b"this is not a valid SSE event\n\n"]
+
+    count = 0
+    async for _ in parse_stream(BytesAiter(sse_data)):
+        count += 1
+
+    assert count == 0