render 1.0.1__py3-none-any.whl

render/workflows/tests/test_app.py

@@ -0,0 +1,343 @@
+"""Tests for the Workflows application class."""
+
+import pytest
+
+from render.workflows.app import Workflows
+from render.workflows.task import Retry
+
+
+class TestFromWorkflows:
+    """Tests for Workflows.from_workflows() composition."""
+
+    def test_combines_tasks_from_multiple_apps(self):
+        """Test that from_workflows combines tasks from multiple apps."""
+        app_a = Workflows()
+        app_b = Workflows()
+
+        @app_a.task
+        def task_a(ctx, x: int) -> int:
+            return x + 1
+
+        @app_b.task
+        def task_b(ctx, x: int) -> int:
+            return x + 2
+
+        combined = Workflows.from_workflows(app_a, app_b)
+
+        # Verify both tasks are in the combined app
+        task_names = combined._registry.get_task_names()
+        assert "task_a" in task_names
+        assert "task_b" in task_names
+        assert len(task_names) == 2
+
+    def test_raises_on_duplicate_task_names(self):
+        """Test that from_workflows raises ValueError on duplicate task names."""
+        app_a = Workflows()
+        app_b = Workflows()
+
+        @app_a.task
+        def duplicate_task(ctx, x: int) -> int:
+            return x + 1
+
+        @app_b.task
+        def duplicate_task(ctx, x: int) -> int:  # noqa: F811
+            return x + 2
+
+        with pytest.raises(
+            ValueError, match="Task 'duplicate_task' is defined in multiple apps"
+        ):
+            Workflows.from_workflows(app_a, app_b)
+
+    def test_combined_app_uses_its_own_defaults(self):
+        """Test that the combined app uses its own defaults, not source app defaults."""
+        source_retry = Retry(max_retries=5, wait_duration_ms=500, backoff_scaling=1.0)
+        app_a = Workflows(default_retry=source_retry, default_timeout=100)
+
+        @app_a.task
+        def task_a(ctx, x: int) -> int:
+            return x
+
+        # Combined app has different defaults
+        combined_retry = Retry(
+            max_retries=10, wait_duration_ms=1000, backoff_scaling=2.0
+        )
+        combined = Workflows.from_workflows(
+            app_a,
+            default_retry=combined_retry,
+            default_timeout=300,
+            default_plan="premium",
+        )
+
+        # Verify the combined app stored its own defaults
+        assert combined._default_retry == combined_retry
+        assert combined._default_timeout == 300
+        assert combined._default_plan == "premium"
+
+    def test_combined_app_can_define_new_tasks(self):
+        """Test that new tasks can be added to the combined app."""
+        app_a = Workflows()
+
+        @app_a.task
+        def task_a(ctx, x: int) -> int:
+            return x
+
+        combined = Workflows.from_workflows(app_a)
+
+        @combined.task
+        def task_b(ctx, x: int) -> int:
+            return x * 2
+
+        task_names = combined._registry.get_task_names()
+        assert "task_a" in task_names
+        assert "task_b" in task_names
+        assert len(task_names) == 2
+
+    def test_works_with_zero_apps(self):
+        """Test that from_workflows works with no input apps."""
+        combined = Workflows.from_workflows()
+
+        assert combined._registry.get_task_names() == []
+
+    def test_works_with_single_app(self):
+        """Test that from_workflows works with a single app."""
+        app = Workflows()
+
+        @app.task
+        def my_task(ctx, x: int) -> int:
+            return x
+
+        combined = Workflows.from_workflows(app)
+
+        assert "my_task" in combined._registry.get_task_names()
+        assert len(combined._registry.get_task_names()) == 1
+
+    def test_preserves_task_options(self):
+        """Test that task options are preserved when combining apps."""
+        retry = Retry(max_retries=3, wait_duration_ms=1000, backoff_scaling=2.0)
+        app = Workflows()
+
+        @app.task(retry=retry, timeout_seconds=60, plan="starter")
+        def configured_task(ctx, x: int) -> int:
+            return x
+
+        combined = Workflows.from_workflows(app)
+
+        task_info = combined._registry.get_task("configured_task")
+        assert task_info is not None
+        assert task_info.options.retry.max_retries == 3
+        assert task_info.options.timeout_seconds == 60
+        assert task_info.options.plan == "starter"
+
+    def test_combines_three_or_more_apps(self):
+        """Test that from_workflows works with many apps."""
+        app1 = Workflows()
+        app2 = Workflows()
+        app3 = Workflows()
+
+        @app1.task
+        def task_1(ctx, x: int) -> int:
+            return x + 1
+
+        @app2.task
+        def task_2(ctx, x: int) -> int:
+            return x + 2
+
+        @app3.task
+        def task_3(ctx, x: int) -> int:
+            return x + 3
+
+        combined = Workflows.from_workflows(app1, app2, app3)
+
+        task_names = combined._registry.get_task_names()
+        assert len(task_names) == 3
+        assert "task_1" in task_names
+        assert "task_2" in task_names
+        assert "task_3" in task_names
+
+
+class TestWorkflowsInit:
+    """Tests for Workflows initialization."""
+
+    def test_stores_default_retry(self):
+        """Test that default_retry is stored correctly."""
+        retry = Retry(max_retries=5, wait_duration_ms=1000, backoff_scaling=2.0)
+        app = Workflows(default_retry=retry)
+
+        assert app._default_retry == retry
+
+    def test_stores_default_timeout(self):
+        """Test that default_timeout is stored correctly."""
+        app = Workflows(default_timeout=300)
+
+        assert app._default_timeout == 300
+
+    def test_stores_default_plan(self):
+        """Test that default_plan is stored correctly."""
+        app = Workflows(default_plan="premium")
+
+        assert app._default_plan == "premium"
+
+
+class TestWorkflowsTaskDecorator:
+    """Tests for the @app.task decorator."""
+
+    def test_task_uses_app_defaults(self):
+        """Test that tasks use app-level defaults when not overridden."""
+        retry = Retry(max_retries=3, wait_duration_ms=1000, backoff_scaling=2.0)
+        app = Workflows(
+            default_retry=retry,
+            default_timeout=120,
+            default_plan="standard",
+        )
+
+        @app.task
+        def my_task(ctx, x: int) -> int:
+            return x
+
+        task_info = app._registry.get_task("my_task")
+        assert task_info.options.retry == retry
+        assert task_info.options.timeout_seconds == 120
+        assert task_info.options.plan == "standard"
+
+    def test_task_overrides_app_defaults(self):
+        """Test that task-level options override app defaults."""
+        app_retry = Retry(max_retries=3, wait_duration_ms=1000, backoff_scaling=2.0)
+        task_retry = Retry(max_retries=10, wait_duration_ms=5000, backoff_scaling=3.0)
+
+        app = Workflows(
+            default_retry=app_retry,
+            default_timeout=120,
+            default_plan="standard",
+        )
+
+        @app.task(retry=task_retry, timeout_seconds=60, plan="starter")
+        def my_task(ctx, x: int) -> int:
+            return x
+
+        task_info = app._registry.get_task("my_task")
+        assert task_info.options.retry == task_retry
+        assert task_info.options.timeout_seconds == 60
+        assert task_info.options.plan == "starter"
+
+    def test_task_partial_override(self):
+        """Test that tasks can partially override app defaults."""
+        app_retry = Retry(max_retries=3, wait_duration_ms=1000, backoff_scaling=2.0)
+
+        app = Workflows(
+            default_retry=app_retry,
+            default_timeout=120,
+            default_plan="standard",
+        )
+
+        # Only override timeout_seconds, keep retry and plan from defaults
+        @app.task(timeout_seconds=60)
+        def my_task(ctx, x: int) -> int:
+            return x
+
+        task_info = app._registry.get_task("my_task")
+        assert task_info.options.retry == app_retry  # From app default
+        assert task_info.options.timeout_seconds == 60  # Overridden
+        assert task_info.options.plan == "standard"  # From app default
+
+    def test_task_with_custom_name(self):
+        """Test that tasks can have custom names."""
+        app = Workflows()
+
+        @app.task(name="custom_task_name")
+        def my_function(ctx, x: int) -> int:
+            return x
+
+        task_names = app._registry.get_task_names()
+        assert "custom_task_name" in task_names
+        assert "my_function" not in task_names
+
+    def test_task_decorator_without_parentheses(self):
+        """Test that @app.task works without parentheses."""
+        app = Workflows()
+
+        @app.task
+        def my_task(ctx, x: int) -> int:
+            return x
+
+        assert "my_task" in app._registry.get_task_names()
+
+    def test_task_decorator_with_empty_parentheses(self):
+        """Test that @app.task() works with empty parentheses."""
+        app = Workflows()
+
+        @app.task()
+        def my_task(ctx, x: int) -> int:
+            return x
+
+        assert "my_task" in app._registry.get_task_names()
+
+
+class TestWorkflowsStart:
+    """Tests for Workflows.start() method."""
+
+    def test_raises_when_mode_not_set(self, monkeypatch):
+        """Test that start() raises ValueError when RENDER_SDK_MODE is not set."""
+        monkeypatch.delenv("RENDER_SDK_MODE", raising=False)
+        monkeypatch.delenv("RENDER_SDK_SOCKET_PATH", raising=False)
+
+        app = Workflows()
+
+        with pytest.raises(
+            ValueError, match="RENDER_SDK_MODE environment variable is required"
+        ):
+            app.start()
+
+    def test_raises_when_socket_path_not_set(self, monkeypatch):
+        """
+        Test that start() raises ValueError when RENDER_SDK_SOCKET_PATH is not set.
+        """
+        monkeypatch.setenv("RENDER_SDK_MODE", "run")
+        monkeypatch.delenv("RENDER_SDK_SOCKET_PATH", raising=False)
+
+        app = Workflows()
+
+        with pytest.raises(
+            ValueError, match="RENDER_SDK_SOCKET_PATH environment variable is required"
+        ):
+            app.start()
+
+    def test_raises_for_unknown_mode(self, monkeypatch):
+        """Test that start() raises ValueError for unknown mode."""
+        monkeypatch.setenv("RENDER_SDK_MODE", "invalid_mode")
+        monkeypatch.setenv("RENDER_SDK_SOCKET_PATH", "/tmp/test.sock")  # noqa: S108
+
+        app = Workflows()
+
+        with pytest.raises(ValueError, match="Unknown mode: invalid_mode"):
+            app.start()
+
+    def test_copies_tasks_to_global_registry(self, monkeypatch):
+        """Test that start() copies tasks to the global registry."""
+        monkeypatch.setenv("RENDER_SDK_MODE", "register")
+        monkeypatch.setenv("RENDER_SDK_SOCKET_PATH", "/tmp/test.sock")  # noqa: S108
+
+        from render.workflows.task import _global_registry
+
+        # Clear global registry
+        _global_registry._tasks.clear()
+
+        app = Workflows()
+
+        @app.task
+        def my_task(ctx, x: int) -> int:
+            return x
+
+        # Mock the register function to avoid actual socket operations
+        import render.workflows.app as app_module
+
+        original_register = app_module.register
+        app_module.register = lambda _: None
+
+        try:
+            app.start()
+
+            # Task should be in global registry
+            assert "my_task" in _global_registry._tasks
+        finally:
+            app_module.register = original_register
+            _global_registry._tasks.clear()

