From 3c0c3b3abc645ae460e5614b103815d9c86deff9 Mon Sep 17 00:00:00 2001 From: Roman Mogilatov Date: Mon, 23 Nov 2015 21:45:58 +0200 Subject: [PATCH] Refactor tests imports --- tests/test_catalogs.py | 181 +++++++++++++------------ tests/test_common.py | 13 ++ tests/test_injections.py | 90 ++++++------ tests/test_providers.py | 286 ++++++++++++++++++++------------------- tests/test_utils.py | 161 +++++++++++++--------- 5 files changed, 392 insertions(+), 339 deletions(-) create mode 100644 tests/test_common.py diff --git a/tests/test_catalogs.py b/tests/test_catalogs.py index 9f719cfd..648d18ed 100644 --- a/tests/test_catalogs.py +++ b/tests/test_catalogs.py @@ -1,21 +1,24 @@ """Dependency injector catalogs unittests.""" import unittest2 as unittest -import dependency_injector as di + +from dependency_injector import catalogs +from dependency_injector import providers +from dependency_injector import errors -class CatalogA(di.DeclarativeCatalog): +class CatalogA(catalogs.DeclarativeCatalog): """Test catalog A.""" - p11 = di.Provider() - p12 = di.Provider() + p11 = providers.Provider() + p12 = providers.Provider() class CatalogB(CatalogA): """Test catalog B.""" - p21 = di.Provider() - p22 = di.Provider() + p21 = providers.Provider() + p22 = providers.Provider() class CatalogBundleTests(unittest.TestCase): @@ -33,8 +36,8 @@ class CatalogBundleTests(unittest.TestCase): def test_get_attr_not_from_bundle(self): """Test get providers (attribute) that are not in bundle.""" - self.assertRaises(di.Error, getattr, self.bundle, 'p21') - self.assertRaises(di.Error, getattr, self.bundle, 'p22') + self.assertRaises(errors.Error, getattr, self.bundle, 'p21') + self.assertRaises(errors.Error, getattr, self.bundle, 'p22') def test_get_method_from_bundle(self): """Test get providers (get() method) from bundle.""" @@ -43,8 +46,8 @@ class CatalogBundleTests(unittest.TestCase): def test_get_method_not_from_bundle(self): """Test get providers (get() method) that are not in bundle.""" - self.assertRaises(di.Error, self.bundle.get_provider, 'p21') - self.assertRaises(di.Error, self.bundle.get_provider, 'p22') + self.assertRaises(errors.Error, self.bundle.get_provider, 'p21') + self.assertRaises(errors.Error, self.bundle.get_provider, 'p22') def test_has(self): """Test checks of providers availability in bundle.""" @@ -64,26 +67,26 @@ class CatalogBundleTests(unittest.TestCase): def test_create_bundle_with_unbound_provider(self): """Test that bundle is not created with unbound provider.""" - self.assertRaises(di.Error, CatalogB.Bundle, di.Provider()) + self.assertRaises(errors.Error, CatalogB.Bundle, providers.Provider()) def test_create_bundle_with_another_catalog_provider(self): """Test that bundle can not contain another catalog's provider.""" - class TestCatalog(di.DeclarativeCatalog): + class TestCatalog(catalogs.DeclarativeCatalog): """Test catalog.""" - provider = di.Provider() + provider = providers.Provider() - self.assertRaises(di.Error, + self.assertRaises(errors.Error, CatalogB.Bundle, CatalogB.p21, TestCatalog.provider) def test_create_bundle_with_another_catalog_provider_with_same_name(self): """Test that bundle can not contain another catalog's provider.""" - class TestCatalog(di.DeclarativeCatalog): + class TestCatalog(catalogs.DeclarativeCatalog): """Test catalog.""" - p21 = di.Provider() + p21 = providers.Provider() - self.assertRaises(di.Error, + self.assertRaises(errors.Error, CatalogB.Bundle, CatalogB.p21, TestCatalog.p21) def test_is_bundle_owner(self): @@ -93,7 +96,7 @@ class CatalogBundleTests(unittest.TestCase): def test_is_bundle_owner_with_not_bundle_instance(self): """Test that check of bundle ownership raises error with not bundle.""" - self.assertRaises(di.Error, CatalogB.is_bundle_owner, object()) + self.assertRaises(errors.Error, CatalogB.is_bundle_owner, object()) class DynamicCatalogTests(unittest.TestCase): @@ -104,8 +107,8 @@ class DynamicCatalogTests(unittest.TestCase): def setUp(self): """Set test environment up.""" - self.catalog = di.DynamicCatalog(p1=di.Provider(), - p2=di.Provider()) + self.catalog = catalogs.DynamicCatalog(p1=providers.Provider(), + p2=providers.Provider()) self.catalog.name = 'TestCatalog' def test_providers(self): @@ -116,8 +119,8 @@ class DynamicCatalogTests(unittest.TestCase): def test_bind_provider(self): """Test setting of provider via bind_provider() to catalog.""" - px = di.Provider() - py = di.Provider() + px = providers.Provider() + py = providers.Provider() self.catalog.bind_provider('px', px) self.catalog.bind_provider('py', py) @@ -130,8 +133,8 @@ class DynamicCatalogTests(unittest.TestCase): def test_bind_providers(self): """Test setting of provider via bind_providers() to catalog.""" - px = di.Provider() - py = di.Provider() + px = providers.Provider() + py = providers.Provider() self.catalog.bind_providers(dict(px=px, py=py)) @@ -143,8 +146,8 @@ class DynamicCatalogTests(unittest.TestCase): def test_setattr(self): """Test setting of providers via attributes to catalog.""" - px = di.Provider() - py = di.Provider() + px = providers.Provider() + py = providers.Provider() self.catalog.px = px self.catalog.py = py @@ -157,13 +160,13 @@ class DynamicCatalogTests(unittest.TestCase): def test_unbind_provider(self): """Test that catalog unbinds provider correct.""" - self.catalog.px = di.Provider() + self.catalog.px = providers.Provider() self.catalog.unbind_provider('px') self.assertFalse(self.catalog.has_provider('px')) def test_unbind_via_delattr(self): """Test that catalog unbinds provider correct.""" - self.catalog.px = di.Provider() + self.catalog.px = providers.Provider() del self.catalog.px self.assertFalse(self.catalog.has_provider('px')) @@ -181,8 +184,8 @@ class DynamicCatalogTests(unittest.TestCase): p1 = self.catalog.p1 p2 = self.catalog.p2 - catalog_a = di.DynamicCatalog(pa1=p1, pa2=p2) - catalog_b = di.DynamicCatalog(pb1=p1, pb2=p2) + catalog_a = catalogs.DynamicCatalog(pa1=p1, pa2=p2) + catalog_b = catalogs.DynamicCatalog(pb1=p1, pb2=p2) self.assertTrue(self.catalog.is_provider_bound(p1)) self.assertTrue(catalog_a.is_provider_bound(p1)) @@ -200,13 +203,13 @@ class DynamicCatalogTests(unittest.TestCase): def test_provider_rebinding_to_the_same_catalog(self): """Test provider rebinding to the same catalog.""" - with self.assertRaises(di.Error): + with self.assertRaises(errors.Error): self.catalog.p3 = self.catalog.p1 def test_provider_binding_with_the_same_name(self): """Test binding of provider with the same name.""" - with self.assertRaises(di.Error): - self.catalog.bind_provider('p1', di.Provider()) + with self.assertRaises(errors.Error): + self.catalog.bind_provider('p1', providers.Provider()) def test_get(self): """Test getting of providers using get() method.""" @@ -215,10 +218,10 @@ class DynamicCatalogTests(unittest.TestCase): def test_get_undefined(self): """Test getting of undefined providers using get() method.""" - with self.assertRaises(di.UndefinedProviderError): + with self.assertRaises(errors.UndefinedProviderError): self.catalog.get_provider('undefined') - with self.assertRaises(di.UndefinedProviderError): + with self.assertRaises(errors.UndefinedProviderError): self.catalog.undefined def test_has_provider(self): @@ -229,8 +232,8 @@ class DynamicCatalogTests(unittest.TestCase): def test_filter_all_providers_by_type(self): """Test getting of all catalog providers of specific type.""" - self.assertTrue(len(self.catalog.filter(di.Provider)) == 2) - self.assertTrue(len(self.catalog.filter(di.Value)) == 0) + self.assertTrue(len(self.catalog.filter(providers.Provider)) == 2) + self.assertTrue(len(self.catalog.filter(providers.Value)) == 0) def test_repr(self): """Test catalog representation.""" @@ -271,8 +274,8 @@ class DeclarativeCatalogTests(unittest.TestCase): def test_bind_provider(self): """Test setting of provider via bind_provider() to catalog.""" - px = di.Provider() - py = di.Provider() + px = providers.Provider() + py = providers.Provider() CatalogA.bind_provider('px', px) CatalogA.bind_provider('py', py) @@ -290,8 +293,8 @@ class DeclarativeCatalogTests(unittest.TestCase): def test_bind_providers(self): """Test setting of provider via bind_providers() to catalog.""" - px = di.Provider() - py = di.Provider() + px = providers.Provider() + py = providers.Provider() CatalogB.bind_providers(dict(px=px, py=py)) @@ -308,8 +311,8 @@ class DeclarativeCatalogTests(unittest.TestCase): def test_setattr(self): """Test setting of providers via attributes to catalog.""" - px = di.Provider() - py = di.Provider() + px = providers.Provider() + py = providers.Provider() CatalogB.px = px CatalogB.py = py @@ -327,13 +330,13 @@ class DeclarativeCatalogTests(unittest.TestCase): def test_unbind_provider(self): """Test that catalog unbinds provider correct.""" - CatalogB.px = di.Provider() + CatalogB.px = providers.Provider() CatalogB.unbind_provider('px') self.assertFalse(CatalogB.has_provider('px')) def test_unbind_via_delattr(self): """Test that catalog unbinds provider correct.""" - CatalogB.px = di.Provider() + CatalogB.px = providers.Provider() del CatalogB.px self.assertFalse(CatalogB.has_provider('px')) @@ -350,13 +353,13 @@ class DeclarativeCatalogTests(unittest.TestCase): p11 = CatalogA.p11 p12 = CatalogA.p12 - class CatalogD(di.DeclarativeCatalog): + class CatalogD(catalogs.DeclarativeCatalog): """Test catalog.""" pd1 = p11 pd2 = p12 - class CatalogE(di.DeclarativeCatalog): + class CatalogE(catalogs.DeclarativeCatalog): """Test catalog.""" pe1 = p11 @@ -378,21 +381,21 @@ class DeclarativeCatalogTests(unittest.TestCase): def test_provider_rebinding_to_the_same_catalog(self): """Test provider rebinding to the same catalog.""" - with self.assertRaises(di.Error): - class TestCatalog(di.DeclarativeCatalog): + with self.assertRaises(errors.Error): + class TestCatalog(catalogs.DeclarativeCatalog): """Test catalog.""" - p1 = di.Provider() + p1 = providers.Provider() p2 = p1 def test_provider_rebinding_to_the_same_catalogs_hierarchy(self): """Test provider rebinding to the same catalogs hierarchy.""" - class TestCatalog1(di.DeclarativeCatalog): + class TestCatalog1(catalogs.DeclarativeCatalog): """Test catalog.""" - p1 = di.Provider() + p1 = providers.Provider() - with self.assertRaises(di.Error): + with self.assertRaises(errors.Error): class TestCatalog2(TestCatalog1): """Test catalog.""" @@ -412,13 +415,13 @@ class DeclarativeCatalogTests(unittest.TestCase): def test_get_undefined(self): """Test getting of undefined providers using get() method.""" - with self.assertRaises(di.UndefinedProviderError): + with self.assertRaises(errors.UndefinedProviderError): CatalogB.get('undefined') - with self.assertRaises(di.UndefinedProviderError): + with self.assertRaises(errors.UndefinedProviderError): CatalogB.get_provider('undefined') - with self.assertRaises(di.UndefinedProviderError): + with self.assertRaises(errors.UndefinedProviderError): CatalogB.undefined def test_has(self): @@ -437,8 +440,8 @@ class DeclarativeCatalogTests(unittest.TestCase): def test_filter_all_providers_by_type(self): """Test getting of all catalog providers of specific type.""" - self.assertTrue(len(CatalogB.filter(di.Provider)) == 4) - self.assertTrue(len(CatalogB.filter(di.Value)) == 0) + self.assertTrue(len(CatalogB.filter(providers.Provider)) == 4) + self.assertTrue(len(CatalogB.filter(providers.Value)) == 0) def test_repr(self): """Test catalog representation.""" @@ -454,7 +457,7 @@ class DeclarativeCatalogTests(unittest.TestCase): def test_abstract_catalog_backward_compatibility(self): """Test that di.AbstractCatalog is available.""" - self.assertIs(di.DeclarativeCatalog, di.AbstractCatalog) + self.assertIs(catalogs.DeclarativeCatalog, catalogs.AbstractCatalog) class OverrideTests(unittest.TestCase): @@ -466,12 +469,12 @@ class OverrideTests(unittest.TestCase): def test_overriding(self): """Test catalog overriding with another catalog.""" - @di.override(CatalogA) - class OverridingCatalog(di.DeclarativeCatalog): + @catalogs.override(CatalogA) + class OverridingCatalog(catalogs.DeclarativeCatalog): """Overriding catalog.""" - p11 = di.Value(1) - p12 = di.Value(2) + p11 = providers.Value(1) + p12 = providers.Value(2) self.assertEqual(CatalogA.p11(), 1) self.assertEqual(CatalogA.p12(), 2) @@ -479,8 +482,8 @@ class OverrideTests(unittest.TestCase): def test_overriding_with_dynamic_catalog(self): """Test catalog overriding with another dynamic catalog.""" - CatalogA.override(di.DynamicCatalog(p11=di.Value(1), - p12=di.Value(2))) + CatalogA.override(catalogs.DynamicCatalog(p11=providers.Value(1), + p12=providers.Value(2))) self.assertEqual(CatalogA.p11(), 1) self.assertEqual(CatalogA.p12(), 2) self.assertEqual(len(CatalogA.overridden_by), 1) @@ -489,44 +492,44 @@ class OverrideTests(unittest.TestCase): """Test catalog is_overridden property.""" self.assertFalse(CatalogA.is_overridden) - @di.override(CatalogA) - class OverridingCatalog(di.DeclarativeCatalog): + @catalogs.override(CatalogA) + class OverridingCatalog(catalogs.DeclarativeCatalog): """Overriding catalog.""" self.assertTrue(CatalogA.is_overridden) def test_last_overriding(self): """Test catalog last_overriding property.""" - @di.override(CatalogA) - class OverridingCatalog1(di.DeclarativeCatalog): + @catalogs.override(CatalogA) + class OverridingCatalog1(catalogs.DeclarativeCatalog): """Overriding catalog.""" - @di.override(CatalogA) - class OverridingCatalog2(di.DeclarativeCatalog): + @catalogs.override(CatalogA) + class OverridingCatalog2(catalogs.DeclarativeCatalog): """Overriding catalog.""" self.assertIs(CatalogA.last_overriding, OverridingCatalog2) def test_last_overriding_on_not_overridden(self): """Test catalog last_overriding property on not overridden catalog.""" - with self.assertRaises(di.Error): + with self.assertRaises(errors.Error): CatalogA.last_overriding def test_reset_last_overriding(self): """Test resetting last overriding catalog.""" - @di.override(CatalogA) - class OverridingCatalog1(di.DeclarativeCatalog): + @catalogs.override(CatalogA) + class OverridingCatalog1(catalogs.DeclarativeCatalog): """Overriding catalog.""" - p11 = di.Value(1) - p12 = di.Value(2) + p11 = providers.Value(1) + p12 = providers.Value(2) - @di.override(CatalogA) - class OverridingCatalog2(di.DeclarativeCatalog): + @catalogs.override(CatalogA) + class OverridingCatalog2(catalogs.DeclarativeCatalog): """Overriding catalog.""" - p11 = di.Value(3) - p12 = di.Value(4) + p11 = providers.Value(3) + p12 = providers.Value(4) CatalogA.reset_last_overriding() @@ -535,24 +538,24 @@ class OverrideTests(unittest.TestCase): def test_reset_last_overriding_when_not_overridden(self): """Test resetting last overriding catalog when it is not overridden.""" - with self.assertRaises(di.Error): + with self.assertRaises(errors.Error): CatalogA.reset_last_overriding() def test_reset_override(self): """Test resetting all catalog overrides.""" - @di.override(CatalogA) - class OverridingCatalog1(di.DeclarativeCatalog): + @catalogs.override(CatalogA) + class OverridingCatalog1(catalogs.DeclarativeCatalog): """Overriding catalog.""" - p11 = di.Value(1) - p12 = di.Value(2) + p11 = providers.Value(1) + p12 = providers.Value(2) - @di.override(CatalogA) - class OverridingCatalog2(di.DeclarativeCatalog): + @catalogs.override(CatalogA) + class OverridingCatalog2(catalogs.DeclarativeCatalog): """Overriding catalog.""" - p11 = di.Value(3) - p12 = di.Value(4) + p11 = providers.Value(3) + p12 = providers.Value(4) CatalogA.reset_override() diff --git a/tests/test_common.py b/tests/test_common.py new file mode 100644 index 00000000..38365aa9 --- /dev/null +++ b/tests/test_common.py @@ -0,0 +1,13 @@ +"""Common unittests.""" + +import unittest2 as unittest + +from dependency_injector import VERSION + + +class VersionTest(unittest.TestCase): + """Version constant tests.""" + + def test_version_follows_semantic_versioning(self): + """Test that version follows semantic versioning.""" + self.assertEquals(len(VERSION.split('.')), 3) diff --git a/tests/test_injections.py b/tests/test_injections.py index cf5dee81..ea8b4418 100644 --- a/tests/test_injections.py +++ b/tests/test_injections.py @@ -1,7 +1,11 @@ """Dependency injector injections unittests.""" import unittest2 as unittest -import dependency_injector as di + +from dependency_injector import injections +from dependency_injector import catalogs +from dependency_injector import providers +from dependency_injector import errors class InjectionTests(unittest.TestCase): @@ -9,26 +13,27 @@ class InjectionTests(unittest.TestCase): def test_init(self): """Test Injection creation and initialization.""" - injection = di.Injection('some_value') + injection = injections.Injection('some_value') self.assertEqual(injection.injectable, 'some_value') def test_value_with_scalar_injectable(self): """Test Injection value property with scalar value.""" - injection = di.Injection('some_value') + injection = injections.Injection('some_value') self.assertEqual(injection.value, 'some_value') def test_value_with_provider_injectable(self): """Test Injection value property with provider.""" - injection = di.Injection(di.Factory(object)) + injection = injections.Injection(providers.Factory(object)) self.assertIsInstance(injection.value, object) def test_value_with_catalog_bundle_injectable(self): """Test Injection value property with catalog bundle.""" - class TestCatalog(di.AbstractCatalog): + class TestCatalog(catalogs.DeclarativeCatalog): """Test catalog.""" - provider = di.Provider() - injection = di.Injection(TestCatalog.Bundle(TestCatalog.provider)) + provider = providers.Provider() + injection = injections.Injection( + TestCatalog.Bundle(TestCatalog.provider)) self.assertIsInstance(injection.value, TestCatalog.Bundle) @@ -38,7 +43,7 @@ class ArgTests(unittest.TestCase): def test_init(self): """Test Arg creation and initialization.""" - injection = di.Arg('some_value') + injection = injections.Arg('some_value') self.assertEqual(injection.injectable, 'some_value') @@ -47,7 +52,7 @@ class KwArgTests(unittest.TestCase): def test_init(self): """Test KwArg creation and initialization.""" - injection = di.KwArg('some_arg_name', 'some_value') + injection = injections.KwArg('some_arg_name', 'some_value') self.assertEqual(injection.name, 'some_arg_name') self.assertEqual(injection.injectable, 'some_value') @@ -57,7 +62,7 @@ class AttributeTests(unittest.TestCase): def test_init(self): """Test Attribute creation and initialization.""" - injection = di.Attribute('some_arg_name', 'some_value') + injection = injections.Attribute('some_arg_name', 'some_value') self.assertEqual(injection.name, 'some_arg_name') self.assertEqual(injection.injectable, 'some_value') @@ -67,7 +72,7 @@ class MethodTests(unittest.TestCase): def test_init(self): """Test Method creation and initialization.""" - injection = di.Method('some_arg_name', 'some_value') + injection = injections.Method('some_arg_name', 'some_value') self.assertEqual(injection.name, 'some_arg_name') self.assertEqual(injection.injectable, 'some_value') @@ -77,10 +82,10 @@ class InjectTests(unittest.TestCase): def test_decorated_args(self): """Test `inject()` decoration with args.""" - provider1 = di.Factory(object) - provider2 = di.Factory(list) + provider1 = providers.Factory(object) + provider2 = providers.Factory(list) - @di.inject(provider1, provider2) + @injections.inject(provider1, provider2) def test(a, b): return a, b @@ -97,10 +102,11 @@ class InjectTests(unittest.TestCase): def test_decorated_args_extended_syntax(self): """Test `inject()` decoration with args.""" - provider1 = di.Factory(object) - provider2 = di.Factory(list) + provider1 = providers.Factory(object) + provider2 = providers.Factory(list) - @di.inject(di.Arg(provider1), di.Arg(provider2)) + @injections.inject(injections.Arg(provider1), + injections.Arg(provider2)) def test(a, b): return a, b @@ -117,11 +123,11 @@ class InjectTests(unittest.TestCase): def test_decorated_args_several_times(self): """Test `inject()` decoration with args several times.""" - provider1 = di.Factory(object) - provider2 = di.Factory(list) + provider1 = providers.Factory(object) + provider2 = providers.Factory(list) - @di.inject(provider2) - @di.inject(provider1) + @injections.inject(provider2) + @injections.inject(provider1) def test(a, b): return a, b @@ -138,10 +144,10 @@ class InjectTests(unittest.TestCase): def test_decorated_context_args(self): """Test `inject()` decoration with context args.""" - provider1 = di.Factory(object) - provider2 = di.Factory(list) + provider1 = providers.Factory(object) + provider2 = providers.Factory(list) - @di.inject(provider1) + @injections.inject(provider1) def test(a, b): return a, b @@ -158,11 +164,11 @@ class InjectTests(unittest.TestCase): def test_decorated_kwargs(self): """Test `inject()` decoration with kwargs.""" - provider1 = di.Factory(object) - provider2 = di.Factory(list) + provider1 = providers.Factory(object) + provider2 = providers.Factory(list) - @di.inject(a=provider1) - @di.inject(b=provider2) + @injections.inject(a=provider1) + @injections.inject(b=provider2) def test(a, b): return a, b @@ -179,12 +185,12 @@ class InjectTests(unittest.TestCase): def test_decorated_kwargs_priority(self): """Test `inject()` decorated callback kwargs priority.""" - provider1 = di.Factory(object) - provider2 = di.Factory(list) + provider1 = providers.Factory(object) + provider2 = providers.Factory(list) object_a = object() - @di.inject(a=provider1) - @di.inject(b=provider2) + @injections.inject(a=provider1) + @injections.inject(b=provider2) def test(a, b): return a, b @@ -202,10 +208,10 @@ class InjectTests(unittest.TestCase): def test_decorated_with_args(self): """Test `inject()` decorated callback with args.""" - provider = di.Factory(list) + provider = providers.Factory(list) object_a = object() - @di.inject(b=provider) + @injections.inject(b=provider) def test(a, b): return a, b @@ -223,10 +229,10 @@ class InjectTests(unittest.TestCase): def test_injection_kwarg_syntax(self): """Test `inject()` decorated callback with "old" style using KwArg.""" - provider = di.Factory(list) + provider = providers.Factory(list) object_a = object() - @di.inject(di.KwArg('b', provider)) + @injections.inject(injections.KwArg('b', provider)) def test(a, b): return a, b @@ -247,8 +253,8 @@ class InjectTests(unittest.TestCase): class Test(object): """Test class.""" - @di.inject(arg1=123) - @di.inject(arg2=456) + @injections.inject(arg1=123) + @injections.inject(arg2=456) def some_method(self, arg1, arg2): """Some test method.""" return arg1, arg2 @@ -261,8 +267,8 @@ class InjectTests(unittest.TestCase): def test_decorate_class_with_init(self): """Test `inject()` decorator that decorate class with __init__.""" - @di.inject(arg1=123) - @di.inject(arg2=456) + @injections.inject(arg1=123) + @injections.inject(arg2=456) class Test(object): """Test class.""" @@ -278,7 +284,7 @@ class InjectTests(unittest.TestCase): def test_decorate_class_without_init(self): """Test `inject()` decorator that decorate class without __init__.""" - with self.assertRaises(di.Error): - @di.inject(arg1=123) + with self.assertRaises(errors.Error): + @injections.inject(arg1=123) class Test(object): """Test class.""" diff --git a/tests/test_providers.py b/tests/test_providers.py index 81afbe90..38990ed5 100644 --- a/tests/test_providers.py +++ b/tests/test_providers.py @@ -1,7 +1,11 @@ """Dependency injector providers unittests.""" import unittest2 as unittest -import dependency_injector as di + +from dependency_injector import providers +from dependency_injector import injections +from dependency_injector import errors +from dependency_injector import utils class Example(object): @@ -35,11 +39,11 @@ class ProviderTests(unittest.TestCase): def setUp(self): """Set test cases environment up.""" - self.provider = di.Provider() + self.provider = providers.Provider() def test_is_provider(self): """Test `is_provider` check.""" - self.assertTrue(di.is_provider(self.provider)) + self.assertTrue(utils.is_provider(self.provider)) def test_call(self): """Test call.""" @@ -49,34 +53,34 @@ class ProviderTests(unittest.TestCase): """Test creating of provider delegation.""" delegate1 = self.provider.delegate() - self.assertIsInstance(delegate1, di.Delegate) + self.assertIsInstance(delegate1, providers.Delegate) self.assertIs(delegate1(), self.provider) delegate2 = self.provider.delegate() - self.assertIsInstance(delegate2, di.Delegate) + self.assertIsInstance(delegate2, providers.Delegate) self.assertIs(delegate2(), self.provider) self.assertIsNot(delegate1, delegate2) def test_override(self): """Test provider overriding.""" - overriding_provider = di.Provider() + overriding_provider = providers.Provider() self.provider.override(overriding_provider) self.assertTrue(self.provider.is_overridden) def test_override_with_itself(self): """Test provider overriding with itself.""" - self.assertRaises(di.Error, self.provider.override, self.provider) + self.assertRaises(errors.Error, self.provider.override, self.provider) def test_override_with_not_provider(self): """Test provider overriding with not provider instance.""" - self.assertRaises(di.Error, self.provider.override, object()) + self.assertRaises(errors.Error, self.provider.override, object()) def test_last_overriding(self): """Test getting last overriding provider.""" - overriding_provider1 = di.Provider() - overriding_provider2 = di.Provider() + overriding_provider1 = providers.Provider() + overriding_provider2 = providers.Provider() self.provider.override(overriding_provider1) self.assertIs(self.provider.last_overriding, overriding_provider1) @@ -88,7 +92,7 @@ class ProviderTests(unittest.TestCase): """Test getting last overriding from not overridden provider.""" try: self.provider.last_overriding - except di.Error: + except errors.Error: pass else: self.fail('Got en error in {}'.format( @@ -96,8 +100,8 @@ class ProviderTests(unittest.TestCase): def test_reset_last_overriding(self): """Test reseting of last overriding provider.""" - overriding_provider1 = di.Provider() - overriding_provider2 = di.Provider() + overriding_provider1 = providers.Provider() + overriding_provider2 = providers.Provider() self.provider.override(overriding_provider1) self.provider.override(overriding_provider2) @@ -112,11 +116,11 @@ class ProviderTests(unittest.TestCase): def test_reset_last_overriding_of_not_overridden_provider(self): """Test resetting of last overriding on not overridden provier.""" - self.assertRaises(di.Error, self.provider.reset_last_overriding) + self.assertRaises(errors.Error, self.provider.reset_last_overriding) def test_reset_override(self): """Test reset of provider's override.""" - overriding_provider = di.Provider() + overriding_provider = providers.Provider() self.provider.override(overriding_provider) self.assertTrue(self.provider.is_overridden) @@ -127,7 +131,7 @@ class ProviderTests(unittest.TestCase): self.assertFalse(self.provider.is_overridden) try: self.provider.last_overriding - except di.Error: + except errors.Error: pass else: self.fail('Got en error in {}'.format( @@ -139,16 +143,16 @@ class DelegateTests(unittest.TestCase): def setUp(self): """Set test cases environment up.""" - self.delegated = di.Provider() - self.delegate = di.Delegate(delegated=self.delegated) + self.delegated = providers.Provider() + self.delegate = providers.Delegate(delegated=self.delegated) def test_is_provider(self): """Test `is_provider` check.""" - self.assertTrue(di.is_provider(self.delegate)) + self.assertTrue(utils.is_provider(self.delegate)) def test_init_with_not_provider(self): """Test that delegate accepts only another provider as delegated.""" - self.assertRaises(di.Error, di.Delegate, delegated=object()) + self.assertRaises(errors.Error, providers.Delegate, delegated=object()) def test_call(self): """Test returning of delegated provider.""" @@ -164,19 +168,19 @@ class FactoryTests(unittest.TestCase): def test_is_provider(self): """Test `is_provider` check.""" - self.assertTrue(di.is_provider(di.Factory(Example))) + self.assertTrue(utils.is_provider(providers.Factory(Example))) def test_init_with_callable(self): """Test creation of provider with a callable.""" - self.assertTrue(di.Factory(credits)) + self.assertTrue(providers.Factory(credits)) def test_init_with_not_callable(self): """Test creation of provider with not a callable.""" - self.assertRaises(di.Error, di.Factory, 123) + self.assertRaises(errors.Error, providers.Factory, 123) def test_call(self): """Test creation of new instances.""" - provider = di.Factory(Example) + provider = providers.Factory(Example) instance1 = provider() instance2 = provider() @@ -189,7 +193,7 @@ class FactoryTests(unittest.TestCase): New simplified syntax. """ - provider = di.Factory(Example, 'i1', 'i2') + provider = providers.Factory(Example, 'i1', 'i2') instance1 = provider() instance2 = provider() @@ -209,7 +213,7 @@ class FactoryTests(unittest.TestCase): New simplified syntax. """ - provider = di.Factory(Example, init_arg1='i1', init_arg2='i2') + provider = providers.Factory(Example, init_arg1='i1', init_arg2='i2') instance1 = provider() instance2 = provider() @@ -229,7 +233,7 @@ class FactoryTests(unittest.TestCase): Simplified syntax of positional and keyword arg injections. """ - provider = di.Factory(Example, 'i1', init_arg2='i2') + provider = providers.Factory(Example, 'i1', init_arg2='i2') instance1 = provider() instance2 = provider() @@ -249,9 +253,9 @@ class FactoryTests(unittest.TestCase): Extended syntax of positional and keyword arg injections. """ - provider = di.Factory(Example, - di.Arg('i1'), - di.KwArg('init_arg2', 'i2')) + provider = providers.Factory(Example, + injections.Arg('i1'), + injections.KwArg('init_arg2', 'i2')) instance1 = provider() instance2 = provider() @@ -268,9 +272,9 @@ class FactoryTests(unittest.TestCase): def test_call_with_attributes(self): """Test creation of new instances with attribute injections.""" - provider = di.Factory(Example, - di.Attribute('attribute1', 'a1'), - di.Attribute('attribute2', 'a2')) + provider = providers.Factory(Example, + injections.Attribute('attribute1', 'a1'), + injections.Attribute('attribute2', 'a2')) instance1 = provider() instance2 = provider() @@ -287,9 +291,9 @@ class FactoryTests(unittest.TestCase): def test_call_with_methods(self): """Test creation of new instances with method injections.""" - provider = di.Factory(Example, - di.Method('method1', 'm1'), - di.Method('method2', 'm2')) + provider = providers.Factory(Example, + injections.Method('method1', 'm1'), + injections.Method('method2', 'm2')) instance1 = provider() instance2 = provider() @@ -306,7 +310,7 @@ class FactoryTests(unittest.TestCase): def test_call_with_context_args(self): """Test creation of new instances with context args.""" - provider = di.Factory(Example, 11, 22) + provider = providers.Factory(Example, 11, 22) instance = provider(33, 44) self.assertEqual(instance.init_arg1, 11) @@ -316,8 +320,8 @@ class FactoryTests(unittest.TestCase): def test_call_with_context_kwargs(self): """Test creation of new instances with context kwargs.""" - provider = di.Factory(Example, - di.KwArg('init_arg1', 1)) + provider = providers.Factory(Example, + injections.KwArg('init_arg1', 1)) instance1 = provider(init_arg2=22) self.assertEqual(instance1.init_arg1, 1) @@ -329,7 +333,7 @@ class FactoryTests(unittest.TestCase): def test_call_with_context_args_and_kwargs(self): """Test creation of new instances with context args and kwargs.""" - provider = di.Factory(Example, 11) + provider = providers.Factory(Example, 11) instance = provider(22, init_arg3=33, init_arg4=44) self.assertEqual(instance.init_arg1, 11) @@ -339,9 +343,9 @@ class FactoryTests(unittest.TestCase): def test_call_overridden(self): """Test creation of new instances on overridden provider.""" - provider = di.Factory(Example) - overriding_provider1 = di.Factory(dict) - overriding_provider2 = di.Factory(list) + provider = providers.Factory(Example) + overriding_provider1 = providers.Factory(dict) + overriding_provider2 = providers.Factory(list) provider.override(overriding_provider1) provider.override(overriding_provider2) @@ -355,17 +359,14 @@ class FactoryTests(unittest.TestCase): def test_injections(self): """Test getting a full list of injections using injections property.""" - provider = di.Factory(Example, - di.Arg(1), - di.KwArg('init_arg2', 2), - di.Attribute('attribute1', 3), - di.Attribute('attribute2', 4), - di.Method('method1', 5), - di.Method('method2', 6)) - - injections = provider.injections - - self.assertEquals(len(injections), 6) + provider = providers.Factory(Example, + injections.Arg(1), + injections.KwArg('init_arg2', 2), + injections.Attribute('attribute1', 3), + injections.Attribute('attribute2', 4), + injections.Method('method1', 5), + injections.Method('method2', 6)) + self.assertEquals(len(provider.injections), 6) class SingletonTests(unittest.TestCase): @@ -373,19 +374,19 @@ class SingletonTests(unittest.TestCase): def test_is_provider(self): """Test `is_provider` check.""" - self.assertTrue(di.is_provider(di.Singleton(Example))) + self.assertTrue(utils.is_provider(providers.Singleton(Example))) def test_init_with_callable(self): """Test creation of provider with a callable.""" - self.assertTrue(di.Singleton(credits)) + self.assertTrue(providers.Singleton(credits)) def test_init_with_not_callable(self): """Test creation of provider with not a callable.""" - self.assertRaises(di.Error, di.Singleton, 123) + self.assertRaises(errors.Error, providers.Singleton, 123) def test_call(self): """Test getting of instances.""" - provider = di.Singleton(Example) + provider = providers.Singleton(Example) instance1 = provider() instance2 = provider() @@ -398,7 +399,7 @@ class SingletonTests(unittest.TestCase): New simplified syntax. """ - provider = di.Singleton(Example, 'i1', 'i2') + provider = providers.Singleton(Example, 'i1', 'i2') instance1 = provider() instance2 = provider() @@ -418,7 +419,7 @@ class SingletonTests(unittest.TestCase): New simplified syntax. """ - provider = di.Singleton(Example, init_arg1='i1', init_arg2='i2') + provider = providers.Singleton(Example, init_arg1='i1', init_arg2='i2') instance1 = provider() instance2 = provider() @@ -438,7 +439,7 @@ class SingletonTests(unittest.TestCase): Simplified syntax of positional and keyword arg injections. """ - provider = di.Singleton(Example, 'i1', init_arg2='i2') + provider = providers.Singleton(Example, 'i1', init_arg2='i2') instance1 = provider() instance2 = provider() @@ -458,9 +459,9 @@ class SingletonTests(unittest.TestCase): Extended syntax of positional and keyword arg injections. """ - provider = di.Singleton(Example, - di.Arg('i1'), - di.KwArg('init_arg2', 'i2')) + provider = providers.Singleton(Example, + injections.Arg('i1'), + injections.KwArg('init_arg2', 'i2')) instance1 = provider() instance2 = provider() @@ -477,9 +478,11 @@ class SingletonTests(unittest.TestCase): def test_call_with_attributes(self): """Test getting of instances with attribute injections.""" - provider = di.Singleton(Example, - di.Attribute('attribute1', 'a1'), - di.Attribute('attribute2', 'a2')) + provider = providers.Singleton(Example, + injections.Attribute('attribute1', + 'a1'), + injections.Attribute('attribute2', + 'a2')) instance1 = provider() instance2 = provider() @@ -496,9 +499,9 @@ class SingletonTests(unittest.TestCase): def test_call_with_methods(self): """Test getting of instances with method injections.""" - provider = di.Singleton(Example, - di.Method('method1', 'm1'), - di.Method('method2', 'm2')) + provider = providers.Singleton(Example, + injections.Method('method1', 'm1'), + injections.Method('method2', 'm2')) instance1 = provider() instance2 = provider() @@ -515,7 +518,7 @@ class SingletonTests(unittest.TestCase): def test_call_with_context_args(self): """Test getting of instances with context args.""" - provider = di.Singleton(Example) + provider = providers.Singleton(Example) instance = provider(11, 22) self.assertEqual(instance.init_arg1, 11) @@ -523,8 +526,8 @@ class SingletonTests(unittest.TestCase): def test_call_with_context_kwargs(self): """Test getting of instances with context kwargs.""" - provider = di.Singleton(Example, - di.KwArg('init_arg1', 1)) + provider = providers.Singleton(Example, + injections.KwArg('init_arg1', 1)) instance1 = provider(init_arg2=22) self.assertEqual(instance1.init_arg1, 1) @@ -537,7 +540,7 @@ class SingletonTests(unittest.TestCase): def test_call_with_context_args_and_kwargs(self): """Test getting of instances with context args and kwargs.""" - provider = di.Singleton(Example, 11) + provider = providers.Singleton(Example, 11) instance = provider(22, init_arg3=33, init_arg4=44) self.assertEqual(instance.init_arg1, 11) @@ -547,9 +550,9 @@ class SingletonTests(unittest.TestCase): def test_call_overridden(self): """Test getting of instances on overridden provider.""" - provider = di.Singleton(Example) - overriding_provider1 = di.Singleton(dict) - overriding_provider2 = di.Singleton(object) + provider = providers.Singleton(Example) + overriding_provider1 = providers.Singleton(dict) + overriding_provider2 = providers.Singleton(object) provider.override(overriding_provider1) provider.override(overriding_provider2) @@ -563,21 +566,18 @@ class SingletonTests(unittest.TestCase): def test_injections(self): """Test getting a full list of injections using injections property.""" - provider = di.Singleton(Example, - di.Arg(1), - di.KwArg('init_arg2', 2), - di.Attribute('attribute1', 3), - di.Attribute('attribute2', 4), - di.Method('method1', 5), - di.Method('method2', 6)) - - injections = provider.injections - - self.assertEquals(len(injections), 6) + provider = providers.Singleton(Example, + injections.Arg(1), + injections.KwArg('init_arg2', 2), + injections.Attribute('attribute1', 3), + injections.Attribute('attribute2', 4), + injections.Method('method1', 5), + injections.Method('method2', 6)) + self.assertEquals(len(provider.injections), 6) def test_reset(self): """Test creation and reset of single object.""" - provider = di.Singleton(object) + provider = providers.Singleton(object) instance1 = provider() self.assertIsInstance(instance1, object) @@ -595,29 +595,29 @@ class ExternalDependencyTests(unittest.TestCase): def setUp(self): """Set test cases environment up.""" - self.provider = di.ExternalDependency(instance_of=list) + self.provider = providers.ExternalDependency(instance_of=list) def test_init_with_not_class(self): """Test creation with not a class.""" - self.assertRaises(di.Error, di.ExternalDependency, object()) + self.assertRaises(errors.Error, providers.ExternalDependency, object()) def test_is_provider(self): """Test `is_provider` check.""" - self.assertTrue(di.is_provider(self.provider)) + self.assertTrue(utils.is_provider(self.provider)) def test_call_overridden(self): """Test call of overridden external dependency.""" - self.provider.provided_by(di.Factory(list)) + self.provider.provided_by(providers.Factory(list)) self.assertIsInstance(self.provider(), list) def test_call_overridden_but_not_instance_of(self): """Test call of overridden external dependency, but not instance of.""" - self.provider.provided_by(di.Factory(dict)) - self.assertRaises(di.Error, self.provider) + self.provider.provided_by(providers.Factory(dict)) + self.assertRaises(errors.Error, self.provider) def test_call_not_overridden(self): """Test call of not satisfied external dependency.""" - self.assertRaises(di.Error, self.provider) + self.assertRaises(errors.Error, self.provider) class StaticProvidersTests(unittest.TestCase): @@ -625,52 +625,52 @@ class StaticProvidersTests(unittest.TestCase): def test_is_provider(self): """Test `is_provider` check.""" - self.assertTrue(di.is_provider(di.Class(object))) - self.assertTrue(di.is_provider(di.Object(object()))) - self.assertTrue(di.is_provider(di.Function(map))) - self.assertTrue(di.is_provider(di.Value(123))) + self.assertTrue(utils.is_provider(providers.Class(object))) + self.assertTrue(utils.is_provider(providers.Object(object()))) + self.assertTrue(utils.is_provider(providers.Function(map))) + self.assertTrue(utils.is_provider(providers.Value(123))) def test_call_class_provider(self): """Test Class provider call.""" - self.assertIs(di.Class(dict)(), dict) + self.assertIs(providers.Class(dict)(), dict) def test_call_object_provider(self): """Test Object provider call.""" obj = object() - self.assertIs(di.Object(obj)(), obj) + self.assertIs(providers.Object(obj)(), obj) def test_call_function_provider(self): """Test Function provider call.""" - self.assertIs(di.Function(map)(), map) + self.assertIs(providers.Function(map)(), map) def test_call_value_provider(self): """Test Value provider call.""" - self.assertEqual(di.Value(123)(), 123) + self.assertEqual(providers.Value(123)(), 123) def test_call_overridden_class_provider(self): """Test overridden Class provider call.""" - cls_provider = di.Class(dict) - cls_provider.override(di.Object(list)) + cls_provider = providers.Class(dict) + cls_provider.override(providers.Object(list)) self.assertIs(cls_provider(), list) def test_call_overridden_object_provider(self): """Test overridden Object provider call.""" obj1 = object() obj2 = object() - obj_provider = di.Object(obj1) - obj_provider.override(di.Object(obj2)) + obj_provider = providers.Object(obj1) + obj_provider.override(providers.Object(obj2)) self.assertIs(obj_provider(), obj2) def test_call_overridden_function_provider(self): """Test overridden Function provider call.""" - function_provider = di.Function(len) - function_provider.override(di.Function(sum)) + function_provider = providers.Function(len) + function_provider.override(providers.Function(sum)) self.assertIs(function_provider(), sum) def test_call_overridden_value_provider(self): """Test overridden Value provider call.""" - value_provider = di.Value(123) - value_provider.override(di.Value(321)) + value_provider = providers.Value(123) + value_provider.override(providers.Value(321)) self.assertEqual(value_provider(), 321) @@ -683,15 +683,15 @@ class CallableTests(unittest.TestCase): def test_init_with_callable(self): """Test creation of provider with a callable.""" - self.assertTrue(di.Callable(self.example)) + self.assertTrue(providers.Callable(self.example)) def test_init_with_not_callable(self): """Test creation of provider with not a callable.""" - self.assertRaises(di.Error, di.Callable, 123) + self.assertRaises(errors.Error, providers.Callable, 123) def test_call(self): """Test call.""" - provider = di.Callable(lambda: True) + provider = providers.Callable(lambda: True) self.assertTrue(provider()) def test_call_with_positional_args(self): @@ -699,7 +699,7 @@ class CallableTests(unittest.TestCase): New simplified syntax. """ - provider = di.Callable(self.example, 1, 2, 3, 4) + provider = providers.Callable(self.example, 1, 2, 3, 4) self.assertTupleEqual(provider(), (1, 2, 3, 4)) def test_call_with_keyword_args(self): @@ -707,7 +707,11 @@ class CallableTests(unittest.TestCase): New simplified syntax. """ - provider = di.Callable(self.example, arg1=1, arg2=2, arg3=3, arg4=4) + provider = providers.Callable(self.example, + arg1=1, + arg2=2, + arg3=3, + arg4=4) self.assertTupleEqual(provider(), (1, 2, 3, 4)) def test_call_with_positional_and_keyword_args(self): @@ -715,7 +719,7 @@ class CallableTests(unittest.TestCase): Simplified syntax of positional and keyword arg injections. """ - provider = di.Callable(self.example, 1, 2, arg3=3, arg4=4) + provider = providers.Callable(self.example, 1, 2, arg3=3, arg4=4) self.assertTupleEqual(provider(), (1, 2, 3, 4)) def test_call_with_positional_and_keyword_args_extended_syntax(self): @@ -723,40 +727,40 @@ class CallableTests(unittest.TestCase): Extended syntax of positional and keyword arg injections. """ - provider = di.Callable(self.example, - di.Arg(1), - di.Arg(2), - di.KwArg('arg3', 3), - di.KwArg('arg4', 4)) + provider = providers.Callable(self.example, + injections.Arg(1), + injections.Arg(2), + injections.KwArg('arg3', 3), + injections.KwArg('arg4', 4)) self.assertTupleEqual(provider(), (1, 2, 3, 4)) def test_call_with_context_args(self): """Test call with context args.""" - provider = di.Callable(self.example, 1, 2) + provider = providers.Callable(self.example, 1, 2) self.assertTupleEqual(provider(3, 4), (1, 2, 3, 4)) def test_call_with_context_kwargs(self): """Test call with context kwargs.""" - provider = di.Callable(self.example, - di.KwArg('arg1', 1)) + provider = providers.Callable(self.example, + injections.KwArg('arg1', 1)) self.assertTupleEqual(provider(arg2=2, arg3=3, arg4=4), (1, 2, 3, 4)) def test_call_with_context_args_and_kwargs(self): """Test call with context args and kwargs.""" - provider = di.Callable(self.example, 1) + provider = providers.Callable(self.example, 1) self.assertTupleEqual(provider(2, arg3=3, arg4=4), (1, 2, 3, 4)) def test_call_overridden(self): """Test creation of new instances on overridden provider.""" - provider = di.Callable(self.example) - provider.override(di.Value((4, 3, 2, 1))) - provider.override(di.Value((1, 2, 3, 4))) + provider = providers.Callable(self.example) + provider.override(providers.Value((4, 3, 2, 1))) + provider.override(providers.Value((1, 2, 3, 4))) self.assertTupleEqual(provider(), (1, 2, 3, 4)) def test_injections(self): """Test getting a full list of injections using injections property.""" - provider = di.Callable(self.example, 1, 2, arg3=3, arg4=4) + provider = providers.Callable(self.example, 1, 2, arg3=3, arg4=4) self.assertEquals(len(provider.injections), 4) @@ -767,15 +771,15 @@ class ConfigTests(unittest.TestCase): """Set test cases environment up.""" self.initial_data = dict(key='value', category=dict(setting='setting_value')) - self.provider = di.Config(self.initial_data) + self.provider = providers.Config(self.initial_data) def test_is_provider(self): """Test `is_provider` check.""" - self.assertTrue(di.is_provider(self.provider)) + self.assertTrue(utils.is_provider(self.provider)) def test_init_without_initial_value(self): """Test provider's creation with no initial value.""" - self.assertEqual(di.Config()(), dict()) + self.assertEqual(providers.Config()(), dict()) def test_call(self): """Test returning of config value.""" @@ -794,8 +798,8 @@ class ConfigTests(unittest.TestCase): category = self.provider.category category_setting = self.provider.category.setting - self.assertTrue(di.is_provider(category)) - self.assertTrue(di.is_provider(category_setting)) + self.assertTrue(utils.is_provider(category)) + self.assertTrue(utils.is_provider(category_setting)) self.assertEqual(category(), self.initial_data['category']) self.assertEqual(category_setting(), @@ -803,12 +807,12 @@ class ConfigTests(unittest.TestCase): def test_call_deferred_child_and_update_from(self): """Test returning of deferred child config values.""" - self.provider = di.Config() + self.provider = providers.Config() category = self.provider.category category_setting = self.provider.category.setting - self.assertTrue(di.is_provider(category)) - self.assertTrue(di.is_provider(category_setting)) + self.assertTrue(utils.is_provider(category)) + self.assertTrue(utils.is_provider(category_setting)) self.provider.update_from(self.initial_data) @@ -818,6 +822,6 @@ class ConfigTests(unittest.TestCase): def test_call_deferred_child_with_empty_value(self): """Test returning of deferred child config values.""" - self.provider = di.Config() + self.provider = providers.Config() category_setting = self.provider.category.setting - self.assertRaises(di.Error, category_setting) + self.assertRaises(errors.Error, category_setting) diff --git a/tests/test_utils.py b/tests/test_utils.py index 93a289a7..263d7618 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -1,7 +1,12 @@ """Dependency injector utils unittests.""" import unittest2 as unittest -import dependency_injector as di + +from dependency_injector import utils +from dependency_injector import providers +from dependency_injector import injections +from dependency_injector import catalogs +from dependency_injector import errors class IsProviderTests(unittest.TestCase): @@ -9,26 +14,26 @@ class IsProviderTests(unittest.TestCase): def test_with_instance(self): """Test with instance.""" - self.assertTrue(di.is_provider(di.Provider())) + self.assertTrue(utils.is_provider(providers.Provider())) def test_with_class(self): """Test with class.""" - self.assertFalse(di.is_provider(di.Provider)) + self.assertFalse(utils.is_provider(providers.Provider)) def test_with_string(self): """Test with string.""" - self.assertFalse(di.is_provider('some_string')) + self.assertFalse(utils.is_provider('some_string')) def test_with_object(self): """Test with object.""" - self.assertFalse(di.is_provider(object())) + self.assertFalse(utils.is_provider(object())) def test_with_subclass_instance(self): """Test with subclass of provider instance.""" - class SomeProvider(di.Provider): + class SomeProvider(providers.Provider): """Some provider for test.""" - self.assertTrue(di.is_provider(SomeProvider())) + self.assertTrue(utils.is_provider(SomeProvider())) def test_with_class_with_getattr(self): """Test with class that has __getattr__() method implementation.""" @@ -39,7 +44,7 @@ class IsProviderTests(unittest.TestCase): """Test implementation that just returns False.""" return False - self.assertFalse(di.is_provider(SomeClass())) + self.assertFalse(utils.is_provider(SomeClass())) class EnsureIsProviderTests(unittest.TestCase): @@ -47,20 +52,24 @@ class EnsureIsProviderTests(unittest.TestCase): def test_with_instance(self): """Test with instance.""" - provider = di.Provider() - self.assertIs(di.ensure_is_provider(provider), provider) + provider = providers.Provider() + self.assertIs(utils.ensure_is_provider(provider), provider) def test_with_class(self): """Test with class.""" - self.assertRaises(di.Error, di.ensure_is_provider, di.Provider) + self.assertRaises(errors.Error, + utils.ensure_is_provider, + providers.Provider) def test_with_string(self): """Test with string.""" - self.assertRaises(di.Error, di.ensure_is_provider, 'some_string') + self.assertRaises(errors.Error, + utils.ensure_is_provider, + 'some_string') def test_with_object(self): """Test with object.""" - self.assertRaises(di.Error, di.ensure_is_provider, object()) + self.assertRaises(errors.Error, utils.ensure_is_provider, object()) class IsInjectionTests(unittest.TestCase): @@ -68,26 +77,29 @@ class IsInjectionTests(unittest.TestCase): def test_with_instance(self): """Test with instance.""" - self.assertTrue(di.is_injection(di.Injection('value'))) + self.assertTrue(utils.is_injection(injections.Injection('value'))) def test_with_subclass_instances(self): """Test with subclass instances.""" - self.assertTrue(di.is_injection(di.Arg('value'))) - self.assertTrue(di.is_injection(di.KwArg('name', 'value'))) - self.assertTrue(di.is_injection(di.Attribute('name', 'value'))) - self.assertTrue(di.is_injection(di.Method('name', 'value'))) + self.assertTrue(utils.is_injection(injections.Arg('value'))) + self.assertTrue(utils.is_injection(injections.KwArg('name', + 'value'))) + self.assertTrue(utils.is_injection(injections.Attribute('name', + 'value'))) + self.assertTrue(utils.is_injection(injections.Method('name', + 'value'))) def test_with_class(self): """Test with class.""" - self.assertFalse(di.is_injection(di.Injection)) + self.assertFalse(utils.is_injection(injections.Injection)) def test_with_string(self): """Test with string.""" - self.assertFalse(di.is_injection('some_string')) + self.assertFalse(utils.is_injection('some_string')) def test_with_object(self): """Test with object.""" - self.assertFalse(di.is_injection(object())) + self.assertFalse(utils.is_injection(object())) class EnsureIsInjectionTests(unittest.TestCase): @@ -95,20 +107,26 @@ class EnsureIsInjectionTests(unittest.TestCase): def test_with_instance(self): """Test with instance.""" - injection = di.Injection('value') - self.assertIs(di.ensure_is_injection(injection), injection) + injection = injections.Injection('value') + self.assertIs(utils.ensure_is_injection(injection), injection) def test_with_class(self): """Test with class.""" - self.assertRaises(di.Error, di.ensure_is_injection, di.Injection) + self.assertRaises(errors.Error, + utils.ensure_is_injection, + injections.Injection) def test_with_string(self): """Test with string.""" - self.assertRaises(di.Error, di.ensure_is_injection, 'some_string') + self.assertRaises(errors.Error, + utils.ensure_is_injection, + 'some_string') def test_with_object(self): """Test with object.""" - self.assertRaises(di.Error, di.ensure_is_injection, object()) + self.assertRaises(errors.Error, + utils.ensure_is_injection, + object()) class IsArgInjectionTests(unittest.TestCase): @@ -116,23 +134,23 @@ class IsArgInjectionTests(unittest.TestCase): def test_with_instance(self): """Test with instance.""" - self.assertTrue(di.is_arg_injection(di.Arg('value'))) + self.assertTrue(utils.is_arg_injection(injections.Arg('value'))) def test_with_class(self): """Test with class.""" - self.assertFalse(di.is_arg_injection(di.Arg)) + self.assertFalse(utils.is_arg_injection(injections.Arg)) def test_with_parent_class(self): """Test with parent class.""" - self.assertFalse(di.is_arg_injection(di.Injection)) + self.assertFalse(utils.is_arg_injection(injections.Injection)) def test_with_string(self): """Test with string.""" - self.assertFalse(di.is_arg_injection('some_string')) + self.assertFalse(utils.is_arg_injection('some_string')) def test_with_object(self): """Test with object.""" - self.assertFalse(di.is_arg_injection(object())) + self.assertFalse(utils.is_arg_injection(object())) class IsKwArgInjectionTests(unittest.TestCase): @@ -140,23 +158,24 @@ class IsKwArgInjectionTests(unittest.TestCase): def test_with_instance(self): """Test with instance.""" - self.assertTrue(di.is_kwarg_injection(di.KwArg('name', 'value'))) + self.assertTrue(utils.is_kwarg_injection(injections.KwArg('name', + 'value'))) def test_with_class(self): """Test with class.""" - self.assertFalse(di.is_kwarg_injection(di.KwArg)) + self.assertFalse(utils.is_kwarg_injection(injections.KwArg)) def test_with_parent_class(self): """Test with parent class.""" - self.assertFalse(di.is_kwarg_injection(di.Injection)) + self.assertFalse(utils.is_kwarg_injection(injections.Injection)) def test_with_string(self): """Test with string.""" - self.assertFalse(di.is_kwarg_injection('some_string')) + self.assertFalse(utils.is_kwarg_injection('some_string')) def test_with_object(self): """Test with object.""" - self.assertFalse(di.is_kwarg_injection(object())) + self.assertFalse(utils.is_kwarg_injection(object())) class IsAttributeInjectionTests(unittest.TestCase): @@ -164,24 +183,24 @@ class IsAttributeInjectionTests(unittest.TestCase): def test_with_instance(self): """Test with instance.""" - self.assertTrue(di.is_attribute_injection(di.Attribute('name', - 'value'))) + self.assertTrue(utils.is_attribute_injection( + injections.Attribute('name', 'value'))) def test_with_class(self): """Test with class.""" - self.assertFalse(di.is_attribute_injection(di.Attribute)) + self.assertFalse(utils.is_attribute_injection(injections.Attribute)) def test_with_parent_class(self): """Test with parent class.""" - self.assertFalse(di.is_attribute_injection(di.Injection)) + self.assertFalse(utils.is_attribute_injection(injections.Injection)) def test_with_string(self): """Test with string.""" - self.assertFalse(di.is_attribute_injection('some_string')) + self.assertFalse(utils.is_attribute_injection('some_string')) def test_with_object(self): """Test with object.""" - self.assertFalse(di.is_attribute_injection(object())) + self.assertFalse(utils.is_attribute_injection(object())) class IsMethodInjectionTests(unittest.TestCase): @@ -189,23 +208,24 @@ class IsMethodInjectionTests(unittest.TestCase): def test_with_instance(self): """Test with instance.""" - self.assertTrue(di.is_method_injection(di.Method('name', 'value'))) + self.assertTrue(utils.is_method_injection( + injections.Method('name', 'value'))) def test_with_class(self): """Test with class.""" - self.assertFalse(di.is_method_injection(di.Method)) + self.assertFalse(utils.is_method_injection(injections.Method)) def test_with_parent_class(self): """Test with parent class.""" - self.assertFalse(di.is_method_injection(di.Injection)) + self.assertFalse(utils.is_method_injection(injections.Injection)) def test_with_string(self): """Test with string.""" - self.assertFalse(di.is_method_injection('some_string')) + self.assertFalse(utils.is_method_injection('some_string')) def test_with_object(self): """Test with object.""" - self.assertFalse(di.is_method_injection(object())) + self.assertFalse(utils.is_method_injection(object())) class IsCatalogTests(unittest.TestCase): @@ -213,26 +233,26 @@ class IsCatalogTests(unittest.TestCase): def test_with_declarative_catalog(self): """Test with class.""" - self.assertTrue(di.is_catalog(di.DeclarativeCatalog)) + self.assertTrue(utils.is_catalog(catalogs.DeclarativeCatalog)) def test_with_dynamic_catalog(self): """Test with class.""" - self.assertTrue(di.is_catalog(di.DynamicCatalog())) + self.assertTrue(utils.is_catalog(catalogs.DynamicCatalog())) def test_with_child_class(self): """Test with parent class.""" - class Catalog(di.AbstractCatalog): + class Catalog(catalogs.DeclarativeCatalog): """Example catalog child class.""" - self.assertTrue(di.is_catalog(Catalog)) + self.assertTrue(utils.is_catalog(Catalog)) def test_with_string(self): """Test with string.""" - self.assertFalse(di.is_catalog('some_string')) + self.assertFalse(utils.is_catalog('some_string')) def test_with_object(self): """Test with object.""" - self.assertFalse(di.is_catalog(object())) + self.assertFalse(utils.is_catalog(object())) class IsDynamicCatalogTests(unittest.TestCase): @@ -240,11 +260,11 @@ class IsDynamicCatalogTests(unittest.TestCase): def test_with_declarative_catalog(self): """Test with declarative catalog.""" - self.assertFalse(di.is_dynamic_catalog(di.DeclarativeCatalog)) + self.assertFalse(utils.is_dynamic_catalog(catalogs.DeclarativeCatalog)) def test_with_dynamic_catalog(self): """Test with dynamic catalog.""" - self.assertTrue(di.is_dynamic_catalog(di.DynamicCatalog())) + self.assertTrue(utils.is_dynamic_catalog(catalogs.DynamicCatalog())) class IsDeclarativeCatalogTests(unittest.TestCase): @@ -252,11 +272,13 @@ class IsDeclarativeCatalogTests(unittest.TestCase): def test_with_declarative_catalog(self): """Test with declarative catalog.""" - self.assertTrue(di.is_declarative_catalog(di.DeclarativeCatalog)) + self.assertTrue(utils.is_declarative_catalog( + catalogs.DeclarativeCatalog)) def test_with_dynamic_catalog(self): """Test with dynamic catalog.""" - self.assertFalse(di.is_declarative_catalog(di.DynamicCatalog())) + self.assertFalse(utils.is_declarative_catalog( + catalogs.DynamicCatalog())) class IsCatalogBundleTests(unittest.TestCase): @@ -264,19 +286,19 @@ class IsCatalogBundleTests(unittest.TestCase): def test_with_instance(self): """Test with instance.""" - self.assertTrue(di.is_catalog_bundle(di.CatalogBundle())) + self.assertTrue(utils.is_catalog_bundle(catalogs.CatalogBundle())) def test_with_cls(self): """Test with class.""" - self.assertFalse(di.is_catalog_bundle(di.CatalogBundle)) + self.assertFalse(utils.is_catalog_bundle(catalogs.CatalogBundle)) def test_with_string(self): """Test with string.""" - self.assertFalse(di.is_catalog_bundle('some_string')) + self.assertFalse(utils.is_catalog_bundle('some_string')) def test_with_object(self): """Test with object.""" - self.assertFalse(di.is_catalog_bundle(object())) + self.assertFalse(utils.is_catalog_bundle(object())) class EnsureIsCatalogBundleTests(unittest.TestCase): @@ -284,18 +306,23 @@ class EnsureIsCatalogBundleTests(unittest.TestCase): def test_with_instance(self): """Test with instance.""" - bundle = di.CatalogBundle() - self.assertIs(di.ensure_is_catalog_bundle(bundle), bundle) + bundle = catalogs.CatalogBundle() + self.assertIs(utils.ensure_is_catalog_bundle(bundle), bundle) def test_with_class(self): """Test with class.""" - self.assertRaises(di.Error, di.ensure_is_catalog_bundle, - di.CatalogBundle) + self.assertRaises(errors.Error, + utils.ensure_is_catalog_bundle, + catalogs.CatalogBundle) def test_with_string(self): """Test with string.""" - self.assertRaises(di.Error, di.ensure_is_catalog_bundle, 'some_string') + self.assertRaises(errors.Error, + utils.ensure_is_catalog_bundle, + 'some_string') def test_with_object(self): """Test with object.""" - self.assertRaises(di.Error, di.ensure_is_catalog_bundle, object()) + self.assertRaises(errors.Error, + utils.ensure_is_catalog_bundle, + object())