def test_components_find(benchmark, components):
class Foo:
pass
class Bar(Foo):
pass
c1 = components.Components()
c2 = c1.push()
c3 = c2.push()
c4 = c3.push()
foo = c1.add(Foo())
bar = c2.add(Bar(), name="bar")
foobar = c3.add(Foo(), name="bar")
barbar = c4.add(Bar(), name="bar")
def find():
assert c3.find(Foo) == {None: foo, "bar": foobar}
assert c3.find(Bar) == {"bar": bar}
assert c4.find(Bar) == {"bar": barbar}
assert c3.get(Bar, name="bar") == bar
assert c4.get(Bar, name="bar") == barbar
benchmark(find)
def buvar_context(buvar_config_source):
from buvar import components
context = components.Components()
context.add(buvar_config_source)
return context
def test_components_get(benchmark):
from buvar import components
class Foo:
pass
class Bar(Foo):
pass
class Baz(Bar):
pass
c = components.Components()
foo = Foo()
baz = Baz()
c.add(foo)
c.add(baz)
def test():
assert c.get(Bar) == baz
assert c.get(Foo) == baz
assert c.get(Baz) == baz
benchmark(test)
def test_stage_components():
import asyncio
from buvar import plugin, components, context
async def test_plugin(load: plugin.Loader):
assert context.get(str) == "foo"
context.add("bar", name="bar")
async def task1():
assert context.get(str, name="bar") == "bar"
asyncio.sleep(0.02)
context.add("task1", name="bar")
asyncio.sleep(0.01)
assert context.get(str, name="bar") == "task1"
async def task2():
assert context.get(str, name="bar") == "bar"
asyncio.sleep(0.01)
context.add("task2", name="bar")
asyncio.sleep(0.02)
assert context.get(str, name="bar") == "task2"
yield task1()
yield task2()
cmps = components.Components()
cmps.add("foo")
plugin.stage(test_plugin, components=cmps)
async def nject(self, *targets, **dependencies):
"""Resolve all dependencies and return the created component."""
# create components
cmps = components.Components()
# add default unnamed dependencies
# every non-default argument of the same type gets its value
# XXX is this good?
for dep in dependencies.values():
cmps.add(dep)
# add current context
current_context = context.current_context()
stack = current_context.stack if current_context else []
cmps = cmps.push(*stack)
# add default named dependencies
cmps = cmps.push()
for name, dep in dependencies.items():
cmps.add(dep, name=name)
# find the proper components to instantiate that class
injected = [
await self.resolve_adapter(cmps, target, name=name)
for name, target in ((None, target) for target in targets)
]
if len(targets) == 1:
return injected[0]
return injected
def test_components_get_bytes_name():
from buvar import components
c = components.Components()
c.add("foo", b"bar")
assert c.get(b"bar") == "foo"
def test_components_get_basic():
from buvar import components
c = components.Components()
c.add("foo", "bar")
assert c.get("bar") == "foo"
def test_components_add_name_any(components):
c = components.Components()
c.add("foo", name=("bar", 123))
foo = c.get(str, name=("bar", 123))
assert foo == "foo"
def test_components_deep_find():
from buvar import components
c = components.Components()
c.add("foo")
cc = c.push()
cc.add("bar", name="bar")
assert c.find(str) == {None: "foo"}
assert cc.find(str) == {None: "foo", "bar": "bar"}
def test_components_no_instance():
from buvar import components
c = components.Components()
class Foo:
pass
with pytest.raises(ValueError):
c.add(Foo)
def test_components_push_pop(benchmark, components):
c = components.Components()
c.add("foo")
def pushpop():
cc = c.push()
cc.add("bar", name="bar")
assert c.find(str) == cc.pop().find(str)
benchmark(pushpop)
assert c.find(str) == {None: "foo"}
def test_componentsn_find_str(components):
c = components.Components()
c.add("foo", "foo")
space = c.find("foo")
assert space == {None: "foo"}
@attr.s(auto_attribs=True)
class GeneralConfig:
"""Simple config."""
log_level: str = "INFO"
plugins: typing.Set[str] = set()
# get config from file
user_config = toml.load(
os.environ.get("USER_CONFIG",
os.path.dirname(__file__) + "/user_config.toml"))
# your components registry
cmps = components.Components()
# make config values overwritable by environment vars
source = cmps.add(config.ConfigSource(user_config, env_prefix="APP"))
general_config = cmps.add(source.load(GeneralConfig))
# setup structlog
log.setup_logging(tty=sys.stdout.isatty(), level=general_config.log_level)
sl = structlog.get_logger()
sl.info("Starting process", pid=os.getpid())
sl.debug("Config used", **source)
plugin.stage(config, *general_config.plugins, components=cmps)