render/workflows/tests/test_cli.py

@@ -0,0 +1,134 @@
+"""Tests for the CLI entrypoint module."""
+
+import pytest
+
+from render.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/workflows/tests/test_client.py

@@ -0,0 +1,59 @@
+"""Tests for the UDS client's subtask submission."""
+
+import uuid
+from datetime import datetime
+
+import pytest
+
+from render.workflows._callback_models import RunSubtaskRequest, RunSubtaskResponse
+from render.workflows.client import Status, TaskResultResponse, UDSClient
+
+
+def _new_client(monkeypatch, tmp_path) -> tuple[UDSClient, list[RunSubtaskRequest]]:
+    """Build a UDSClient whose subtask calls are stubbed out.
+
+    Returns the client and the list of requests it submits, in call order.
+    """
+    client = UDSClient(str(tmp_path / "test.sock"))
+    captured: list[RunSubtaskRequest] = []
+
+    async def fake_start_subtask(request: RunSubtaskRequest) -> RunSubtaskResponse:
+        captured.append(request)
+        return RunSubtaskResponse(task_run_id="trn-1")
+
+    async def fake_get_task_result(task_run_id: str) -> TaskResultResponse:
+        return TaskResultResponse(status=Status.SUCCESS, result=["ok"])
+
+    monkeypatch.setattr(client, "_start_subtask", fake_start_subtask)
+    monkeypatch.setattr(client, "get_task_result", fake_get_task_result)
+
+    return client, captured
+
+
+@pytest.mark.asyncio
+async def test_run_subtask_sets_idempotency_key_and_created_at(monkeypatch, tmp_path):
+    client, captured = _new_client(monkeypatch, tmp_path)
+
+    result = await client.run_subtask("my-task", ["arg"])
+    assert result == "ok"
+
+    request = captured[0]
+    assert isinstance(request.idempotency_key, str)
+    # The key must be a well-formed UUID v4.
+    assert uuid.UUID(request.idempotency_key).version == 4
+    assert isinstance(request.created_at, str)
+    # created_at must be a valid ISO-8601 / RFC 3339 timestamp.
+    datetime.fromisoformat(request.created_at)
+
+
+@pytest.mark.asyncio
+async def test_run_subtask_generates_a_distinct_key_per_call(monkeypatch, tmp_path):
+    client, captured = _new_client(monkeypatch, tmp_path)
+
+    await client.run_subtask("my-task", ["arg"])
+    await client.run_subtask("my-task", ["arg"])
+
+    keys = [request.idempotency_key for request in captured]
+    assert len(keys) == 2
+    assert all(uuid.UUID(key).version == 4 for key in keys)
+    assert keys[0] != keys[1]

