render_sdk 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

render_sdk/workflows/tests/test_cli.py

@@ -0,0 +1,134 @@
+"""Tests for the CLI entrypoint module."""
+
+import pytest
+
+from render_sdk.workflows import cli
+
+
+class TestCLIMain:
+    """Tests for the main() CLI entrypoint."""
+
+    def test_no_arguments_shows_usage_and_exits(self, mocker, capsys):
+        """Test that running with no arguments shows usage and exits with code 1."""
+        mocker.patch("sys.argv", ["render-workflows"])
+
+        with pytest.raises(SystemExit) as exc_info:
+            cli.main()
+
+        assert exc_info.value.code == 1
+        captured = capsys.readouterr()
+        assert "Usage: render-workflows <module:app>" in captured.err
+        assert "Example: render-workflows myapp:app" in captured.err
+
+    def test_invalid_format_no_colon_shows_error(self, mocker, capsys):
+        """Test that an argument without a colon shows an error."""
+        mocker.patch("sys.argv", ["render-workflows", "myapp"])
+
+        with pytest.raises(SystemExit) as exc_info:
+            cli.main()
+
+        assert exc_info.value.code == 1
+        captured = capsys.readouterr()
+        assert "Error: Invalid app path 'myapp'" in captured.err
+        assert "Expected format: <module>:<app_variable>" in captured.err
+
+    def test_module_not_found_shows_error(self, mocker, capsys):
+        """Test that a non-existent module shows an import error."""
+        mocker.patch("sys.argv", ["render-workflows", "nonexistent_module:app"])
+
+        with pytest.raises(SystemExit) as exc_info:
+            cli.main()
+
+        assert exc_info.value.code == 1
+        captured = capsys.readouterr()
+        assert "Error: Could not import module 'nonexistent_module'" in captured.err
+
+    def test_attribute_not_found_shows_error(self, mocker, capsys):
+        """Test that a missing attribute shows an error."""
+        mocker.patch("sys.argv", ["render-workflows", "os:nonexistent_attr"])
+
+        with pytest.raises(SystemExit) as exc_info:
+            cli.main()
+
+        assert exc_info.value.code == 1
+        captured = capsys.readouterr()
+        assert "Error: Module 'os' has no attribute 'nonexistent_attr'" in captured.err
+
+    def test_object_without_start_method_shows_error(self, mocker, capsys):
+        """Test that an object without a start() method shows an error."""
+        # os.path is a module, not a Workflows instance
+        mocker.patch("sys.argv", ["render-workflows", "os:path"])
+
+        with pytest.raises(SystemExit) as exc_info:
+            cli.main()
+
+        assert exc_info.value.code == 1
+        captured = capsys.readouterr()
+        assert "Error: 'path' does not have a start() method" in captured.err
+        assert "Expected a Workflows instance" in captured.err
+
+    def test_valid_app_calls_start(self, mocker):
+        """Test that a valid app path calls the app's start() method."""
+        # Create a mock app with a start method
+        mock_app = mocker.Mock()
+        mock_app.start = mocker.Mock()
+
+        # Create a mock module containing the app
+        mock_module = mocker.Mock()
+        mock_module.app = mock_app
+
+        # Patch sys.argv and importlib
+        mocker.patch("sys.argv", ["render-workflows", "mymodule:app"])
+        mocker.patch("importlib.import_module", return_value=mock_module)
+
+        # Should not raise
+        cli.main()
+
+        # Verify start() was called
+        mock_app.start.assert_called_once()
+
+    def test_nested_module_path(self, mocker):
+        """Test that nested module paths (e.g., 'myproject.tasks:app') work."""
+        mock_app = mocker.Mock()
+        mock_app.start = mocker.Mock()
+
+        mock_module = mocker.Mock()
+        mock_module.app = mock_app
+
+        mocker.patch("sys.argv", ["render-workflows", "myproject.tasks.workers:app"])
+        mock_import = mocker.patch("importlib.import_module", return_value=mock_module)
+
+        cli.main()
+
+        # Verify the full module path was used
+        mock_import.assert_called_once_with("myproject.tasks.workers")
+        mock_app.start.assert_called_once()
+
+    def test_colon_in_module_path_uses_last_colon(self, mocker, capsys):
+        """Test that multiple colons use rsplit to get the last segment."""
+        # This is an edge case: "weird:module:app" should split as
+        # module="weird:module", app="app"
+        mocker.patch("sys.argv", ["render-workflows", "weird:module:app"])
+
+        with pytest.raises(SystemExit) as exc_info:
+            cli.main()
+
+        # Should fail on import (module "weird:module" doesn't exist)
+        assert exc_info.value.code == 1
+        captured = capsys.readouterr()
+        assert "Could not import module 'weird:module'" in captured.err
+
+    def test_import_error_includes_original_message(self, mocker, capsys):
+        """Test that import errors include the original exception message."""
+        mocker.patch("sys.argv", ["render-workflows", "mymodule:app"])
+        mocker.patch(
+            "importlib.import_module",
+            side_effect=ImportError("No module named 'dependency'"),
+        )
+
+        with pytest.raises(SystemExit) as exc_info:
+            cli.main()
+
+        assert exc_info.value.code == 1
+        captured = capsys.readouterr()
+        assert "No module named 'dependency'" in captured.err

