mirror of
https://github.com/ets-labs/python-dependency-injector.git
synced 2025-07-04 20:33:13 +03:00
Migrate selector provider tests
This commit is contained in:
Roman Mogylatov
parent
7774ed391d
commit
d9ba72f950
|
|
@ -1,220 +1,209 @@
|
|||
"""Dependency injector selector provider unit tests."""
|
||||
"""Selector provider tests."""
|
||||
|
||||
import functools
|
||||
import itertools
|
||||
import sys
|
||||
|
||||
import unittest
|
||||
|
||||
from dependency_injector import providers, errors
|
||||
from pytest import raises
|
||||
from pytest import fixture, mark, raises
|
||||
|
||||
|
||||
class SelectorTests(unittest.TestCase):
|
||||
@fixture
|
||||
def switch():
|
||||
return providers.Configuration()
|
||||
|
||||
selector = providers.Configuration()
|
||||
|
||||
def test_is_provider(self):
|
||||
assert providers.is_provider(providers.Selector(self.selector)) is True
|
||||
@fixture
|
||||
def one():
|
||||
return providers.Object(1)
|
||||
|
||||
def test_init_optional(self):
|
||||
one = providers.Object(1)
|
||||
two = providers.Object(2)
|
||||
|
||||
provider = providers.Selector()
|
||||
provider.set_selector(self.selector)
|
||||
provider.set_providers(one=one, two=two)
|
||||
@fixture
|
||||
def two():
|
||||
return providers.Object(2)
|
||||
|
||||
assert provider.providers == {"one": one, "two": two}
|
||||
with self.selector.override("one"):
|
||||
assert provider() == one()
|
||||
with self.selector.override("two"):
|
||||
assert provider() == two()
|
||||
|
||||
def test_set_selector_returns_self(self):
|
||||
provider = providers.Selector()
|
||||
assert provider.set_selector(self.selector) is provider
|
||||
@fixture
|
||||
def selector_type():
|
||||
return "default"
|
||||
|
||||
def test_set_providers_returns_self(self):
|
||||
provider = providers.Selector()
|
||||
assert provider.set_providers(one=providers.Provider()) is provider
|
||||
|
||||
def test_provided_instance_provider(self):
|
||||
provider = providers.Selector(self.selector)
|
||||
assert isinstance(provider.provided, providers.ProvidedInstance)
|
||||
|
||||
def test_call(self):
|
||||
provider = providers.Selector(
|
||||
self.selector,
|
||||
one=providers.Object(1),
|
||||
two=providers.Object(2),
|
||||
@fixture
|
||||
def selector(selector_type, switch, one, two):
|
||||
if selector_type == "default":
|
||||
return providers.Selector(switch, one=one, two=two)
|
||||
elif selector_type == "empty":
|
||||
return providers.Selector()
|
||||
elif selector_type == "sys-streams":
|
||||
return providers.Selector(
|
||||
switch,
|
||||
stdin=providers.Object(sys.stdin),
|
||||
stdout=providers.Object(sys.stdout),
|
||||
stderr=providers.Object(sys.stderr),
|
||||
)
|
||||
else:
|
||||
raise ValueError("Unknown selector type \"{0}\"".format(selector_type))
|
||||
|
||||
with self.selector.override("one"):
|
||||
assert provider() == 1
|
||||
|
||||
with self.selector.override("two"):
|
||||
assert provider() == 2
|
||||
def test_is_provider(selector):
|
||||
assert providers.is_provider(selector) is True
|
||||
|
||||
def test_call_undefined_provider(self):
|
||||
provider = providers.Selector(
|
||||
self.selector,
|
||||
one=providers.Object(1),
|
||||
two=providers.Object(2),
|
||||
)
|
||||
|
||||
with self.selector.override("three"):
|
||||
@mark.parametrize("selector_type", ["empty"])
|
||||
def test_init_optional(selector, switch, one, two):
|
||||
selector.set_selector(switch)
|
||||
selector.set_providers(one=one, two=two)
|
||||
|
||||
assert selector.providers == {"one": one, "two": two}
|
||||
with switch.override("one"):
|
||||
assert selector() == one()
|
||||
with switch.override("two"):
|
||||
assert selector() == two()
|
||||
|
||||
|
||||
def test_set_selector_returns_self(selector, switch):
|
||||
assert selector.set_selector(switch) is selector
|
||||
|
||||
|
||||
def test_set_providers_returns_self(selector, one):
|
||||
assert selector.set_providers(one=one) is selector
|
||||
|
||||
|
||||
def test_provided_instance_provider(selector):
|
||||
assert isinstance(selector.provided, providers.ProvidedInstance)
|
||||
|
||||
|
||||
def test_call(selector, switch):
|
||||
with switch.override("one"):
|
||||
assert selector() == 1
|
||||
|
||||
with switch.override("two"):
|
||||
assert selector() == 2
|
||||
|
||||
|
||||
def test_call_undefined_provider(selector, switch):
|
||||
with switch.override("three"):
|
||||
with raises(errors.Error):
|
||||
provider()
|
||||
selector()
|
||||
|
||||
def test_call_selector_is_none(self):
|
||||
provider = providers.Selector(
|
||||
self.selector,
|
||||
one=providers.Object(1),
|
||||
two=providers.Object(2),
|
||||
)
|
||||
|
||||
with self.selector.override(None):
|
||||
def test_call_selector_is_none(selector, switch):
|
||||
with switch.override(None):
|
||||
with raises(errors.Error):
|
||||
provider()
|
||||
selector()
|
||||
|
||||
def test_call_any_callable(self):
|
||||
provider = providers.Selector(
|
||||
functools.partial(next, itertools.cycle(["one", "two"])),
|
||||
|
||||
@mark.parametrize("selector_type", ["empty"])
|
||||
def test_call_any_callable(selector):
|
||||
selector.set_selector(functools.partial(next, itertools.cycle(["one", "two"])))
|
||||
selector.set_providers(
|
||||
one=providers.Object(1),
|
||||
two=providers.Object(2),
|
||||
)
|
||||
|
||||
assert provider() == 1
|
||||
assert provider() == 2
|
||||
assert provider() == 1
|
||||
assert provider() == 2
|
||||
assert selector() == 1
|
||||
assert selector() == 2
|
||||
assert selector() == 1
|
||||
assert selector() == 2
|
||||
|
||||
def test_call_with_context_args(self):
|
||||
provider = providers.Selector(
|
||||
self.selector,
|
||||
one=providers.Callable(lambda *args, **kwargs: (args, kwargs)),
|
||||
)
|
||||
|
||||
with self.selector.override("one"):
|
||||
args, kwargs = provider(1, 2, three=3, four=4)
|
||||
@mark.parametrize("selector_type", ["empty"])
|
||||
def test_call_with_context_args(selector, switch):
|
||||
selector.set_selector(switch)
|
||||
selector.set_providers(one=providers.Callable(lambda *args, **kwargs: (args, kwargs)))
|
||||
|
||||
with switch.override("one"):
|
||||
args, kwargs = selector(1, 2, three=3, four=4)
|
||||
|
||||
assert args == (1, 2)
|
||||
assert kwargs == {"three": 3, "four": 4}
|
||||
|
||||
def test_getattr(self):
|
||||
provider_one = providers.Object(1)
|
||||
provider_two = providers.Object(2)
|
||||
|
||||
provider = providers.Selector(
|
||||
self.selector,
|
||||
one=provider_one,
|
||||
two=provider_two,
|
||||
)
|
||||
def test_getattr(selector, one, two):
|
||||
assert selector.one is one
|
||||
assert selector.two is two
|
||||
|
||||
assert provider.one is provider_one
|
||||
assert provider.two is provider_two
|
||||
|
||||
def test_getattr_attribute_error(self):
|
||||
provider_one = providers.Object(1)
|
||||
provider_two = providers.Object(2)
|
||||
|
||||
provider = providers.Selector(
|
||||
self.selector,
|
||||
one=provider_one,
|
||||
two=provider_two,
|
||||
)
|
||||
|
||||
def test_getattr_attribute_error(selector):
|
||||
with raises(AttributeError):
|
||||
_ = provider.provider_three
|
||||
_ = selector.provider_three
|
||||
|
||||
def test_call_overridden(self):
|
||||
provider = providers.Selector(self.selector, sample=providers.Object(1))
|
||||
overriding_provider1 = providers.Selector(self.selector, sample=providers.Object(2))
|
||||
overriding_provider2 = providers.Selector(self.selector, sample=providers.Object(3))
|
||||
|
||||
provider.override(overriding_provider1)
|
||||
provider.override(overriding_provider2)
|
||||
def test_call_overridden(selector, switch):
|
||||
overriding_provider1 = providers.Selector(switch, one=providers.Object(2))
|
||||
overriding_provider2 = providers.Selector(switch, one=providers.Object(3))
|
||||
|
||||
with self.selector.override("sample"):
|
||||
assert provider() == 3
|
||||
selector.override(overriding_provider1)
|
||||
selector.override(overriding_provider2)
|
||||
|
||||
def test_providers_attribute(self):
|
||||
provider_one = providers.Object(1)
|
||||
provider_two = providers.Object(2)
|
||||
with switch.override("one"):
|
||||
assert selector() == 3
|
||||
|
||||
provider = providers.Selector(
|
||||
self.selector,
|
||||
one=provider_one,
|
||||
two=provider_two,
|
||||
)
|
||||
assert provider.providers == {"one": provider_one, "two": provider_two}
|
||||
|
||||
def test_deepcopy(self):
|
||||
provider = providers.Selector(self.selector)
|
||||
def test_providers_attribute(selector, one, two):
|
||||
assert selector.providers == {"one": one, "two": two}
|
||||
|
||||
provider_copy = providers.deepcopy(provider)
|
||||
|
||||
assert provider is not provider_copy
|
||||
assert isinstance(provider, providers.Selector)
|
||||
def test_deepcopy(selector):
|
||||
provider_copy = providers.deepcopy(selector)
|
||||
|
||||
def test_deepcopy_from_memo(self):
|
||||
provider = providers.Selector(self.selector)
|
||||
provider_copy_memo = providers.Selector(self.selector)
|
||||
assert provider_copy is not selector
|
||||
assert isinstance(selector, providers.Selector)
|
||||
|
||||
assert provider_copy.selector is not selector.selector
|
||||
assert isinstance(provider_copy.selector, providers.Configuration)
|
||||
|
||||
assert provider_copy.one is not selector.one
|
||||
assert isinstance(provider_copy.one, providers.Object)
|
||||
assert provider_copy.one.provides == 1
|
||||
|
||||
assert provider_copy.two is not selector.two
|
||||
assert isinstance(provider_copy.two, providers.Object)
|
||||
assert provider_copy.two.provides == 2
|
||||
|
||||
|
||||
def test_deepcopy_from_memo(selector):
|
||||
provider_copy = providers.deepcopy(
|
||||
provider,
|
||||
memo={id(provider): provider_copy_memo},
|
||||
selector,
|
||||
memo={id(selector): selector},
|
||||
)
|
||||
assert provider_copy is selector
|
||||
|
||||
assert provider_copy is provider_copy_memo
|
||||
|
||||
def test_deepcopy_overridden(self):
|
||||
provider = providers.Selector(self.selector)
|
||||
def test_deepcopy_overridden(selector):
|
||||
object_provider = providers.Object(object())
|
||||
|
||||
provider.override(object_provider)
|
||||
selector.override(object_provider)
|
||||
|
||||
provider_copy = providers.deepcopy(provider)
|
||||
provider_copy = providers.deepcopy(selector)
|
||||
object_provider_copy = provider_copy.overridden[0]
|
||||
|
||||
assert provider is not provider_copy
|
||||
assert isinstance(provider, providers.Selector)
|
||||
assert selector is not provider_copy
|
||||
assert isinstance(selector, providers.Selector)
|
||||
|
||||
assert object_provider is not object_provider_copy
|
||||
assert isinstance(object_provider_copy, providers.Object)
|
||||
|
||||
def test_deepcopy_with_sys_streams(self):
|
||||
provider = providers.Selector(
|
||||
self.selector,
|
||||
stdin=providers.Object(sys.stdin),
|
||||
stdout=providers.Object(sys.stdout),
|
||||
stderr=providers.Object(sys.stderr),
|
||||
|
||||
)
|
||||
@mark.parametrize("selector_type", ["sys-streams"])
|
||||
def test_deepcopy_with_sys_streams(selector, switch):
|
||||
provider_copy = providers.deepcopy(selector)
|
||||
|
||||
provider_copy = providers.deepcopy(provider)
|
||||
|
||||
assert provider is not provider_copy
|
||||
assert selector is not provider_copy
|
||||
assert isinstance(provider_copy, providers.Selector)
|
||||
|
||||
with self.selector.override("stdin"):
|
||||
assert provider() is sys.stdin
|
||||
with switch.override("stdin"):
|
||||
assert selector() is sys.stdin
|
||||
|
||||
with self.selector.override("stdout"):
|
||||
assert provider() is sys.stdout
|
||||
with switch.override("stdout"):
|
||||
assert selector() is sys.stdout
|
||||
|
||||
with self.selector.override("stderr"):
|
||||
assert provider() is sys.stderr
|
||||
with switch.override("stderr"):
|
||||
assert selector() is sys.stderr
|
||||
|
||||
def test_repr(self):
|
||||
provider = providers.Selector(
|
||||
self.selector,
|
||||
one=providers.Object(1),
|
||||
two=providers.Object(2),
|
||||
)
|
||||
|
||||
assert "<dependency_injector.providers.Selector({0}".format(repr(self.selector)) in repr(provider)
|
||||
assert "one={0}".format(repr(provider.one)) in repr(provider)
|
||||
assert "two={0}".format(repr(provider.two)) in repr(provider)
|
||||
assert "at {0}".format(hex(id(provider))) in repr(provider)
|
||||
def test_repr(selector, switch):
|
||||
assert "<dependency_injector.providers.Selector({0}".format(repr(switch)) in repr(selector)
|
||||
assert "one={0}".format(repr(selector.one)) in repr(selector)
|
||||
assert "two={0}".format(repr(selector.two)) in repr(selector)
|
||||
assert "at {0}".format(hex(id(selector))) in repr(selector)
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user