wehub-resource-sync
170 lines
4.7 KiB
Python
170 lines
4.7 KiB
Python
from __future__ import annotations
|
|
|
|
import pytest
|
|
|
|
from agents.sandbox.session import (
|
|
Dependencies,
|
|
DependenciesBindingError,
|
|
DependenciesMissingDependencyError,
|
|
)
|
|
|
|
|
|
class _AsyncClosable:
|
|
def __init__(self) -> None:
|
|
self.calls = 0
|
|
|
|
async def aclose(self) -> None:
|
|
self.calls += 1
|
|
|
|
|
|
class _AsyncCloseMethod:
|
|
def __init__(self) -> None:
|
|
self.calls = 0
|
|
|
|
async def close(self) -> None:
|
|
self.calls += 1
|
|
|
|
|
|
class _SyncClosable:
|
|
def __init__(self) -> None:
|
|
self.calls = 0
|
|
|
|
def close(self) -> None:
|
|
self.calls += 1
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_dependencies_with_values_binds_multiple_values() -> None:
|
|
key1 = "tests.with_values.str"
|
|
key2 = "tests.with_values.int"
|
|
dependencies = Dependencies.with_values({key1: "hello", key2: 123})
|
|
|
|
assert await dependencies.require(key1) == "hello"
|
|
assert await dependencies.require(key2) == 123
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_dependencies_bind_value_and_require() -> None:
|
|
dependencies = Dependencies()
|
|
key = "tests.value"
|
|
dependencies.bind_value(key, "hello")
|
|
|
|
assert await dependencies.get(key) == "hello"
|
|
assert await dependencies.require(key, consumer="test") == "hello"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_dependencies_missing_dependency_includes_key_and_consumer() -> None:
|
|
dependencies = Dependencies()
|
|
key = "tests.missing"
|
|
|
|
with pytest.raises(DependenciesMissingDependencyError, match="tests.missing"):
|
|
await dependencies.require(key, consumer="SedimentFile")
|
|
|
|
|
|
def test_dependencies_duplicate_binding_raises() -> None:
|
|
dependencies = Dependencies()
|
|
key = "tests.dup"
|
|
dependencies.bind_value(key, "a")
|
|
|
|
with pytest.raises(DependenciesBindingError, match="already bound"):
|
|
dependencies.bind_value(key, "b")
|
|
|
|
|
|
def test_dependencies_empty_key_raises() -> None:
|
|
dependencies = Dependencies()
|
|
|
|
with pytest.raises(ValueError, match="non-empty"):
|
|
dependencies.bind_value("", "x")
|
|
|
|
with pytest.raises(ValueError, match="non-empty"):
|
|
dependencies.bind_factory("", lambda _dependencies: "x")
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_dependencies_cached_factory_resolves_once() -> None:
|
|
dependencies = Dependencies()
|
|
key = "tests.cached_factory"
|
|
calls = 0
|
|
|
|
def _factory(_dependencies: Dependencies) -> str:
|
|
nonlocal calls
|
|
calls += 1
|
|
return f"value-{calls}"
|
|
|
|
dependencies.bind_factory(key, _factory, cache=True)
|
|
|
|
assert await dependencies.require(key) == "value-1"
|
|
assert await dependencies.require(key) == "value-1"
|
|
assert calls == 1
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_dependencies_uncached_factory_resolves_every_time() -> None:
|
|
dependencies = Dependencies()
|
|
key = "tests.uncached_factory"
|
|
calls = 0
|
|
|
|
def _factory(_dependencies: Dependencies) -> str:
|
|
nonlocal calls
|
|
calls += 1
|
|
return f"value-{calls}"
|
|
|
|
dependencies.bind_factory(key, _factory, cache=False)
|
|
|
|
assert await dependencies.require(key) == "value-1"
|
|
assert await dependencies.require(key) == "value-2"
|
|
assert calls == 2
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_dependencies_async_factory_supported() -> None:
|
|
dependencies = Dependencies()
|
|
key = "tests.async_factory"
|
|
|
|
async def _factory(_dependencies: Dependencies) -> str:
|
|
return "async-value"
|
|
|
|
dependencies.bind_factory(key, _factory)
|
|
assert await dependencies.require(key) == "async-value"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_dependencies_aclose_closes_owned_results_and_is_idempotent() -> None:
|
|
dependencies = Dependencies()
|
|
k1 = "tests.async_aclose"
|
|
k2 = "tests.async_close"
|
|
k3 = "tests.sync_close"
|
|
|
|
dependencies.bind_factory(k1, lambda _deps: _AsyncClosable(), owns_result=True)
|
|
dependencies.bind_factory(k2, lambda _deps: _AsyncCloseMethod(), owns_result=True)
|
|
dependencies.bind_factory(k3, lambda _deps: _SyncClosable(), owns_result=True, cache=False)
|
|
|
|
v1 = await dependencies.require(k1)
|
|
v2 = await dependencies.require(k2)
|
|
v3a = await dependencies.require(k3)
|
|
v3b = await dependencies.require(k3)
|
|
|
|
assert v3a is not v3b
|
|
|
|
await dependencies.aclose()
|
|
await dependencies.aclose()
|
|
|
|
assert isinstance(v1, _AsyncClosable) and v1.calls == 1
|
|
assert isinstance(v2, _AsyncCloseMethod) and v2.calls == 1
|
|
assert isinstance(v3a, _SyncClosable) and v3a.calls == 1
|
|
assert isinstance(v3b, _SyncClosable) and v3b.calls == 1
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_dependencies_bound_values_are_not_closed() -> None:
|
|
dependencies = Dependencies()
|
|
key = "tests.bound_value"
|
|
value = _SyncClosable()
|
|
dependencies.bind_value(key, value)
|
|
|
|
_ = await dependencies.require(key)
|
|
await dependencies.aclose()
|
|
|
|
assert value.calls == 0
|