render_sdk/workflows/tests/test_end_to_end.py

@@ -70,7 +70,9 @@ def test_task_registration_network_payload(task_registry, task_decorator, mocker
         return f"Hello {msg}"
 
     @task_decorator(
-        options=Options(retry=Retry(max_retries=3, wait_duration_ms=1000, factor=1.5)),
+        options=Options(
+            retry=Retry(max_retries=3, wait_duration_ms=1000, backoff_scaling=1.5)
+        ),
     )
     def retry_task(data: str) -> str:
         return data.upper()
@@ -120,6 +122,74 @@ def test_task_registration_network_payload(task_registry, task_decorator, mocker
     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_sdk.workflows.callback_api.types import UNSET
+
+    # Mock the UDSClient class
+    mock_uds_client_class = mocker.patch("render_sdk.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(x: int) -> int:
+        return x * 2
+
+    # Define a task without timeout_seconds
+    @task_decorator
+    def no_timeout_task(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(x: int) -> int:
+        return x * 4
+
+    # Mock get_task_registry to return our test registry
+    mock_get_registry = mocker.patch("render_sdk.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
+
+
 @pytest.mark.asyncio
 async def test_callback_payloads_with_mocked_client(
     task_registry,

render_sdk/workflows/tests/test_registration.py

@@ -93,7 +93,9 @@ def test_task_registration_with_options_object():
 
     # Task with only retry options
     @task_decorator(
-        options=Options(retry=Retry(max_retries=1, wait_duration_ms=500, factor=1.0)),
+        options=Options(
+            retry=Retry(max_retries=1, wait_duration_ms=500, backoff_scaling=1.0)
+        ),
     )
     def task_with_retry_only(x: int) -> int:
         return x
@@ -128,3 +130,58 @@ def test_task_registration_preserves_function_attributes(task_registry, task_dec
     # 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(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(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(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_sdk-0.1.2.dist-info → render_sdk-0.2.0.dist-info}/METADATA

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: render_sdk
-Version: 0.1.2
+Version: 0.2.0
 Summary: Python SDK for Render Workflows
+License-File: LICENSE
 Author: Render
 Author-email: support@render.com
 Requires-Python: >=3.10,<4.0
@@ -15,7 +16,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Requires-Dist: aiohttp (>=3.8.0,<4.0.0)
+Requires-Dist: aiohttp (>=3.12.14,<4.0.0)
 Requires-Dist: httpx (>=0.28.1,<0.29.0)
 Requires-Dist: openapi-python-client (>=0.26.1,<0.27.0)
 Description-Content-Type: text/markdown