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

render_sdk/workflows/tests/test_app.py

@@ -0,0 +1,412 @@
+"""Tests for the Workflows application class."""
+
+import warnings
+
+import pytest
+
+from render_sdk.workflows.app import Workflows
+from render_sdk.workflows.task import Retry
+
+
+# Reset global state before each test
+@pytest.fixture(autouse=True)
+def reset_auto_start_state():
+    """Reset the global auto_start tracking state before each test."""
+    import render_sdk.workflows.app as app_module
+
+    app_module._auto_start_app_registered = False
+    yield
+    app_module._auto_start_app_registered = False
+
+
+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(x: int) -> int:
+            return x + 1
+
+        @app_b.task
+        def task_b(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(x: int) -> int:
+            return x + 1
+
+        @app_b.task
+        def duplicate_task(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(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(x: int) -> int:
+            return x
+
+        combined = Workflows.from_workflows(app_a)
+
+        @combined.task
+        def task_b(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(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=60, plan="starter")
+        def configured_task(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(x: int) -> int:
+            return x + 1
+
+        @app2.task
+        def task_2(x: int) -> int:
+            return x + 2
+
+        @app3.task
+        def task_3(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"
+
+    def test_auto_start_false_by_default(self):
+        """Test that auto_start is False by default."""
+        app = Workflows()
+
+        assert app._auto_start is False
+
+    def test_started_false_initially(self):
+        """Test that _started is False initially."""
+        app = Workflows()
+
+        assert app._started is False
+
+
+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(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=60, plan="starter")
+        def my_task(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, keep retry and plan from defaults
+        @app.task(timeout=60)
+        def my_task(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(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(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(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_started_not_set_on_validation_failure(self, monkeypatch):
+        """Test that _started remains False when validation fails."""
+        monkeypatch.delenv("RENDER_SDK_MODE", raising=False)
+
+        app = Workflows()
+        assert app._started is False
+
+        with pytest.raises(ValueError):
+            app.start()
+
+        # _started should still be False since validation failed
+        assert app._started is False
+
+    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_sdk.workflows.task import _global_registry
+
+        # Clear global registry
+        _global_registry._tasks.clear()
+
+        app = Workflows()
+
+        @app.task
+        def my_task(x: int) -> int:
+            return x
+
+        # Mock the register function to avoid actual socket operations
+        import render_sdk.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()
+
+
+class TestAutoStartWarning:
+    """Tests for auto_start warning behavior."""
+
+    def test_warns_on_multiple_auto_start_apps(self):
+        """Test that creating multiple apps with auto_start=True warns."""
+        # First app should not warn
+        _app1 = Workflows(auto_start=True)
+
+        # Second app should warn
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            _app2 = Workflows(auto_start=True)
+
+            assert len(w) == 1
+            warning_msg = str(w[0].message)
+            assert "Multiple Workflows instances with auto_start=True" in warning_msg
+            assert issubclass(w[0].category, UserWarning)
+
+    def test_no_warning_for_auto_start_false(self):
+        """Test that auto_start=False apps don't trigger warnings."""
+        _app1 = Workflows(auto_start=True)
+
+        # auto_start=False should not warn
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            _app2 = Workflows(auto_start=False)
+            _app3 = Workflows()  # Default is False
+
+            assert len(w) == 0

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

@@ -71,7 +71,7 @@ def test_task_registration_network_payload(task_registry, task_decorator, mocker
 
     @task_decorator(
         options=Options(
-            retry=Retry(max_retries=3, wait_duration=1000, backoff_scaling=1.5)
+            retry=Retry(max_retries=3, wait_duration_ms=1000, backoff_scaling=1.5)
         ),
     )
     def retry_task(data: str) -> str:
@@ -122,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

@@ -94,7 +94,7 @@ def test_task_registration_with_options_object():
     # Task with only retry options
     @task_decorator(
         options=Options(
-            retry=Retry(max_retries=1, wait_duration=500, backoff_scaling=1.0)
+            retry=Retry(max_retries=1, wait_duration_ms=500, backoff_scaling=1.0)
         ),
     )
     def task_with_retry_only(x: int) -> int:
@@ -130,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