From 708092b21ac65e9179fd03c49cd7326bbcb9d939 Mon Sep 17 00:00:00 2001 From: Roman Mogylatov Date: Sat, 16 Oct 2021 12:15:22 -0400 Subject: [PATCH] Migrate provider tests --- tests/unit/providers/test_base_py2_py3.py | 143 ---------------- tests/unit/providers/test_provider_py2_py3.py | 157 ++++++++++++++++++ 2 files changed, 157 insertions(+), 143 deletions(-) create mode 100644 tests/unit/providers/test_provider_py2_py3.py diff --git a/tests/unit/providers/test_base_py2_py3.py b/tests/unit/providers/test_base_py2_py3.py index 8611dfed..18d1c72b 100644 --- a/tests/unit/providers/test_base_py2_py3.py +++ b/tests/unit/providers/test_base_py2_py3.py @@ -11,149 +11,6 @@ from dependency_injector import ( from pytest import raises -class ProviderTests(unittest.TestCase): - - def setUp(self): - self.provider = providers.Provider() - - def test_is_provider(self): - assert providers.is_provider(self.provider) is True - - def test_call(self): - with raises(NotImplementedError): - self.provider() - - def test_delegate(self): - with warnings.catch_warnings(): - warnings.simplefilter("ignore") - delegate1 = self.provider.delegate() - delegate2 = self.provider.delegate() - - assert isinstance(delegate1, providers.Delegate) - assert delegate1() is self.provider - - assert isinstance(delegate2, providers.Delegate) - assert delegate2() is self.provider - - assert delegate1 is not delegate2 - - def test_provider(self): - delegate1 = self.provider.provider - - assert isinstance(delegate1, providers.Delegate) - assert delegate1() is self.provider - - delegate2 = self.provider.provider - - assert isinstance(delegate2, providers.Delegate) - assert delegate2() is self.provider - - assert delegate1 is not delegate2 - - def test_override(self): - overriding_provider = providers.Provider() - self.provider.override(overriding_provider) - assert self.provider.overridden == (overriding_provider,) - assert self.provider.last_overriding is overriding_provider - - def test_double_override(self): - overriding_provider1 = providers.Object(1) - overriding_provider2 = providers.Object(2) - - self.provider.override(overriding_provider1) - overriding_provider1.override(overriding_provider2) - - assert self.provider() == overriding_provider2() - - def test_overriding_context(self): - overriding_provider = providers.Provider() - with self.provider.override(overriding_provider): - assert self.provider.overridden == (overriding_provider,) - assert self.provider.overridden == tuple() - assert not self.provider.overridden - - def test_override_with_itself(self): - with raises(errors.Error): - self.provider.override(self.provider) - - def test_override_with_not_provider(self): - obj = object() - self.provider.override(obj) - assert self.provider() is obj - - def test_reset_last_overriding(self): - overriding_provider1 = providers.Provider() - overriding_provider2 = providers.Provider() - - self.provider.override(overriding_provider1) - self.provider.override(overriding_provider2) - - assert self.provider.overridden[-1] is overriding_provider2 - assert self.provider.last_overriding is overriding_provider2 - - self.provider.reset_last_overriding() - assert self.provider.overridden[-1] is overriding_provider1 - assert self.provider.last_overriding is overriding_provider1 - - self.provider.reset_last_overriding() - assert self.provider.overridden == tuple() - assert not self.provider.overridden - assert self.provider.last_overriding is None - - def test_reset_last_overriding_of_not_overridden_provider(self): - with raises(errors.Error): - self.provider.reset_last_overriding() - - def test_reset_override(self): - overriding_provider = providers.Provider() - self.provider.override(overriding_provider) - - assert self.provider.overridden - assert self.provider.overridden == (overriding_provider,) - - self.provider.reset_override() - - assert self.provider.overridden == tuple() - - def test_deepcopy(self): - provider = providers.Provider() - - provider_copy = providers.deepcopy(provider) - - assert provider is not provider_copy - assert isinstance(provider, providers.Provider) - - def test_deepcopy_from_memo(self): - provider = providers.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(self): - provider = providers.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.Provider) - - assert overriding_provider is not overriding_provider_copy - assert isinstance(overriding_provider_copy, providers.Provider) - - def test_repr(self): - assert repr(self.provider) == ( - "".format(hex(id(self.provider))) - ) - - class DependencyTests(unittest.TestCase): def setUp(self): diff --git a/tests/unit/providers/test_provider_py2_py3.py b/tests/unit/providers/test_provider_py2_py3.py new file mode 100644 index 00000000..50f4dc3e --- /dev/null +++ b/tests/unit/providers/test_provider_py2_py3.py @@ -0,0 +1,157 @@ +"""Provider tests.""" + +import warnings + +from dependency_injector import providers, errors +from pytest import fixture, raises + + +@fixture +def provider(): + return providers.Provider() + + +def test_is_provider(provider): + assert providers.is_provider(provider) is True + + +def test_call(provider): + with raises(NotImplementedError): + provider() + + +def test_delegate(provider): + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + delegate1 = provider.delegate() + delegate2 = provider.delegate() + + assert isinstance(delegate1, providers.Delegate) + assert delegate1() is provider + + assert isinstance(delegate2, providers.Delegate) + assert delegate2() is provider + + assert delegate1 is not delegate2 + + +def test_provider(provider): + delegate1 = provider.provider + + assert isinstance(delegate1, providers.Delegate) + assert delegate1() is provider + + delegate2 = provider.provider + + assert isinstance(delegate2, providers.Delegate) + assert delegate2() is provider + + assert delegate1 is not delegate2 + + +def test_override(provider): + overriding_provider = providers.Provider() + provider.override(overriding_provider) + assert provider.overridden == (overriding_provider,) + assert provider.last_overriding is overriding_provider + + +def test_double_override(provider): + overriding_provider1 = providers.Object(1) + overriding_provider2 = providers.Object(2) + + provider.override(overriding_provider1) + overriding_provider1.override(overriding_provider2) + + assert provider() == overriding_provider2() + + +def test_overriding_context(provider): + overriding_provider = providers.Provider() + with provider.override(overriding_provider): + assert provider.overridden == (overriding_provider,) + assert provider.overridden == tuple() + assert not provider.overridden + + +def test_override_with_itself(provider): + with raises(errors.Error): + provider.override(provider) + + +def test_override_with_not_provider(provider): + obj = object() + provider.override(obj) + assert provider() is obj + + +def test_reset_last_overriding(provider): + overriding_provider1 = providers.Provider() + overriding_provider2 = providers.Provider() + + provider.override(overriding_provider1) + provider.override(overriding_provider2) + + assert provider.overridden[-1] is overriding_provider2 + assert provider.last_overriding is overriding_provider2 + + provider.reset_last_overriding() + assert provider.overridden[-1] is overriding_provider1 + assert provider.last_overriding is overriding_provider1 + + provider.reset_last_overriding() + assert provider.overridden == tuple() + assert not provider.overridden + assert provider.last_overriding is None + + +def test_reset_last_overriding_of_not_overridden_provider(provider): + with raises(errors.Error): + provider.reset_last_overriding() + + +def test_reset_override(provider): + overriding_provider = providers.Provider() + provider.override(overriding_provider) + + assert provider.overridden + assert provider.overridden == (overriding_provider,) + + provider.reset_override() + + assert provider.overridden == tuple() + + +def test_deepcopy(provider): + provider_copy = providers.deepcopy(provider) + + assert provider is not provider_copy + assert isinstance(provider, providers.Provider) + + +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.Provider) + + assert overriding_provider is not overriding_provider_copy + assert isinstance(overriding_provider_copy, providers.Provider) + + +def test_repr(provider): + assert repr(provider) == ( + "".format(hex(id(provider))) + )