render 1.0.1__py3-none-any.whl

render/client/tests/test_util.py

@@ -0,0 +1,303 @@
+import json
+
+import httpx
+import pytest
+
+from render.client.errors import ClientError, RenderError, ServerError, TimeoutError
+from render.client.util import (
+    _handle_wrapper_exception,
+    handle_api_error,
+    handle_http_error,
+    handle_httpx_exception,
+    handle_storage_http_error,
+    retry_with_backoff,
+)
+from render.public_api.models.error import Error
+from render.public_api.types import UNSET, Response
+
+
+class TestException(Exception):
+    pass
+
+
+@pytest.mark.asyncio
+async def test_retry_with_backoff_success():
+    async def fn() -> int:
+        return 1
+
+    result = await retry_with_backoff(fn)
+    assert result == 1
+
+
+@pytest.mark.asyncio
+async def test_retry_with_backoff_failure():
+    async def fn() -> int:
+        raise TestException("Test failure")
+
+    with pytest.raises(TestException):
+        result = await retry_with_backoff(
+            fn, max_retries=2, poll_interval=0.001, backoff_factor=1.0
+        )
+        assert result is None
+
+
+@pytest.mark.asyncio
+async def test_retry_with_backoff_success_after_failure():
+    count = 0
+
+    async def fn() -> int:
+        nonlocal count
+        count += 1
+        if count == 1:
+            raise TestException("Test failure")
+        else:
+            return 1
+
+    result = await retry_with_backoff(
+        fn, max_retries=2, poll_interval=0.001, backoff_factor=1.0
+    )
+    assert result == 1
+
+
+@pytest.mark.asyncio
+async def test_retry_with_backoff_success_after_failure_with_exempted_exception():
+    count = 0
+
+    async def fn() -> int:
+        nonlocal count
+        count += 1
+        raise TestException("Test failure")
+
+    with pytest.raises(TestException):
+        result = await retry_with_backoff(
+            fn,
+            max_retries=2,
+            poll_interval=0.001,
+            backoff_factor=1.0,
+            exempted_exceptions=(TestException,),
+        )
+        assert result is None
+        assert count == 1
+
+
+def test_handle_http_error_4xx():
+    response = httpx.Response(
+        status_code=404, json={"message": "Not found"}, text="Not found"
+    )
+    with pytest.raises(
+        ClientError, match="API request failed with status 404: Not found"
+    ):
+        handle_http_error(response, "API request")
+
+
+def test_handle_http_error_5xx():
+    response = httpx.Response(
+        status_code=500,
+        json={"error": "Internal server error"},
+        text="Internal server error",
+    )
+    with pytest.raises(
+        ServerError, match="API request failed with status 500: Internal server error"
+    ):
+        handle_http_error(response, "API request")
+
+
+def test_handle_httpx_exception_timeout():
+    exception = httpx.TimeoutException("Request timed out")
+    with pytest.raises(TimeoutError, match="HTTP request timed out"):
+        handle_httpx_exception(exception, "HTTP request")
+
+
+def test_handle_httpx_exception_remote_protocol_error():
+    exception = httpx.RemoteProtocolError(
+        "Server disconnected without sending a response."
+    )
+    with pytest.raises(ServerError, match="failed due to network error"):
+        handle_httpx_exception(exception, "get task result")
+
+
+def test_handle_api_error_client_error():
+    response = Response(
+        status_code=400, content=b"", headers={}, parsed=Error(message="Bad request")
+    )
+    with pytest.raises(ClientError, match="API request failed: Bad request"):
+        handle_api_error(response, "API request")
+
+
+def test_handle_api_error_server_error():
+    response = Response(
+        status_code=500,
+        content=b"",
+        headers={},
+        parsed=Error(message="Internal server error"),
+    )
+    with pytest.raises(ServerError, match="API request failed: Internal server error"):
+        handle_api_error(response, "API request")
+
+
+def test_handle_api_error_with_unset_message():
+    """When Error has Unset message, should fallback to 'Unknown error occurred'."""
+    response = Response(
+        status_code=400,
+        content=b"",
+        headers={},
+        parsed=Error(message=UNSET),
+    )
+    with pytest.raises(ClientError, match="API request failed: Unknown error occurred"):
+        handle_api_error(response, "API request")
+
+
+def test_handle_api_error_extracts_message_from_content_when_parsed_is_none():
+    """When parsed is None, should extract error message from response content."""
+    response = Response(
+        status_code=400,
+        content=b'{"message": "limit must be a positive integer"}',
+        headers={},
+        parsed=None,
+    )
+    with pytest.raises(ClientError, match="limit must be a positive integer"):
+        handle_api_error(response, "API request")
+
+
+def test_handle_api_error_fallback_when_content_is_not_json():
+    """When parsed is None and content is not JSON, should use fallback message."""
+    response = Response(
+        status_code=400,
+        content=b"Not a JSON response",
+        headers={},
+        parsed=None,
+    )
+    with pytest.raises(ClientError, match="API request failed: Unknown error occurred"):
+        handle_api_error(response, "API request")
+
+
+def test_handle_wrapper_exception_reraises_render_error():
+    with pytest.raises(RenderError, match="already a render error"):
+        _handle_wrapper_exception(RenderError("already a render error"), "op")
+
+
+def test_handle_wrapper_exception_httpx_request_error():
+    exc = httpx.TimeoutException("timed out")
+    with pytest.raises(TimeoutError, match="op timed out"):
+        _handle_wrapper_exception(exc, "op")
+
+
+def test_handle_wrapper_exception_json_decode_error():
+    exc = json.JSONDecodeError("Expecting value", "Unauthorized\n", 0)
+    with pytest.raises(
+        RenderError, match="server returned a non-JSON response: Unauthorized"
+    ):
+        _handle_wrapper_exception(exc, "create task")
+
+
+def test_handle_wrapper_exception_json_decode_error_empty_body():
+    exc = json.JSONDecodeError("Expecting value", "", 0)
+    with pytest.raises(
+        RenderError, match="server returned a non-JSON response: empty response"
+    ):
+        _handle_wrapper_exception(exc, "create task")
+
+
+def test_handle_wrapper_exception_unexpected_error():
+    exc = ValueError("something weird")
+    with pytest.raises(
+        RenderError, match="failed with unexpected error: something weird"
+    ):
+        _handle_wrapper_exception(exc, "op")
+
+
+class TestHandleStorageHttpError:
+    """Tests for handle_storage_http_error function."""
+
+    def test_404_with_s3_xml_error_does_not_expose_raw_content(self):
+        """Verify that raw S3 XML error content is not exposed in error message."""
+        s3_xml_error = (
+            '<?xml version="1.0" encoding="UTF-8"?>'
+            "<Error><Code>NoSuchKey</Code>"
+            "<Message>The specified key does not exist.</Message>"
+            "<Key>tea-d3tc3fuuk2gs73d0paug/foo/bar/test.txt</Key>"
+            "<RequestId>95N55HR7H0QBF3X9</RequestId>"
+            "<HostId>QfLXA55SGkqZ6VEKV97lgMjiFNWRFhpTj29FAylq2SOh2LJFMyvHuRdUjDu1IaZ"
+            "/NmQR0znt4/0=</HostId></Error>"
+        )
+
+        response = httpx.Response(status_code=404, text=s3_xml_error)
+
+        with pytest.raises(ClientError) as exc_info:
+            handle_storage_http_error(response, "download object")
+
+        error_message = str(exc_info.value)
+
+        # Should contain sanitized message
+        assert "failed with status 404" in error_message
+        assert "object not found" in error_message
+
+        # Should NOT contain sensitive/raw content
+        assert "NoSuchKey" not in error_message
+        assert "tea-d3tc3fuuk2gs73d0paug" not in error_message
+        assert "RequestId" not in error_message
+        assert "HostId" not in error_message
+
+    def test_403_access_denied_does_not_expose_bucket_info(self):
+        """Verify that storage bucket info is not exposed in error message."""
+        gcs_error = (
+            "<?xml version='1.0' encoding='UTF-8'?>"
+            "<Error><Code>AccessDenied</Code><Message>Access denied.</Message>"
+            "<Details>render-objects-bucket/some/path</Details></Error>"
+        )
+
+        response = httpx.Response(status_code=403, text=gcs_error)
+
+        with pytest.raises(ClientError) as exc_info:
+            handle_storage_http_error(response, "upload object")
+
+        error_message = str(exc_info.value)
+
+        # Should contain sanitized message
+        assert "failed with status 403" in error_message
+        assert "access denied" in error_message
+
+        # Should NOT contain sensitive info
+        assert "render-objects-bucket" not in error_message
+        assert "AccessDenied" not in error_message
+
+    def test_500_server_error(self):
+        """Verify 5xx errors raise ServerError with sanitized message."""
+        response = httpx.Response(
+            status_code=500,
+            text="Internal Server Error: connection to storage backend failed",
+        )
+
+        with pytest.raises(ServerError) as exc_info:
+            handle_storage_http_error(response, "download object")
+
+        error_message = str(exc_info.value)
+
+        # Should contain sanitized message
+        assert "failed with status 500" in error_message
+        assert "storage service temporarily unavailable" in error_message
+
+        # Should NOT contain raw error content
+        assert "Internal Server Error" not in error_message
+        assert "storage backend" not in error_message
+
+    def test_413_payload_too_large(self):
+        """Verify 413 errors are handled with appropriate message."""
+        xml_error = '<?xml version="1.0"?><Error><Code>EntityTooLarge</Code><MaxSizeAllowed>5368709120</MaxSizeAllowed></Error>'
+        response = httpx.Response(status_code=413, text=xml_error)
+
+        with pytest.raises(ClientError) as exc_info:
+            handle_storage_http_error(response, "upload object")
+
+        error_message = str(exc_info.value)
+
+        assert "failed with status 413" in error_message
+        assert "object too large" in error_message
+        assert "EntityTooLarge" not in error_message
+        assert "MaxSizeAllowed" not in error_message
+
+    def test_success_response_does_not_raise(self):
+        """Verify successful responses don't raise exceptions."""
+        response = httpx.Response(status_code=200, text="OK")
+        # Should not raise
+        handle_storage_http_error(response, "download object")

