From 4a5241bb252433af0659de00ae1772451239f390 Mon Sep 17 00:00:00 2001 From: Roman Mogylatov Date: Sat, 16 Oct 2021 12:28:04 -0400 Subject: [PATCH] Migrate dependency provider tests --- tests/unit/providers/test_base_py2_py3.py | 340 ----------------- .../unit/providers/test_dependency_py2_py3.py | 348 ++++++++++++++++++ 2 files changed, 348 insertions(+), 340 deletions(-) create mode 100644 tests/unit/providers/test_dependency_py2_py3.py diff --git a/tests/unit/providers/test_base_py2_py3.py b/tests/unit/providers/test_base_py2_py3.py index 18d1c72b..1abb8d84 100644 --- a/tests/unit/providers/test_base_py2_py3.py +++ b/tests/unit/providers/test_base_py2_py3.py @@ -1,7 +1,6 @@ """Dependency injector base providers unit tests.""" import unittest -import warnings from dependency_injector import ( containers, @@ -11,345 +10,6 @@ from dependency_injector import ( from pytest import raises -class DependencyTests(unittest.TestCase): - - def setUp(self): - self.provider = providers.Dependency(instance_of=list) - - def test_init_optional(self): - list_provider = providers.List(1, 2, 3) - provider = providers.Dependency() - provider.set_instance_of(list) - provider.set_default(list_provider) - - assert provider.instance_of is list - assert provider.default is list_provider - assert provider() == [1, 2, 3] - - def test_set_instance_of_returns_self(self): - provider = providers.Dependency() - assert provider.set_instance_of(list) is provider - - def test_set_default_returns_self(self): - provider = providers.Dependency() - assert provider.set_default(providers.Provider()) is provider - - def test_init_with_not_class(self): - with raises(TypeError): - providers.Dependency(object()) - - def test_with_abc(self): - try: - import collections.abc as collections_abc - except ImportError: - import collections as collections_abc - - provider = providers.Dependency(collections_abc.Mapping) - provider.provided_by(providers.Factory(dict)) - - assert isinstance(provider(), collections_abc.Mapping) - assert isinstance(provider(), dict) - - def test_is_provider(self): - assert providers.is_provider(self.provider) is True - - def test_provided_instance_provider(self): - assert isinstance(self.provider.provided, providers.ProvidedInstance) - - def test_default(self): - provider = providers.Dependency(instance_of=dict, default={"foo": "bar"}) - assert provider() == {"foo": "bar"} - - def test_default_attribute(self): - provider = providers.Dependency(instance_of=dict, default={"foo": "bar"}) - assert provider.default() == {"foo": "bar"} - - def test_default_provider(self): - provider = providers.Dependency(instance_of=dict, default=providers.Factory(dict, foo="bar")) - assert provider.default() == {"foo": "bar"} - - def test_default_attribute_provider(self): - default = providers.Factory(dict, foo="bar") - provider = providers.Dependency(instance_of=dict, default=default) - - assert provider.default() == {"foo": "bar"} - assert provider.default is default - - def test_is_defined(self): - provider = providers.Dependency() - assert provider.is_defined is False - - def test_is_defined_when_overridden(self): - provider = providers.Dependency() - provider.override("value") - assert provider.is_defined is True - - def test_is_defined_with_default(self): - provider = providers.Dependency(default="value") - assert provider.is_defined is True - - def test_call_overridden(self): - self.provider.provided_by(providers.Factory(list)) - assert isinstance(self.provider(), list) - - def test_call_overridden_but_not_instance_of(self): - self.provider.provided_by(providers.Factory(dict)) - with raises(errors.Error): - self.provider() - - def test_call_undefined(self): - with raises(errors.Error, match="Dependency is not defined"): - self.provider() - - def test_call_undefined_error_message_with_container_instance_parent(self): - class UserService: - def __init__(self, database): - self.database = database - - class Container(containers.DeclarativeContainer): - database = providers.Dependency() - - user_service = providers.Factory( - UserService, - database=database, # <---- missing dependency - ) - - container = Container() - - with raises(errors.Error) as exception_info: - container.user_service() - assert str(exception_info.value) == "Dependency \"Container.database\" is not defined" - - def test_call_undefined_error_message_with_container_provider_parent_deep(self): - class Database: - pass - - class UserService: - def __init__(self, db): - self.db = db - - class Gateways(containers.DeclarativeContainer): - database_client = providers.Singleton(Database) - - class Services(containers.DeclarativeContainer): - gateways = providers.DependenciesContainer() - - user = providers.Factory( - UserService, - db=gateways.database_client, - ) - - class Container(containers.DeclarativeContainer): - gateways = providers.Container(Gateways) - - services = providers.Container( - Services, - # gateways=gateways, # <---- missing dependency - ) - - container = Container() - - with raises(errors.Error) as exception_info: - container.services().user() - assert str(exception_info.value) == "Dependency \"Container.services.gateways.database_client\" is not defined" - - def test_call_undefined_error_message_with_dependenciescontainer_provider_parent(self): - class UserService: - def __init__(self, db): - self.db = db - - class Services(containers.DeclarativeContainer): - gateways = providers.DependenciesContainer() - - user = providers.Factory( - UserService, - db=gateways.database_client, # <---- missing dependency - ) - - services = Services() - - with raises(errors.Error) as exception_info: - services.user() - assert str(exception_info.value) == "Dependency \"Services.gateways.database_client\" is not defined" - - def test_assign_parent(self): - parent = providers.DependenciesContainer() - provider = providers.Dependency() - - provider.assign_parent(parent) - - assert provider.parent is parent - - def test_parent_name(self): - container = containers.DynamicContainer() - provider = providers.Dependency() - container.name = provider - assert provider.parent_name == "name" - - def test_parent_name_with_deep_parenting(self): - provider = providers.Dependency() - container = providers.DependenciesContainer(name=provider) - _ = providers.DependenciesContainer(container=container) - assert provider.parent_name == "container.name" - - def test_parent_name_is_none(self): - provider = providers.DependenciesContainer() - assert provider.parent_name is None - - def test_parent_deepcopy(self): - container = containers.DynamicContainer() - provider = providers.Dependency() - container.name = provider - - copied = providers.deepcopy(container) - - assert container.name.parent is container - assert copied.name.parent is copied - - assert container is not copied - assert container.name is not copied.name - assert container.name.parent is not copied.name.parent - - def test_forward_attr_to_default(self): - default = providers.Configuration() - - provider = providers.Dependency(default=default) - provider.from_dict({"foo": "bar"}) - - assert default() == {"foo": "bar"} - - def test_forward_attr_to_overriding(self): - overriding = providers.Configuration() - - provider = providers.Dependency() - provider.override(overriding) - provider.from_dict({"foo": "bar"}) - - assert overriding() == {"foo": "bar"} - - def test_forward_attr_to_none(self): - provider = providers.Dependency() - with raises(AttributeError): - provider.from_dict - - def test_deepcopy(self): - provider = providers.Dependency(int) - - provider_copy = providers.deepcopy(provider) - - assert provider is not provider_copy - assert isinstance(provider, providers.Dependency) - - def test_deepcopy_from_memo(self): - provider = providers.Dependency(int) - provider_copy_memo = providers.Provider() - - provider_copy = providers.deepcopy( - provider, memo={id(provider): provider_copy_memo}) - - assert provider_copy is provider_copy_memo - - def test_deepcopy_overridden(self): - provider = providers.Dependency(int) - overriding_provider = providers.Provider() - - provider.override(overriding_provider) - - provider_copy = providers.deepcopy(provider) - overriding_provider_copy = provider_copy.overridden[0] - - assert provider is not provider_copy - assert isinstance(provider, providers.Dependency) - - assert overriding_provider is not overriding_provider_copy - assert isinstance(overriding_provider_copy, providers.Provider) - - def test_deep_copy_default_object(self): - default = {"foo": "bar"} - provider = providers.Dependency(dict, default=default) - - provider_copy = providers.deepcopy(provider) - - assert provider_copy() is default - assert provider_copy.default() is default - - def test_deep_copy_default_provider(self): - bar = object() - default = providers.Factory(dict, foo=providers.Object(bar)) - provider = providers.Dependency(dict, default=default) - - provider_copy = providers.deepcopy(provider) - - assert provider_copy() == {"foo": bar} - assert provider_copy.default() == {"foo": bar} - assert provider_copy()["foo"] is bar - - def test_with_container_default_object(self): - default = {"foo": "bar"} - - class Container(containers.DeclarativeContainer): - provider = providers.Dependency(dict, default=default) - - container = Container() - - assert container.provider() is default - assert container.provider.default() is default - - def test_with_container_default_provider(self): - bar = object() - - class Container(containers.DeclarativeContainer): - provider = providers.Dependency(dict, default=providers.Factory(dict, foo=providers.Object(bar))) - - container = Container() - - assert container.provider() == {"foo": bar} - assert container.provider.default() == {"foo": bar} - assert container.provider()["foo"] is bar - - def test_with_container_default_provider_with_overriding(self): - bar = object() - baz = object() - - class Container(containers.DeclarativeContainer): - provider = providers.Dependency(dict, default=providers.Factory(dict, foo=providers.Object(bar))) - - container = Container(provider=providers.Factory(dict, foo=providers.Object(baz))) - - assert container.provider() == {"foo": baz} - assert container.provider.default() == {"foo": bar} - assert container.provider()["foo"] is baz - - def test_repr(self): - assert repr(self.provider) == ( - "".format(repr(list), hex(id(self.provider))) - ) - - def test_repr_in_container(self): - class Container(containers.DeclarativeContainer): - dependency = providers.Dependency(instance_of=int) - - container = Container() - - assert repr(container.dependency) == ( - "".format( - repr(int), - hex(id(container.dependency)), - ) - ) - - -class ExternalDependencyTests(unittest.TestCase): - - def setUp(self): - self.provider = providers.ExternalDependency(instance_of=list) - - def test_is_instance(self): - assert isinstance(self.provider, providers.Dependency) - - class DependenciesContainerTests(unittest.TestCase): class Container(containers.DeclarativeContainer): diff --git a/tests/unit/providers/test_dependency_py2_py3.py b/tests/unit/providers/test_dependency_py2_py3.py new file mode 100644 index 00000000..c4c2cea1 --- /dev/null +++ b/tests/unit/providers/test_dependency_py2_py3.py @@ -0,0 +1,348 @@ +"""Dependency provider tests.""" + +from dependency_injector import containers, providers, errors +from pytest import fixture, raises + + +@fixture +def provider(): + return providers.Dependency(instance_of=list) + + +def test_init_optional(): + list_provider = providers.List(1, 2, 3) + provider = providers.Dependency() + provider.set_instance_of(list) + provider.set_default(list_provider) + + assert provider.instance_of is list + assert provider.default is list_provider + assert provider() == [1, 2, 3] + + +def test_set_instance_of_returns_self(provider): + assert provider.set_instance_of(list) is provider + + +def test_set_default_returns_self(provider): + assert provider.set_default(providers.Provider()) is provider + + +def test_init_with_not_class(): + with raises(TypeError): + providers.Dependency(object()) + + +def test_with_abc(): + try: + import collections.abc as collections_abc + except ImportError: + import collections as collections_abc + + provider = providers.Dependency(collections_abc.Mapping) + provider.provided_by(providers.Factory(dict)) + + assert isinstance(provider(), collections_abc.Mapping) + assert isinstance(provider(), dict) + + +def test_is_provider(provider): + assert providers.is_provider(provider) is True + + +def test_provided_instance_provider(provider): + assert isinstance(provider.provided, providers.ProvidedInstance) + + +def test_default(): + provider = providers.Dependency(instance_of=dict, default={"foo": "bar"}) + assert provider() == {"foo": "bar"} + + +def test_default_attribute(): + provider = providers.Dependency(instance_of=dict, default={"foo": "bar"}) + assert provider.default() == {"foo": "bar"} + + +def test_default_provider(): + provider = providers.Dependency(instance_of=dict, default=providers.Factory(dict, foo="bar")) + assert provider.default() == {"foo": "bar"} + + +def test_default_attribute_provider(): + default = providers.Factory(dict, foo="bar") + provider = providers.Dependency(instance_of=dict, default=default) + + assert provider.default() == {"foo": "bar"} + assert provider.default is default + + +def test_is_defined(provider): + assert provider.is_defined is False + + +def test_is_defined_when_overridden(provider): + provider.override("value") + assert provider.is_defined is True + + +def test_is_defined_with_default(): + provider = providers.Dependency(default="value") + assert provider.is_defined is True + + +def test_call_overridden(provider): + provider.provided_by(providers.Factory(list)) + assert isinstance(provider(), list) + + +def test_call_overridden_but_not_instance_of(provider): + provider.provided_by(providers.Factory(dict)) + with raises(errors.Error): + provider() + + +def test_call_undefined(provider): + with raises(errors.Error, match="Dependency is not defined"): + provider() + + +def test_call_undefined_error_message_with_container_instance_parent(): + class UserService: + def __init__(self, database): + self.database = database + + class Container(containers.DeclarativeContainer): + database = providers.Dependency() + + user_service = providers.Factory( + UserService, + database=database, # <---- missing dependency + ) + + container = Container() + + with raises(errors.Error, match="Dependency \"Container.database\" is not defined"): + container.user_service() + + +def test_call_undefined_error_message_with_container_provider_parent_deep(): + class Database: + pass + + class UserService: + def __init__(self, db): + self.db = db + + class Gateways(containers.DeclarativeContainer): + database_client = providers.Singleton(Database) + + class Services(containers.DeclarativeContainer): + gateways = providers.DependenciesContainer() + + user = providers.Factory( + UserService, + db=gateways.database_client, + ) + + class Container(containers.DeclarativeContainer): + gateways = providers.Container(Gateways) + + services = providers.Container( + Services, + # gateways=gateways, # <---- missing dependency + ) + + container = Container() + + with raises(errors.Error, match="Dependency \"Container.services.gateways.database_client\" is not defined"): + container.services().user() + + +def test_call_undefined_error_message_with_dependenciescontainer_provider_parent(): + class UserService: + def __init__(self, db): + self.db = db + + class Services(containers.DeclarativeContainer): + gateways = providers.DependenciesContainer() + + user = providers.Factory( + UserService, + db=gateways.database_client, # <---- missing dependency + ) + + services = Services() + + with raises(errors.Error, match="Dependency \"Services.gateways.database_client\" is not defined"): + services.user() + + +def test_assign_parent(provider): + parent = providers.DependenciesContainer() + provider.assign_parent(parent) + assert provider.parent is parent + + +def test_parent_name(provider): + container = containers.DynamicContainer() + container.name = provider + assert provider.parent_name == "name" + + +def test_parent_name_with_deep_parenting(provider): + container = providers.DependenciesContainer(name=provider) + _ = providers.DependenciesContainer(container=container) + assert provider.parent_name == "container.name" + + +def test_parent_name_is_none(): + provider = providers.Dependency() + assert provider.parent_name is None + + +def test_parent_deepcopy(provider): + container = containers.DynamicContainer() + container.name = provider + + copied = providers.deepcopy(container) + + assert container.name.parent is container + assert copied.name.parent is copied + + assert container is not copied + assert container.name is not copied.name + assert container.name.parent is not copied.name.parent + + +def test_forward_attr_to_default(): + default = providers.Configuration() + provider = providers.Dependency(default=default) + provider.from_dict({"foo": "bar"}) + assert default() == {"foo": "bar"} + + +def test_forward_attr_to_overriding(provider): + overriding = providers.Configuration() + provider.override(overriding) + provider.from_dict({"foo": "bar"}) + assert overriding() == {"foo": "bar"} + + +def test_forward_attr_to_none(provider): + with raises(AttributeError): + provider.from_dict + + +def test_deepcopy(provider): + provider_copy = providers.deepcopy(provider) + assert provider is not provider_copy + assert isinstance(provider, providers.Dependency) + + +def test_deepcopy_from_memo(provider): + provider_copy_memo = providers.Provider() + provider_copy = providers.deepcopy(provider, memo={id(provider): provider_copy_memo}) + assert provider_copy is provider_copy_memo + + +def test_deepcopy_overridden(provider): + overriding_provider = providers.Provider() + + provider.override(overriding_provider) + + provider_copy = providers.deepcopy(provider) + overriding_provider_copy = provider_copy.overridden[0] + + assert provider is not provider_copy + assert isinstance(provider, providers.Dependency) + + assert overriding_provider is not overriding_provider_copy + assert isinstance(overriding_provider_copy, providers.Provider) + + +def test_deep_copy_default_object(): + default = {"foo": "bar"} + provider = providers.Dependency(dict, default=default) + + provider_copy = providers.deepcopy(provider) + + assert provider_copy() is default + assert provider_copy.default() is default + + +def test_deep_copy_default_provider(): + bar = object() + default = providers.Factory(dict, foo=providers.Object(bar)) + provider = providers.Dependency(dict, default=default) + + provider_copy = providers.deepcopy(provider) + + assert provider_copy() == {"foo": bar} + assert provider_copy.default() == {"foo": bar} + assert provider_copy()["foo"] is bar + + +def test_with_container_default_object(): + default = {"foo": "bar"} + + class Container(containers.DeclarativeContainer): + provider = providers.Dependency(dict, default=default) + + container = Container() + + assert container.provider() is default + assert container.provider.default() is default + + +def test_with_container_default_provider(): + bar = object() + + class Container(containers.DeclarativeContainer): + provider = providers.Dependency(dict, default=providers.Factory(dict, foo=providers.Object(bar))) + + container = Container() + + assert container.provider() == {"foo": bar} + assert container.provider.default() == {"foo": bar} + assert container.provider()["foo"] is bar + + +def test_with_container_default_provider_with_overriding(): + bar = object() + baz = object() + + class Container(containers.DeclarativeContainer): + provider = providers.Dependency(dict, default=providers.Factory(dict, foo=providers.Object(bar))) + + container = Container(provider=providers.Factory(dict, foo=providers.Object(baz))) + + assert container.provider() == {"foo": baz} + assert container.provider.default() == {"foo": bar} + assert container.provider()["foo"] is baz + + +def test_repr(provider): + assert repr(provider) == ( + "".format(repr(list), hex(id(provider))) + ) + + +def test_repr_in_container(): + class Container(containers.DeclarativeContainer): + dependency = providers.Dependency(instance_of=int) + + container = Container() + + assert repr(container.dependency) == ( + "".format( + repr(int), + hex(id(container.dependency)), + ) + ) + + +def test_external_dependency(): + assert isinstance(providers.ExternalDependency(), providers.Dependency)