From ee0c53c953c7b0e6a9da8fbb2f3e9c3632472de2 Mon Sep 17 00:00:00 2001 From: Roman Mogylatov Date: Sun, 17 Oct 2021 11:06:26 -0400 Subject: [PATCH] Migrate callable tests --- tests/unit/providers/callables/__init__.py | 1 + tests/unit/providers/callables/common.py | 5 + .../test_abstract_callable_py2_py3.py | 56 ++++ .../test_callable_delegate_py2_py3.py | 17 ++ .../callables/test_callable_py2_py3.py | 210 +++++++++++++ .../test_delegated_callable_py2_py3.py | 26 ++ .../unit/providers/test_callables_py2_py3.py | 280 ------------------ 7 files changed, 315 insertions(+), 280 deletions(-) create mode 100644 tests/unit/providers/callables/__init__.py create mode 100644 tests/unit/providers/callables/common.py create mode 100644 tests/unit/providers/callables/test_abstract_callable_py2_py3.py create mode 100644 tests/unit/providers/callables/test_callable_delegate_py2_py3.py create mode 100644 tests/unit/providers/callables/test_callable_py2_py3.py create mode 100644 tests/unit/providers/callables/test_delegated_callable_py2_py3.py delete mode 100644 tests/unit/providers/test_callables_py2_py3.py diff --git a/tests/unit/providers/callables/__init__.py b/tests/unit/providers/callables/__init__.py new file mode 100644 index 00000000..c79748fa --- /dev/null +++ b/tests/unit/providers/callables/__init__.py @@ -0,0 +1 @@ +"""Tests for callables.""" diff --git a/tests/unit/providers/callables/common.py b/tests/unit/providers/callables/common.py new file mode 100644 index 00000000..822970eb --- /dev/null +++ b/tests/unit/providers/callables/common.py @@ -0,0 +1,5 @@ +"""Common test artifacts.""" + + +def example(arg1, arg2, arg3, arg4): + return arg1, arg2, arg3, arg4 diff --git a/tests/unit/providers/callables/test_abstract_callable_py2_py3.py b/tests/unit/providers/callables/test_abstract_callable_py2_py3.py new file mode 100644 index 00000000..fa794840 --- /dev/null +++ b/tests/unit/providers/callables/test_abstract_callable_py2_py3.py @@ -0,0 +1,56 @@ +"""AbstractCallable provider tests.""" + +from dependency_injector import providers, errors +from pytest import raises + +from .common import example + + +def test_inheritance(): + assert isinstance(providers.AbstractCallable(example), providers.Callable) + + +def test_call_overridden_by_callable(): + def _abstract_example(): + pass + + provider = providers.AbstractCallable(_abstract_example) + provider.override(providers.Callable(example)) + + assert provider(1, 2, 3, 4) == (1, 2, 3, 4) + + +def test_call_overridden_by_delegated_callable(): + def _abstract_example(): + pass + + provider = providers.AbstractCallable(_abstract_example) + provider.override(providers.DelegatedCallable(example)) + + assert provider(1, 2, 3, 4) == (1, 2, 3, 4) + + +def test_call_not_overridden(): + provider = providers.AbstractCallable(example) + with raises(errors.Error): + provider(1, 2, 3, 4) + + +def test_override_by_not_callable(): + provider = providers.AbstractCallable(example) + with raises(errors.Error): + provider.override(providers.Factory(object)) + + +def test_provide_not_implemented(): + provider = providers.AbstractCallable(example) + with raises(NotImplementedError): + provider._provide((1, 2, 3, 4), dict()) + + +def test_repr(): + provider = providers.AbstractCallable(example) + assert repr(provider) == ( + "".format(repr(example), hex(id(provider))) + ) diff --git a/tests/unit/providers/callables/test_callable_delegate_py2_py3.py b/tests/unit/providers/callables/test_callable_delegate_py2_py3.py new file mode 100644 index 00000000..f33f2723 --- /dev/null +++ b/tests/unit/providers/callables/test_callable_delegate_py2_py3.py @@ -0,0 +1,17 @@ +"""CallableDelegate provider tests.""" + +from dependency_injector import providers, errors +from pytest import raises + +from .common import example + + +def test_is_delegate(): + provider = providers.Callable(example) + delegate = providers.CallableDelegate(provider) + assert isinstance(delegate, providers.Delegate) + + +def test_init_with_not_callable(): + with raises(errors.Error): + providers.CallableDelegate(providers.Object(object())) diff --git a/tests/unit/providers/callables/test_callable_py2_py3.py b/tests/unit/providers/callables/test_callable_py2_py3.py new file mode 100644 index 00000000..fade0a69 --- /dev/null +++ b/tests/unit/providers/callables/test_callable_py2_py3.py @@ -0,0 +1,210 @@ +"""Callable provider tests.""" + +import sys + +from dependency_injector import providers, errors +from pytest import raises + +from .common import example + + +def test_is_provider(): + assert providers.is_provider(providers.Callable(example)) is True + + +def test_init_with_not_callable(): + with raises(errors.Error): + providers.Callable(123) + + +def test_init_optional_provides(): + provider = providers.Callable() + provider.set_provides(object) + assert provider.provides is object + assert isinstance(provider(), object) + + +def test_set_provides_returns_(): + provider = providers.Callable() + assert provider.set_provides(object) is provider + + +def test_provided_instance_provider(): + provider = providers.Callable(example) + assert isinstance(provider.provided, providers.ProvidedInstance) + + +def test_call(): + provider = providers.Callable(lambda: True) + assert provider() is True + + +def test_call_with_positional_args(): + provider = providers.Callable(example, 1, 2, 3, 4) + assert provider() == (1, 2, 3, 4) + + +def test_call_with_keyword_args(): + provider = providers.Callable(example, arg1=1, arg2=2, arg3=3, arg4=4) + assert provider() == (1, 2, 3, 4) + + +def test_call_with_positional_and_keyword_args(): + provider = providers.Callable(example, 1, 2, arg3=3, arg4=4) + assert provider() == (1, 2, 3, 4) + + +def test_call_with_context_args(): + provider = providers.Callable(example, 1, 2) + assert provider(3, 4) == (1, 2, 3, 4) + + +def test_call_with_context_kwargs(): + provider = providers.Callable(example, arg1=1) + assert provider(arg2=2, arg3=3, arg4=4) == (1, 2, 3, 4) + + +def test_call_with_context_args_and_kwargs(): + provider = providers.Callable(example, 1) + assert provider(2, arg3=3, arg4=4) == (1, 2, 3, 4) + + +def test_fluent_interface(): + provider = providers.Singleton(example) \ + .add_args(1, 2) \ + .add_kwargs(arg3=3, arg4=4) + assert provider() == (1, 2, 3, 4) + + +def test_set_args(): + provider = providers.Callable(example) \ + .add_args(1, 2) \ + .set_args(3, 4) + assert provider.args == (3, 4) + + +def test_set_kwargs(): + provider = providers.Callable(example) \ + .add_kwargs(init_arg3=3, init_arg4=4) \ + .set_kwargs(init_arg3=4, init_arg4=5) + assert provider.kwargs == dict(init_arg3=4, init_arg4=5) + + +def test_clear_args(): + provider = providers.Callable(example) \ + .add_args(1, 2) \ + .clear_args() + assert provider.args == tuple() + + +def test_clear_kwargs(): + provider = providers.Callable(example) \ + .add_kwargs(init_arg3=3, init_arg4=4) \ + .clear_kwargs() + assert provider.kwargs == dict() + + +def test_call_overridden(): + provider = providers.Callable(example) + + provider.override(providers.Object((4, 3, 2, 1))) + provider.override(providers.Object((1, 2, 3, 4))) + + assert provider() == (1, 2, 3, 4) + + +def test_deepcopy(): + provider = providers.Callable(example) + + provider_copy = providers.deepcopy(provider) + + assert provider is not provider_copy + assert provider.provides is provider_copy.provides + assert isinstance(provider, providers.Callable) + + +def test_deepcopy_from_memo(): + provider = providers.Callable(example) + provider_copy_memo = providers.Callable(example) + + provider_copy = providers.deepcopy(provider, memo={id(provider): provider_copy_memo}) + + assert provider_copy is provider_copy_memo + + +def test_deepcopy_args(): + provider = providers.Callable(example) + dependent_provider1 = providers.Callable(list) + dependent_provider2 = providers.Callable(dict) + + provider.add_args(dependent_provider1, dependent_provider2) + + provider_copy = providers.deepcopy(provider) + dependent_provider_copy1 = provider_copy.args[0] + dependent_provider_copy2 = provider_copy.args[1] + + assert provider.args != provider_copy.args + + assert dependent_provider1.provides is dependent_provider_copy1.provides + assert dependent_provider1 is not dependent_provider_copy1 + + assert dependent_provider2.provides is dependent_provider_copy2.provides + assert dependent_provider2 is not dependent_provider_copy2 + + +def test_deepcopy_kwargs(): + provider = providers.Callable(example) + dependent_provider1 = providers.Callable(list) + dependent_provider2 = providers.Callable(dict) + + provider.add_kwargs(a1=dependent_provider1, a2=dependent_provider2) + + provider_copy = providers.deepcopy(provider) + dependent_provider_copy1 = provider_copy.kwargs["a1"] + dependent_provider_copy2 = provider_copy.kwargs["a2"] + + assert provider.kwargs != provider_copy.kwargs + + assert dependent_provider1.provides is dependent_provider_copy1.provides + assert dependent_provider1 is not dependent_provider_copy1 + + assert dependent_provider2.provides is dependent_provider_copy2.provides + assert dependent_provider2 is not dependent_provider_copy2 + + +def test_deepcopy_overridden(): + provider = providers.Callable(example) + object_provider = providers.Object(object()) + + provider.override(object_provider) + + provider_copy = providers.deepcopy(provider) + object_provider_copy = provider_copy.overridden[0] + + assert provider is not provider_copy + assert provider.provides is provider_copy.provides + assert isinstance(provider, providers.Callable) + + assert object_provider is not object_provider_copy + assert isinstance(object_provider_copy, providers.Object) + + +def test_deepcopy_with_sys_streams(): + provider = providers.Callable(example) + provider.add_args(sys.stdin) + provider.add_kwargs(a2=sys.stdout) + + provider_copy = providers.deepcopy(provider) + + assert provider is not provider_copy + assert isinstance(provider_copy, providers.Callable) + assert provider.args[0] is sys.stdin + assert provider.kwargs["a2"] is sys.stdout + + +def test_repr(): + provider = providers.Callable(example) + assert repr(provider) == ( + "".format(repr(example), hex(id(provider))) + ) diff --git a/tests/unit/providers/callables/test_delegated_callable_py2_py3.py b/tests/unit/providers/callables/test_delegated_callable_py2_py3.py new file mode 100644 index 00000000..15311164 --- /dev/null +++ b/tests/unit/providers/callables/test_delegated_callable_py2_py3.py @@ -0,0 +1,26 @@ +"""DelegatedCallable provider tests.""" + +from dependency_injector import providers + +from .common import example + + +def test_inheritance(): + assert isinstance(providers.DelegatedCallable(example), providers.Callable) + + +def test_is_provider(): + assert providers.is_provider(providers.DelegatedCallable(example)) is True + + +def test_is_delegated_provider(): + provider = providers.DelegatedCallable(example) + assert providers.is_delegated(provider) is True + + +def test_repr(): + provider = providers.DelegatedCallable(example) + assert repr(provider) == ( + "".format(repr(example), hex(id(provider))) + ) diff --git a/tests/unit/providers/test_callables_py2_py3.py b/tests/unit/providers/test_callables_py2_py3.py deleted file mode 100644 index dd546826..00000000 --- a/tests/unit/providers/test_callables_py2_py3.py +++ /dev/null @@ -1,280 +0,0 @@ -"""Dependency injector callable providers unit tests.""" - -import sys - -import unittest - -from dependency_injector import ( - providers, - errors, -) -from pytest import raises - - -def _example(arg1, arg2, arg3, arg4): - return arg1, arg2, arg3, arg4 - - -class CallableTests(unittest.TestCase): - - def test_is_provider(self): - assert providers.is_provider(providers.Callable(_example)) is True - - def test_init_with_not_callable(self): - with raises(errors.Error): - providers.Callable(123) - - def test_init_optional_provides(self): - provider = providers.Callable() - provider.set_provides(object) - assert provider.provides is object - assert isinstance(provider(), object) - - def test_set_provides_returns_self(self): - provider = providers.Callable() - assert provider.set_provides(object) is provider - - def test_provided_instance_provider(self): - provider = providers.Callable(_example) - assert isinstance(provider.provided, providers.ProvidedInstance) - - def test_call(self): - provider = providers.Callable(lambda: True) - assert provider() is True - - def test_call_with_positional_args(self): - provider = providers.Callable(_example, 1, 2, 3, 4) - assert provider() == (1, 2, 3, 4) - - def test_call_with_keyword_args(self): - provider = providers.Callable(_example, arg1=1, arg2=2, arg3=3, arg4=4) - assert provider() == (1, 2, 3, 4) - - def test_call_with_positional_and_keyword_args(self): - provider = providers.Callable(_example, 1, 2, arg3=3, arg4=4) - assert provider() == (1, 2, 3, 4) - - def test_call_with_context_args(self): - provider = providers.Callable(_example, 1, 2) - assert provider(3, 4) == (1, 2, 3, 4) - - def test_call_with_context_kwargs(self): - provider = providers.Callable(_example, arg1=1) - assert provider(arg2=2, arg3=3, arg4=4) == (1, 2, 3, 4) - - def test_call_with_context_args_and_kwargs(self): - provider = providers.Callable(_example, 1) - assert provider(2, arg3=3, arg4=4) == (1, 2, 3, 4) - - def test_fluent_interface(self): - provider = providers.Singleton(_example) \ - .add_args(1, 2) \ - .add_kwargs(arg3=3, arg4=4) - assert provider() == (1, 2, 3, 4) - - def test_set_args(self): - provider = providers.Callable(_example) \ - .add_args(1, 2) \ - .set_args(3, 4) - assert provider.args == (3, 4) - - def test_set_kwargs(self): - provider = providers.Callable(_example) \ - .add_kwargs(init_arg3=3, init_arg4=4) \ - .set_kwargs(init_arg3=4, init_arg4=5) - assert provider.kwargs == dict(init_arg3=4, init_arg4=5) - - def test_clear_args(self): - provider = providers.Callable(_example) \ - .add_args(1, 2) \ - .clear_args() - assert provider.args == tuple() - - def test_clear_kwargs(self): - provider = providers.Callable(_example) \ - .add_kwargs(init_arg3=3, init_arg4=4) \ - .clear_kwargs() - assert provider.kwargs == dict() - - def test_call_overridden(self): - provider = providers.Callable(_example) - - provider.override(providers.Object((4, 3, 2, 1))) - provider.override(providers.Object((1, 2, 3, 4))) - - assert provider() == (1, 2, 3, 4) - - def test_deepcopy(self): - provider = providers.Callable(_example) - - provider_copy = providers.deepcopy(provider) - - assert provider is not provider_copy - assert provider.provides is provider_copy.provides - assert isinstance(provider, providers.Callable) - - def test_deepcopy_from_memo(self): - provider = providers.Callable(_example) - provider_copy_memo = providers.Callable(_example) - - provider_copy = providers.deepcopy(provider, memo={id(provider): provider_copy_memo}) - - assert provider_copy is provider_copy_memo - - def test_deepcopy_args(self): - provider = providers.Callable(_example) - dependent_provider1 = providers.Callable(list) - dependent_provider2 = providers.Callable(dict) - - provider.add_args(dependent_provider1, dependent_provider2) - - provider_copy = providers.deepcopy(provider) - dependent_provider_copy1 = provider_copy.args[0] - dependent_provider_copy2 = provider_copy.args[1] - - assert provider.args != provider_copy.args - - assert dependent_provider1.provides is dependent_provider_copy1.provides - assert dependent_provider1 is not dependent_provider_copy1 - - assert dependent_provider2.provides is dependent_provider_copy2.provides - assert dependent_provider2 is not dependent_provider_copy2 - - def test_deepcopy_kwargs(self): - provider = providers.Callable(_example) - dependent_provider1 = providers.Callable(list) - dependent_provider2 = providers.Callable(dict) - - provider.add_kwargs(a1=dependent_provider1, a2=dependent_provider2) - - provider_copy = providers.deepcopy(provider) - dependent_provider_copy1 = provider_copy.kwargs["a1"] - dependent_provider_copy2 = provider_copy.kwargs["a2"] - - assert provider.kwargs != provider_copy.kwargs - - assert dependent_provider1.provides is dependent_provider_copy1.provides - assert dependent_provider1 is not dependent_provider_copy1 - - assert dependent_provider2.provides is dependent_provider_copy2.provides - assert dependent_provider2 is not dependent_provider_copy2 - - def test_deepcopy_overridden(self): - provider = providers.Callable(_example) - object_provider = providers.Object(object()) - - provider.override(object_provider) - - provider_copy = providers.deepcopy(provider) - object_provider_copy = provider_copy.overridden[0] - - assert provider is not provider_copy - assert provider.provides is provider_copy.provides - assert isinstance(provider, providers.Callable) - - assert object_provider is not object_provider_copy - assert isinstance(object_provider_copy, providers.Object) - - def test_deepcopy_with_sys_streams(self): - provider = providers.Callable(_example) - provider.add_args(sys.stdin) - provider.add_kwargs(a2=sys.stdout) - - provider_copy = providers.deepcopy(provider) - - assert provider is not provider_copy - assert isinstance(provider_copy, providers.Callable) - assert provider.args[0] is sys.stdin - assert provider.kwargs["a2"] is sys.stdout - - def test_repr(self): - provider = providers.Callable(_example) - assert repr(provider) == ( - "".format(repr(_example), hex(id(provider))) - ) - - -class DelegatedCallableTests(unittest.TestCase): - - def test_inheritance(self): - assert isinstance(providers.DelegatedCallable(_example), - providers.Callable) - - def test_is_provider(self): - assert providers.is_provider(providers.DelegatedCallable(_example)) is True - - def test_is_delegated_provider(self): - provider = providers.DelegatedCallable(_example) - assert providers.is_delegated(provider) is True - - def test_repr(self): - provider = providers.DelegatedCallable(_example) - assert repr(provider) == ( - "".format(repr(_example), hex(id(provider))) - ) - - -class AbstractCallableTests(unittest.TestCase): - - def test_inheritance(self): - assert isinstance(providers.AbstractCallable(_example), providers.Callable) - - def test_call_overridden_by_callable(self): - def _abstract_example(): - pass - - provider = providers.AbstractCallable(_abstract_example) - provider.override(providers.Callable(_example)) - - assert provider(1, 2, 3, 4) == (1, 2, 3, 4) - - def test_call_overridden_by_delegated_callable(self): - def _abstract_example(): - pass - - provider = providers.AbstractCallable(_abstract_example) - provider.override(providers.DelegatedCallable(_example)) - - assert provider(1, 2, 3, 4) == (1, 2, 3, 4) - - def test_call_not_overridden(self): - provider = providers.AbstractCallable(_example) - - with raises(errors.Error): - provider(1, 2, 3, 4) - - def test_override_by_not_callable(self): - provider = providers.AbstractCallable(_example) - - with raises(errors.Error): - provider.override(providers.Factory(object)) - - def test_provide_not_implemented(self): - provider = providers.AbstractCallable(_example) - - with raises(NotImplementedError): - provider._provide((1, 2, 3, 4), dict()) - - def test_repr(self): - provider = providers.AbstractCallable(_example) - - assert repr(provider) == ( - "".format(repr(_example), hex(id(provider))) - ) - - -class CallableDelegateTests(unittest.TestCase): - - def setUp(self): - self.delegated = providers.Callable(_example) - self.delegate = providers.CallableDelegate(self.delegated) - - def test_is_delegate(self): - assert isinstance(self.delegate, providers.Delegate) - - def test_init_with_not_callable(self): - with raises(errors.Error): - providers.CallableDelegate(providers.Object(object()))