render/workflows/tests/test_context.py

@@ -0,0 +1,118 @@
+"""Tests for the task execution context."""
+
+import pytest
+
+from render.workflows.client import UDSClient
+from render.workflows.context import TaskContext, WorkflowTaskContext
+from render.workflows.task import TaskRegistry, create_task_decorator
+
+
+@pytest.fixture
+def task_decorator():
+    """Create a task decorator bound to a fresh registry."""
+    return create_task_decorator(TaskRegistry())
+
+
+@pytest.fixture
+def mock_client(mocker):
+    """Create a mock UDS client that records subtask submissions."""
+    mock = mocker.create_autospec(UDSClient, spec_set=True)
+    mock.run_subtask = mocker.AsyncMock(return_value="subtask result")
+    return mock
+
+
+@pytest.fixture
+def ctx(mock_client):
+    return WorkflowTaskContext(mock_client)
+
+
+@pytest.mark.asyncio
+async def test_a_stand_in_can_satisfy_the_protocol(task_decorator):
+    """
+    TaskContext is a Protocol, so a test double needs no subclassing.
+    """
+
+    class RecordingContext:
+        def __init__(self):
+            self.runs = []
+
+        async def run(self, task, *args, **kwargs):
+            self.runs.append((task.name, args, kwargs))
+            return "stubbed"
+
+    @task_decorator
+    async def caller(ctx, a: int) -> str:
+        return await ctx.run(callee, a)
+
+    @task_decorator
+    def callee(ctx, a: int) -> int:
+        return a
+
+    recording: TaskContext = RecordingContext()
+    assert await caller.func(recording, 5) == "stubbed"
+    assert recording.runs == [("callee", (5,), {})]
+
+
+class TestRun:
+    """ctx.run submits the task to run on its own compute."""
+
+    @pytest.mark.asyncio
+    async def test_submits_by_name_with_positional_input(
+        self, ctx, mock_client, task_decorator
+    ):
+        @task_decorator
+        def square(ctx, a: int) -> int:
+            return a * a
+
+        result = await ctx.run(square, 5)
+
+        assert result == "subtask result"
+        mock_client.run_subtask.assert_awaited_once_with("square", [5])
+
+    @pytest.mark.asyncio
+    async def test_submits_named_parameters_as_a_dict(
+        self, ctx, mock_client, task_decorator
+    ):
+        @task_decorator
+        def add(ctx, a: int, b: int) -> int:
+            return a + b
+
+        await ctx.run(add, a=1, b=2)
+
+        mock_client.run_subtask.assert_awaited_once_with("add", {"a": 1, "b": 2})
+
+    @pytest.mark.asyncio
+    async def test_submits_empty_input_for_a_task_with_no_arguments(
+        self, ctx, mock_client, task_decorator
+    ):
+        @task_decorator
+        def ping(ctx) -> str:
+            return "pong"
+
+        await ctx.run(ping)
+
+        mock_client.run_subtask.assert_awaited_once_with("ping", [])
+
+    @pytest.mark.asyncio
+    async def test_rejects_mixed_positional_and_named_input(self, ctx, task_decorator):
+        @task_decorator
+        def add(ctx, a: int, b: int) -> int:
+            return a + b
+
+        with pytest.raises(ValueError, match="Cannot mix positional and keyword"):
+            await ctx.run(add, 1, b=2)
+
+    @pytest.mark.asyncio
+    async def test_propagates_subtask_failures(
+        self, ctx, mock_client, task_decorator, mocker
+    ):
+        @task_decorator
+        def failing(ctx) -> None:
+            return None
+
+        mock_client.run_subtask = mocker.AsyncMock(
+            side_effect=RuntimeError("subtask failed")
+        )
+
+        with pytest.raises(RuntimeError, match="subtask failed"):
+            await ctx.run(failing)