render/client/tests/test_util_sync.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""Unit tests for synchronous utility functions."""
+
+import pytest
+
+from render.client.util_sync import retry_with_backoff
+
+
+class _TestException(Exception):
+    pass
+
+
+def test_retry_with_backoff_success():
+    def fn() -> int:
+        return 1
+
+    result = retry_with_backoff(fn)
+    assert result == 1
+
+
+def test_retry_with_backoff_failure():
+    def fn() -> int:
+        raise _TestException("Test failure")
+
+    with pytest.raises(_TestException):
+        retry_with_backoff(fn, max_retries=2, poll_interval=0.001, backoff_factor=1.0)
+
+
+def test_retry_with_backoff_success_after_failure():
+    count = 0
+
+    def fn() -> int:
+        nonlocal count
+        count += 1
+        if count == 1:
+            raise _TestException("Test failure")
+        return 1
+
+    result = retry_with_backoff(
+        fn, max_retries=2, poll_interval=0.001, backoff_factor=1.0
+    )
+    assert result == 1
+
+
+def test_retry_with_backoff_exempted_exception():
+    count = 0
+
+    def fn() -> int:
+        nonlocal count
+        count += 1
+        raise _TestException("Test failure")
+
+    with pytest.raises(_TestException):
+        retry_with_backoff(
+            fn,
+            max_retries=5,
+            poll_interval=0.001,
+            backoff_factor=1.0,
+            exempted_exceptions=(_TestException,),
+        )
+
+    # Should have raised on the first attempt without retrying
+    assert count == 1
+
+
+def test_retry_with_backoff_returns_none_when_all_none():
+    def fn():
+        return None
+
+    result = retry_with_backoff(
+        fn, max_retries=3, poll_interval=0.001, backoff_factor=1.0
+    )
+    assert result is None

render/client/tests/test_workflows_sync.py

@@ -0,0 +1,313 @@
+#!/usr/bin/env python3
+"""Unit tests for the synchronous Render REST API client functionality."""
+
+import datetime
+import json
+
+import pytest
+
+from render.client import Client, ListTaskRunsParams
+from render.client.errors import ClientError, ServerError
+from render.client.workflows_sync import SyncWorkflowsService
+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 sync_workflows_service(client):
+    """Create a SyncWorkflowsService instance."""
+    return SyncWorkflowsService(client)
+
+
+@pytest.fixture
+def mock_cancel_task_run_sync(mocker):
+    return mocker.patch(
+        "render.public_api.api.workflow_tasks_beta.cancel_task_run.sync_detailed"
+    )
+
+
+@pytest.fixture
+def mock_list_task_runs_sync(mocker):
+    return mocker.patch(
+        "render.public_api.api.workflow_tasks_beta.list_task_runs.sync_detailed"
+    )
+
+
+@pytest.fixture
+def mock_create_task_sync(mocker):
+    return mocker.patch(
+        "render.public_api.api.workflow_tasks_beta.create_task.sync_detailed"
+    )
+
+
+@pytest.fixture
+def mock_get_task_run_sync(mocker):
+    return mocker.patch(
+        "render.public_api.api.workflow_tasks_beta.get_task_run.sync_detailed"
+    )
+
+
+def test_start_task_success(
+    mock_create_task_sync, sync_workflows_service, mock_task_run
+):
+    """Test successful task start."""
+    mock_create_task_sync.return_value = Response(
+        status_code=202, content=b"", headers={}, parsed=mock_task_run
+    )
+
+    result = sync_workflows_service.start_task("test-task", {"input": "data"})
+
+    assert isinstance(result, TaskRun)
+    assert result.id == "trn-test123"
+    mock_create_task_sync.assert_called_once()
+
+
+def test_start_task_failure(mock_create_task_sync, sync_workflows_service):
+    """Test task start failure."""
+
+    error = Error(message="Task creation failed")
+    mock_create_task_sync.return_value = Response(
+        status_code=400, content=b"", headers={}, parsed=error
+    )
+
+    with pytest.raises(ClientError, match="create task failed: Task creation failed"):
+        sync_workflows_service.start_task("test-task", {"input": "data"})
+
+
+def test_run_task_returns_task_run_details(
+    mocker,
+    mock_create_task_sync,
+    sync_workflows_service,
+    mock_task_run,
+    mock_task_run_details,
+):
+    """Test that run_task starts a task and waits for completion."""
+    mock_create_task_sync.return_value = Response(
+        status_code=202, content=b"", headers={}, parsed=mock_task_run
+    )
+    mocker.patch.object(
+        sync_workflows_service,
+        "_task_run_completed_with_sse",
+        return_value=mock_task_run_details,
+    )
+
+    result = sync_workflows_service.run_task("test-task", {"input": "data"})
+
+    assert isinstance(result, TaskRunDetails)
+    assert result.id == "trn-test123"
+    assert result.status.value == TaskRunStatus.COMPLETED
+
+
+def test_run_task_failure(mock_create_task_sync, sync_workflows_service):
+    """Test that run_task propagates errors from start_task."""
+    error = Error(message="Task creation failed")
+    mock_create_task_sync.return_value = Response(
+        status_code=400, content=b"", headers={}, parsed=error
+    )
+
+    with pytest.raises(ClientError, match="create task failed: Task creation failed"):
+        sync_workflows_service.run_task("test-task", {"input": "data"})
+
+
+def test_get_task_run_success(
+    mock_get_task_run_sync, sync_workflows_service, mock_task_run_details
+):
+    """Test successful task run retrieval."""
+    mock_get_task_run_sync.return_value = Response(
+        status_code=200, content=b"", headers={}, parsed=mock_task_run_details
+    )
+
+    result = sync_workflows_service.get_task_run("trn-test123")
+
+    assert result.id == "trn-test123"
+    assert result.status.value == TaskRunStatus.COMPLETED
+    mock_get_task_run_sync.assert_called_once_with(
+        client=sync_workflows_service.client.internal, task_run_id="trn-test123"
+    )
+
+
+def test_get_task_run_failure(mock_get_task_run_sync, sync_workflows_service):
+    """Test task run retrieval failure."""
+    error = Error(message="Task not found")
+    mock_get_task_run_sync.return_value = Response(
+        status_code=400, content=b"", headers={}, parsed=error
+    )
+
+    with pytest.raises(ClientError, match="get task run failed: Task not found"):
+        sync_workflows_service.get_task_run("trn-test123")
+
+
+def test_cancel_task_run_success(mock_cancel_task_run_sync, sync_workflows_service):
+    """Test successful task run cancellation."""
+    mock_cancel_task_run_sync.return_value = Response(
+        status_code=204, content=b"", headers={}, parsed=None
+    )
+
+    sync_workflows_service.cancel_task_run("trn-test123")
+
+    mock_cancel_task_run_sync.assert_called_once_with(
+        client=sync_workflows_service.client.internal, task_run_id="trn-test123"
+    )
+
+
+def test_cancel_task_run_failure(mock_cancel_task_run_sync, sync_workflows_service):
+    """Test task run cancellation failure."""
+    error = Error(message="Cannot cancel task")
+    mock_cancel_task_run_sync.return_value = Response(
+        status_code=400, content=b"", headers={}, parsed=error
+    )
+
+    with pytest.raises(ClientError, match="cancel task run failed: Cannot cancel task"):
+        sync_workflows_service.cancel_task_run("trn-test123")
+
+
+def test_list_task_runs_success(
+    mocker, mock_list_task_runs_sync, sync_workflows_service, mock_task_run
+):
+    """Test successful task runs listing."""
+    task_runs = [mock_task_run]
+    mock_list_task_runs_sync.return_value = Response(
+        status_code=200, content=b"", headers={}, parsed=task_runs
+    )
+
+    params = ListTaskRunsParams(limit=5, owner_id="test-owner")
+    result = sync_workflows_service.list_task_runs(params)
+
+    assert len(result) == 1
+    assert result[0].id == "trn-test123"
+    mock_list_task_runs_sync.assert_called_once_with(
+        client=sync_workflows_service.client.internal,
+        limit=5,
+        cursor=mocker.ANY,
+        owner_id="test-owner",
+    )
+
+
+@pytest.fixture
+def mock_httpx_stream(mocker):
+    """Mock httpx.Client 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 context managers
+    (Client → stream → response.iter_bytes).
+    """
+    chunks: list[bytes] = []
+
+    def iter_bytes():
+        yield from chunks
+
+    mock_response = mocker.Mock()
+    mock_response.status_code = 200
+    mock_response.iter_bytes = iter_bytes
+
+    stream_cm = mocker.MagicMock()
+    stream_cm.__enter__ = mocker.Mock(return_value=mock_response)
+    stream_cm.__exit__ = mocker.Mock(return_value=False)
+
+    mock_http_client = mocker.Mock()
+    mock_http_client.stream.return_value = stream_cm
+
+    client_cm = mocker.MagicMock()
+    client_cm.__enter__ = mocker.Mock(return_value=mock_http_client)
+    client_cm.__exit__ = mocker.Mock(return_value=False)
+
+    mocker.patch("render.client.workflows_sync.httpx.Client", return_value=client_cm)
+
+    return chunks, mock_response
+
+
+def test_task_run_events_yields_events(sync_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 = []
+    for event in sync_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
+
+
+def test_task_run_events_raises_on_http_error(
+    sync_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):
+        for _ in sync_workflows_service.task_run_events(["trn-test123"]):
+            pass