render-lab-test-utils 0.1.0__tar.gz

render_lab_test_utils-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+.venv/
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+dist/
+*.egg-info/
+.env
+.env.*
+!.env.example

render_lab_test_utils-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Render Lab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

render_lab_test_utils-0.1.0/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.5
+Name: render-lab-test-utils
+Version: 0.1.0
+Summary: Registration-free test contexts for Render tasks
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: render==1.0.1
+Description-Content-Type: text/markdown
+
+# render-lab-test-utils
+
+Registration-free test contexts for `render==1.0.1`. No credentials or network.
+
+```python
+from render_lab_test_utils import fake_ctx, local_ctx
+
+ctx = fake_ctx()  # Any unexpected ctx.run fails loudly.
+# await some_impl(ctx, input, deps=fakes)
+
+ctx = local_ctx()  # Execute task.func(ctx, ...) recursively in this process.
+# await ctx.run(composed_task, input)
+```
+
+`fake_ctx(override)` accepts a context stub implementing async `run`. This replaces
+TypeScript's partial-object override with Python's structural TaskContext protocol.
+`local_ctx` supports synchronous and asynchronous task bodies and keyword inputs.
+It checks wiring and results; it does not prove durable dispatch, retries, or timeouts.
+
+## Installation
+
+```sh
+pip install render-lab-test-utils==0.1.0
+```

render_lab_test_utils-0.1.0/README.md

@@ -0,0 +1,24 @@
+# render-lab-test-utils
+
+Registration-free test contexts for `render==1.0.1`. No credentials or network.
+
+```python
+from render_lab_test_utils import fake_ctx, local_ctx
+
+ctx = fake_ctx()  # Any unexpected ctx.run fails loudly.
+# await some_impl(ctx, input, deps=fakes)
+
+ctx = local_ctx()  # Execute task.func(ctx, ...) recursively in this process.
+# await ctx.run(composed_task, input)
+```
+
+`fake_ctx(override)` accepts a context stub implementing async `run`. This replaces
+TypeScript's partial-object override with Python's structural TaskContext protocol.
+`local_ctx` supports synchronous and asynchronous task bodies and keyword inputs.
+It checks wiring and results; it does not prove durable dispatch, retries, or timeouts.
+
+## Installation
+
+```sh
+pip install render-lab-test-utils==0.1.0
+```

render_lab_test_utils-0.1.0/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["hatchling>=1.27,<2"]
+build-backend = "hatchling.build"
+
+[project]
+name = "render-lab-test-utils"
+version = "0.1.0"
+description = "Registration-free test contexts for Render tasks"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+dependencies = ["render==1.0.1"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/render_lab_test_utils"]

render_lab_test_utils-0.1.0/src/render_lab_test_utils/__init__.py

@@ -0,0 +1,42 @@
+"""Registration-free contexts for unit and composition tests."""
+
+from __future__ import annotations
+
+import inspect
+from typing import TYPE_CHECKING, cast
+
+if TYPE_CHECKING:
+    from render import TaskContext
+    from render.workflows.task import TaskDefinition
+
+
+class LocalContext:
+    """Execute raw task functions recursively, without durability or retries."""
+
+    async def run[**P, R](self, task: TaskDefinition[P, R], *args: P.args, **kwargs: P.kwargs) -> R:
+        if not callable(getattr(task, "func", None)):
+            raise TypeError(f"local_ctx: {getattr(task, 'name', task)} is not a task definition")
+        result = task.func(self, *args, **kwargs)
+        if inspect.isawaitable(result):
+            return cast(R, await result)
+        return result
+
+
+class FakeContext:
+    """Fail any unstubbed chained dispatch."""
+
+    async def run[**P, R](self, task: TaskDefinition[P, R], *args: P.args, **kwargs: P.kwargs) -> R:
+        raise RuntimeError(
+            f'unexpected ctx.run("{getattr(task, "name", "unknown")}") '
+            "- stub it via fake_ctx(override)"
+        )
+
+
+def fake_ctx(override: TaskContext | None = None) -> TaskContext:
+    """Return a failing context, or an explicit context stub implementing run."""
+    return override if override is not None else FakeContext()
+
+
+def local_ctx() -> TaskContext:
+    """Return a context that runs chained task bodies in the current process."""
+    return LocalContext()

render_lab_test_utils-0.1.0/tests/test_contexts.py

@@ -0,0 +1,33 @@
+from types import SimpleNamespace
+
+import pytest
+from render import Workflows
+from render_lab_test_utils import fake_ctx, local_ctx
+
+
+async def test_unexpected_dispatch_and_override():
+    with pytest.raises(RuntimeError, match=r'unexpected ctx.run\("demo.leaf"\)'):
+        await fake_ctx().run(SimpleNamespace(name="demo.leaf"))
+    override = local_ctx()
+    assert fake_ctx(override) is override
+
+
+async def test_recursive_sync_and_async_bodies_receive_same_context():
+    app = Workflows()
+    seen = []
+
+    @app.task(name="testutils.leaf")
+    def leaf(ctx, value):
+        seen.append(ctx)
+        return value + 1
+
+    @app.task(name="testutils.parent")
+    async def parent(ctx, value):
+        seen.append(ctx)
+        return await ctx.run(leaf, value=value)
+
+    ctx = local_ctx()
+    assert await ctx.run(parent, 3) == 4
+    assert seen == [ctx, ctx]
+    with pytest.raises(TypeError, match="not a task definition"):
+        await ctx.run(SimpleNamespace(name="bad"))