ets-labs/python-dependency-injector
1
1
Fork 0
mirror of https://github.com/ets-labs/python-dependency-injector.git synced 2025-02-16 19:40:59 +03:00
Code Issues Packages Projects Releases Wiki Activity

Refactor tests imports

Browse Source
This commit is contained in:
Roman Mogilatov 2015-11-23 21:45:58 +02:00
parent 99b9a5648a
commit 3c0c3b3abc
5 changed files with 392 additions and 339 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

181
tests/test_catalogs.py
View File

@ -1,21 +1,24 @@
"""Dependency injector catalogs unittests.""" """Dependency injector catalogs unittests."""
import unittest2 as unittest 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.""" """Test catalog A."""
p11 = di.Provider() p11 = providers.Provider()
p12 = di.Provider() p12 = providers.Provider()
class CatalogB(CatalogA): class CatalogB(CatalogA):
"""Test catalog B.""" """Test catalog B."""
p21 = di.Provider() p21 = providers.Provider()
p22 = di.Provider() p22 = providers.Provider()
class CatalogBundleTests(unittest.TestCase): class CatalogBundleTests(unittest.TestCase):
@ -33,8 +36,8 @@ class CatalogBundleTests(unittest.TestCase):
def test_get_attr_not_from_bundle(self): def test_get_attr_not_from_bundle(self):
"""Test get providers (attribute) that are not in bundle.""" """Test get providers (attribute) that are not in bundle."""
self.assertRaises(di.Error, getattr, self.bundle, 'p21') self.assertRaises(errors.Error, getattr, self.bundle, 'p21')
self.assertRaises(di.Error, getattr, self.bundle, 'p22') self.assertRaises(errors.Error, getattr, self.bundle, 'p22')
def test_get_method_from_bundle(self): def test_get_method_from_bundle(self):
"""Test get providers (get() method) from bundle.""" """Test get providers (get() method) from bundle."""
@ -43,8 +46,8 @@ class CatalogBundleTests(unittest.TestCase):
def test_get_method_not_from_bundle(self): def test_get_method_not_from_bundle(self):
"""Test get providers (get() method) that are not in bundle.""" """Test get providers (get() method) that are not in bundle."""
self.assertRaises(di.Error, self.bundle.get_provider, 'p21') self.assertRaises(errors.Error, self.bundle.get_provider, 'p21')
self.assertRaises(di.Error, self.bundle.get_provider, 'p22') self.assertRaises(errors.Error, self.bundle.get_provider, 'p22')
def test_has(self): def test_has(self):
"""Test checks of providers availability in bundle.""" """Test checks of providers availability in bundle."""
@ -64,26 +67,26 @@ class CatalogBundleTests(unittest.TestCase):
def test_create_bundle_with_unbound_provider(self): def test_create_bundle_with_unbound_provider(self):
"""Test that bundle is not created with unbound provider.""" """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): def test_create_bundle_with_another_catalog_provider(self):
"""Test that bundle can not contain another catalog's provider.""" """Test that bundle can not contain another catalog's provider."""
class TestCatalog(di.DeclarativeCatalog): class TestCatalog(catalogs.DeclarativeCatalog):
"""Test catalog.""" """Test catalog."""
provider = di.Provider() provider = providers.Provider()
self.assertRaises(di.Error, self.assertRaises(errors.Error,
CatalogB.Bundle, CatalogB.p21, TestCatalog.provider) CatalogB.Bundle, CatalogB.p21, TestCatalog.provider)
def test_create_bundle_with_another_catalog_provider_with_same_name(self): def test_create_bundle_with_another_catalog_provider_with_same_name(self):
"""Test that bundle can not contain another catalog's provider.""" """Test that bundle can not contain another catalog's provider."""
class TestCatalog(di.DeclarativeCatalog): class TestCatalog(catalogs.DeclarativeCatalog):
"""Test catalog.""" """Test catalog."""
p21 = di.Provider() p21 = providers.Provider()
self.assertRaises(di.Error, self.assertRaises(errors.Error,
CatalogB.Bundle, CatalogB.p21, TestCatalog.p21) CatalogB.Bundle, CatalogB.p21, TestCatalog.p21)
def test_is_bundle_owner(self): def test_is_bundle_owner(self):
@ -93,7 +96,7 @@ class CatalogBundleTests(unittest.TestCase):
def test_is_bundle_owner_with_not_bundle_instance(self): def test_is_bundle_owner_with_not_bundle_instance(self):
"""Test that check of bundle ownership raises error with not bundle.""" """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): class DynamicCatalogTests(unittest.TestCase):
@ -104,8 +107,8 @@ class DynamicCatalogTests(unittest.TestCase):
def setUp(self): def setUp(self):
"""Set test environment up.""" """Set test environment up."""
self.catalog = di.DynamicCatalog(p1=di.Provider(), self.catalog = catalogs.DynamicCatalog(p1=providers.Provider(),
p2=di.Provider()) p2=providers.Provider())
self.catalog.name = 'TestCatalog' self.catalog.name = 'TestCatalog'
def test_providers(self): def test_providers(self):
@ -116,8 +119,8 @@ class DynamicCatalogTests(unittest.TestCase):
def test_bind_provider(self): def test_bind_provider(self):
"""Test setting of provider via bind_provider() to catalog.""" """Test setting of provider via bind_provider() to catalog."""
px = di.Provider() px = providers.Provider()
py = di.Provider() py = providers.Provider()
self.catalog.bind_provider('px', px) self.catalog.bind_provider('px', px)
self.catalog.bind_provider('py', py) self.catalog.bind_provider('py', py)
@ -130,8 +133,8 @@ class DynamicCatalogTests(unittest.TestCase):
def test_bind_providers(self): def test_bind_providers(self):
"""Test setting of provider via bind_providers() to catalog.""" """Test setting of provider via bind_providers() to catalog."""
px = di.Provider() px = providers.Provider()
py = di.Provider() py = providers.Provider()
self.catalog.bind_providers(dict(px=px, py=py)) self.catalog.bind_providers(dict(px=px, py=py))
@ -143,8 +146,8 @@ class DynamicCatalogTests(unittest.TestCase):
def test_setattr(self): def test_setattr(self):
"""Test setting of providers via attributes to catalog.""" """Test setting of providers via attributes to catalog."""
px = di.Provider() px = providers.Provider()
py = di.Provider() py = providers.Provider()
self.catalog.px = px self.catalog.px = px
self.catalog.py = py self.catalog.py = py
@ -157,13 +160,13 @@ class DynamicCatalogTests(unittest.TestCase):
def test_unbind_provider(self): def test_unbind_provider(self):
"""Test that catalog unbinds provider correct.""" """Test that catalog unbinds provider correct."""
self.catalog.px = di.Provider() self.catalog.px = providers.Provider()
self.catalog.unbind_provider('px') self.catalog.unbind_provider('px')
self.assertFalse(self.catalog.has_provider('px')) self.assertFalse(self.catalog.has_provider('px'))
def test_unbind_via_delattr(self): def test_unbind_via_delattr(self):
"""Test that catalog unbinds provider correct.""" """Test that catalog unbinds provider correct."""
self.catalog.px = di.Provider() self.catalog.px = providers.Provider()
del self.catalog.px del self.catalog.px
self.assertFalse(self.catalog.has_provider('px')) self.assertFalse(self.catalog.has_provider('px'))
@ -181,8 +184,8 @@ class DynamicCatalogTests(unittest.TestCase):
p1 = self.catalog.p1 p1 = self.catalog.p1
p2 = self.catalog.p2 p2 = self.catalog.p2
catalog_a = di.DynamicCatalog(pa1=p1, pa2=p2) catalog_a = catalogs.DynamicCatalog(pa1=p1, pa2=p2)
catalog_b = di.DynamicCatalog(pb1=p1, pb2=p2) catalog_b = catalogs.DynamicCatalog(pb1=p1, pb2=p2)
self.assertTrue(self.catalog.is_provider_bound(p1)) self.assertTrue(self.catalog.is_provider_bound(p1))
self.assertTrue(catalog_a.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): def test_provider_rebinding_to_the_same_catalog(self):
"""Test provider rebinding to the same catalog.""" """Test provider rebinding to the same catalog."""
with self.assertRaises(di.Error): with self.assertRaises(errors.Error):
self.catalog.p3 = self.catalog.p1 self.catalog.p3 = self.catalog.p1
def test_provider_binding_with_the_same_name(self): def test_provider_binding_with_the_same_name(self):
"""Test binding of provider with the same name.""" """Test binding of provider with the same name."""
with self.assertRaises(di.Error): with self.assertRaises(errors.Error):
self.catalog.bind_provider('p1', di.Provider()) self.catalog.bind_provider('p1', providers.Provider())
def test_get(self): def test_get(self):
"""Test getting of providers using get() method.""" """Test getting of providers using get() method."""
@ -215,10 +218,10 @@ class DynamicCatalogTests(unittest.TestCase):
def test_get_undefined(self): def test_get_undefined(self):
"""Test getting of undefined providers using get() method.""" """Test getting of undefined providers using get() method."""
with self.assertRaises(di.UndefinedProviderError): with self.assertRaises(errors.UndefinedProviderError):
self.catalog.get_provider('undefined') self.catalog.get_provider('undefined')
with self.assertRaises(di.UndefinedProviderError): with self.assertRaises(errors.UndefinedProviderError):
self.catalog.undefined self.catalog.undefined
def test_has_provider(self): def test_has_provider(self):
@ -229,8 +232,8 @@ class DynamicCatalogTests(unittest.TestCase):
def test_filter_all_providers_by_type(self): def test_filter_all_providers_by_type(self):
"""Test getting of all catalog providers of specific type.""" """Test getting of all catalog providers of specific type."""
self.assertTrue(len(self.catalog.filter(di.Provider)) == 2) self.assertTrue(len(self.catalog.filter(providers.Provider)) == 2)
self.assertTrue(len(self.catalog.filter(di.Value)) == 0) self.assertTrue(len(self.catalog.filter(providers.Value)) == 0)
def test_repr(self): def test_repr(self):
"""Test catalog representation.""" """Test catalog representation."""
@ -271,8 +274,8 @@ class DeclarativeCatalogTests(unittest.TestCase):
def test_bind_provider(self): def test_bind_provider(self):
"""Test setting of provider via bind_provider() to catalog.""" """Test setting of provider via bind_provider() to catalog."""
px = di.Provider() px = providers.Provider()
py = di.Provider() py = providers.Provider()
CatalogA.bind_provider('px', px) CatalogA.bind_provider('px', px)
CatalogA.bind_provider('py', py) CatalogA.bind_provider('py', py)
@ -290,8 +293,8 @@ class DeclarativeCatalogTests(unittest.TestCase):
def test_bind_providers(self): def test_bind_providers(self):
"""Test setting of provider via bind_providers() to catalog.""" """Test setting of provider via bind_providers() to catalog."""
px = di.Provider() px = providers.Provider()
py = di.Provider() py = providers.Provider()
CatalogB.bind_providers(dict(px=px, py=py)) CatalogB.bind_providers(dict(px=px, py=py))
@ -308,8 +311,8 @@ class DeclarativeCatalogTests(unittest.TestCase):
def test_setattr(self): def test_setattr(self):
"""Test setting of providers via attributes to catalog.""" """Test setting of providers via attributes to catalog."""
px = di.Provider() px = providers.Provider()
py = di.Provider() py = providers.Provider()
CatalogB.px = px CatalogB.px = px
CatalogB.py = py CatalogB.py = py
@ -327,13 +330,13 @@ class DeclarativeCatalogTests(unittest.TestCase):
def test_unbind_provider(self): def test_unbind_provider(self):
"""Test that catalog unbinds provider correct.""" """Test that catalog unbinds provider correct."""
CatalogB.px = di.Provider() CatalogB.px = providers.Provider()
CatalogB.unbind_provider('px') CatalogB.unbind_provider('px')
self.assertFalse(CatalogB.has_provider('px')) self.assertFalse(CatalogB.has_provider('px'))
def test_unbind_via_delattr(self): def test_unbind_via_delattr(self):
"""Test that catalog unbinds provider correct.""" """Test that catalog unbinds provider correct."""
CatalogB.px = di.Provider() CatalogB.px = providers.Provider()
del CatalogB.px del CatalogB.px
self.assertFalse(CatalogB.has_provider('px')) self.assertFalse(CatalogB.has_provider('px'))
@ -350,13 +353,13 @@ class DeclarativeCatalogTests(unittest.TestCase):
p11 = CatalogA.p11 p11 = CatalogA.p11
p12 = CatalogA.p12 p12 = CatalogA.p12
class CatalogD(di.DeclarativeCatalog): class CatalogD(catalogs.DeclarativeCatalog):
"""Test catalog.""" """Test catalog."""
pd1 = p11 pd1 = p11
pd2 = p12 pd2 = p12
class CatalogE(di.DeclarativeCatalog): class CatalogE(catalogs.DeclarativeCatalog):
"""Test catalog.""" """Test catalog."""
pe1 = p11 pe1 = p11
@ -378,21 +381,21 @@ class DeclarativeCatalogTests(unittest.TestCase):
def test_provider_rebinding_to_the_same_catalog(self): def test_provider_rebinding_to_the_same_catalog(self):
"""Test provider rebinding to the same catalog.""" """Test provider rebinding to the same catalog."""
with self.assertRaises(di.Error): with self.assertRaises(errors.Error):
class TestCatalog(di.DeclarativeCatalog): class TestCatalog(catalogs.DeclarativeCatalog):
"""Test catalog.""" """Test catalog."""
p1 = di.Provider() p1 = providers.Provider()
p2 = p1 p2 = p1
def test_provider_rebinding_to_the_same_catalogs_hierarchy(self): def test_provider_rebinding_to_the_same_catalogs_hierarchy(self):
"""Test provider rebinding to the same catalogs hierarchy.""" """Test provider rebinding to the same catalogs hierarchy."""
class TestCatalog1(di.DeclarativeCatalog): class TestCatalog1(catalogs.DeclarativeCatalog):
"""Test catalog.""" """Test catalog."""
p1 = di.Provider() p1 = providers.Provider()
with self.assertRaises(di.Error): with self.assertRaises(errors.Error):
class TestCatalog2(TestCatalog1): class TestCatalog2(TestCatalog1):
"""Test catalog.""" """Test catalog."""
@ -412,13 +415,13 @@ class DeclarativeCatalogTests(unittest.TestCase):
def test_get_undefined(self): def test_get_undefined(self):
"""Test getting of undefined providers using get() method.""" """Test getting of undefined providers using get() method."""
with self.assertRaises(di.UndefinedProviderError): with self.assertRaises(errors.UndefinedProviderError):
CatalogB.get('undefined') CatalogB.get('undefined')
with self.assertRaises(di.UndefinedProviderError): with self.assertRaises(errors.UndefinedProviderError):
CatalogB.get_provider('undefined') CatalogB.get_provider('undefined')
with self.assertRaises(di.UndefinedProviderError): with self.assertRaises(errors.UndefinedProviderError):
CatalogB.undefined CatalogB.undefined
def test_has(self): def test_has(self):
@ -437,8 +440,8 @@ class DeclarativeCatalogTests(unittest.TestCase):
def test_filter_all_providers_by_type(self): def test_filter_all_providers_by_type(self):
"""Test getting of all catalog providers of specific type.""" """Test getting of all catalog providers of specific type."""
self.assertTrue(len(CatalogB.filter(di.Provider)) == 4) self.assertTrue(len(CatalogB.filter(providers.Provider)) == 4)
self.assertTrue(len(CatalogB.filter(di.Value)) == 0) self.assertTrue(len(CatalogB.filter(providers.Value)) == 0)
def test_repr(self): def test_repr(self):
"""Test catalog representation.""" """Test catalog representation."""
@ -454,7 +457,7 @@ class DeclarativeCatalogTests(unittest.TestCase):
def test_abstract_catalog_backward_compatibility(self): def test_abstract_catalog_backward_compatibility(self):
"""Test that di.AbstractCatalog is available.""" """Test that di.AbstractCatalog is available."""
self.assertIs(di.DeclarativeCatalog, di.AbstractCatalog) self.assertIs(catalogs.DeclarativeCatalog, catalogs.AbstractCatalog)
class OverrideTests(unittest.TestCase): class OverrideTests(unittest.TestCase):
@ -466,12 +469,12 @@ class OverrideTests(unittest.TestCase):
def test_overriding(self): def test_overriding(self):
"""Test catalog overriding with another catalog.""" """Test catalog overriding with another catalog."""
@di.override(CatalogA) @catalogs.override(CatalogA)
class OverridingCatalog(di.DeclarativeCatalog): class OverridingCatalog(catalogs.DeclarativeCatalog):
"""Overriding catalog.""" """Overriding catalog."""
p11 = di.Value(1) p11 = providers.Value(1)
p12 = di.Value(2) p12 = providers.Value(2)
self.assertEqual(CatalogA.p11(), 1) self.assertEqual(CatalogA.p11(), 1)
self.assertEqual(CatalogA.p12(), 2) self.assertEqual(CatalogA.p12(), 2)
@ -479,8 +482,8 @@ class OverrideTests(unittest.TestCase):
def test_overriding_with_dynamic_catalog(self): def test_overriding_with_dynamic_catalog(self):
"""Test catalog overriding with another dynamic catalog.""" """Test catalog overriding with another dynamic catalog."""
CatalogA.override(di.DynamicCatalog(p11=di.Value(1), CatalogA.override(catalogs.DynamicCatalog(p11=providers.Value(1),
p12=di.Value(2))) p12=providers.Value(2)))
self.assertEqual(CatalogA.p11(), 1) self.assertEqual(CatalogA.p11(), 1)
self.assertEqual(CatalogA.p12(), 2) self.assertEqual(CatalogA.p12(), 2)
self.assertEqual(len(CatalogA.overridden_by), 1) self.assertEqual(len(CatalogA.overridden_by), 1)
@ -489,44 +492,44 @@ class OverrideTests(unittest.TestCase):
"""Test catalog is_overridden property.""" """Test catalog is_overridden property."""
self.assertFalse(CatalogA.is_overridden) self.assertFalse(CatalogA.is_overridden)
@di.override(CatalogA) @catalogs.override(CatalogA)
class OverridingCatalog(di.DeclarativeCatalog): class OverridingCatalog(catalogs.DeclarativeCatalog):
"""Overriding catalog.""" """Overriding catalog."""
self.assertTrue(CatalogA.is_overridden) self.assertTrue(CatalogA.is_overridden)
def test_last_overriding(self): def test_last_overriding(self):
"""Test catalog last_overriding property.""" """Test catalog last_overriding property."""
@di.override(CatalogA) @catalogs.override(CatalogA)
class OverridingCatalog1(di.DeclarativeCatalog): class OverridingCatalog1(catalogs.DeclarativeCatalog):
"""Overriding catalog.""" """Overriding catalog."""
@di.override(CatalogA) @catalogs.override(CatalogA)
class OverridingCatalog2(di.DeclarativeCatalog): class OverridingCatalog2(catalogs.DeclarativeCatalog):
"""Overriding catalog.""" """Overriding catalog."""
self.assertIs(CatalogA.last_overriding, OverridingCatalog2) self.assertIs(CatalogA.last_overriding, OverridingCatalog2)
def test_last_overriding_on_not_overridden(self): def test_last_overriding_on_not_overridden(self):
"""Test catalog last_overriding property on not overridden catalog.""" """Test catalog last_overriding property on not overridden catalog."""
with self.assertRaises(di.Error): with self.assertRaises(errors.Error):
CatalogA.last_overriding CatalogA.last_overriding
def test_reset_last_overriding(self): def test_reset_last_overriding(self):
"""Test resetting last overriding catalog.""" """Test resetting last overriding catalog."""
@di.override(CatalogA) @catalogs.override(CatalogA)
class OverridingCatalog1(di.DeclarativeCatalog): class OverridingCatalog1(catalogs.DeclarativeCatalog):
"""Overriding catalog.""" """Overriding catalog."""
p11 = di.Value(1) p11 = providers.Value(1)
p12 = di.Value(2) p12 = providers.Value(2)
@di.override(CatalogA) @catalogs.override(CatalogA)
class OverridingCatalog2(di.DeclarativeCatalog): class OverridingCatalog2(catalogs.DeclarativeCatalog):
"""Overriding catalog.""" """Overriding catalog."""
p11 = di.Value(3) p11 = providers.Value(3)
p12 = di.Value(4) p12 = providers.Value(4)
CatalogA.reset_last_overriding() CatalogA.reset_last_overriding()
@ -535,24 +538,24 @@ class OverrideTests(unittest.TestCase):
def test_reset_last_overriding_when_not_overridden(self): def test_reset_last_overriding_when_not_overridden(self):
"""Test resetting last overriding catalog when it is not overridden.""" """Test resetting last overriding catalog when it is not overridden."""
with self.assertRaises(di.Error): with self.assertRaises(errors.Error):
CatalogA.reset_last_overriding() CatalogA.reset_last_overriding()
def test_reset_override(self): def test_reset_override(self):
"""Test resetting all catalog overrides.""" """Test resetting all catalog overrides."""
@di.override(CatalogA) @catalogs.override(CatalogA)
class OverridingCatalog1(di.DeclarativeCatalog): class OverridingCatalog1(catalogs.DeclarativeCatalog):
"""Overriding catalog.""" """Overriding catalog."""
p11 = di.Value(1) p11 = providers.Value(1)
p12 = di.Value(2) p12 = providers.Value(2)
@di.override(CatalogA) @catalogs.override(CatalogA)
class OverridingCatalog2(di.DeclarativeCatalog): class OverridingCatalog2(catalogs.DeclarativeCatalog):
"""Overriding catalog.""" """Overriding catalog."""
p11 = di.Value(3) p11 = providers.Value(3)
p12 = di.Value(4) p12 = providers.Value(4)
CatalogA.reset_override() CatalogA.reset_override()

13
tests/test_common.py Normal file
View File

@ -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)

90
tests/test_injections.py
View File

@ -1,7 +1,11 @@
"""Dependency injector injections unittests.""" """Dependency injector injections unittests."""
import unittest2 as unittest 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): class InjectionTests(unittest.TestCase):
@ -9,26 +13,27 @@ class InjectionTests(unittest.TestCase):
def test_init(self): def test_init(self):
"""Test Injection creation and initialization.""" """Test Injection creation and initialization."""
injection = di.Injection('some_value') injection = injections.Injection('some_value')
self.assertEqual(injection.injectable, 'some_value') self.assertEqual(injection.injectable, 'some_value')
def test_value_with_scalar_injectable(self): def test_value_with_scalar_injectable(self):
"""Test Injection value property with scalar value.""" """Test Injection value property with scalar value."""
injection = di.Injection('some_value') injection = injections.Injection('some_value')
self.assertEqual(injection.value, 'some_value') self.assertEqual(injection.value, 'some_value')
def test_value_with_provider_injectable(self): def test_value_with_provider_injectable(self):
"""Test Injection value property with provider.""" """Test Injection value property with provider."""
injection = di.Injection(di.Factory(object)) injection = injections.Injection(providers.Factory(object))
self.assertIsInstance(injection.value, object) self.assertIsInstance(injection.value, object)
def test_value_with_catalog_bundle_injectable(self): def test_value_with_catalog_bundle_injectable(self):
"""Test Injection value property with catalog bundle.""" """Test Injection value property with catalog bundle."""
class TestCatalog(di.AbstractCatalog): class TestCatalog(catalogs.DeclarativeCatalog):
"""Test catalog.""" """Test catalog."""
provider = di.Provider() provider = providers.Provider()
injection = di.Injection(TestCatalog.Bundle(TestCatalog.provider)) injection = injections.Injection(
TestCatalog.Bundle(TestCatalog.provider))
self.assertIsInstance(injection.value, TestCatalog.Bundle) self.assertIsInstance(injection.value, TestCatalog.Bundle)
@ -38,7 +43,7 @@ class ArgTests(unittest.TestCase):
def test_init(self): def test_init(self):
"""Test Arg creation and initialization.""" """Test Arg creation and initialization."""
injection = di.Arg('some_value') injection = injections.Arg('some_value')
self.assertEqual(injection.injectable, 'some_value') self.assertEqual(injection.injectable, 'some_value')
@ -47,7 +52,7 @@ class KwArgTests(unittest.TestCase):
def test_init(self): def test_init(self):
"""Test KwArg creation and initialization.""" """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.name, 'some_arg_name')
self.assertEqual(injection.injectable, 'some_value') self.assertEqual(injection.injectable, 'some_value')
@ -57,7 +62,7 @@ class AttributeTests(unittest.TestCase):
def test_init(self): def test_init(self):
"""Test Attribute creation and initialization.""" """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.name, 'some_arg_name')
self.assertEqual(injection.injectable, 'some_value') self.assertEqual(injection.injectable, 'some_value')
@ -67,7 +72,7 @@ class MethodTests(unittest.TestCase):
def test_init(self): def test_init(self):
"""Test Method creation and initialization.""" """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.name, 'some_arg_name')
self.assertEqual(injection.injectable, 'some_value') self.assertEqual(injection.injectable, 'some_value')
@ -77,10 +82,10 @@ class InjectTests(unittest.TestCase):
def test_decorated_args(self): def test_decorated_args(self):
"""Test `inject()` decoration with args.""" """Test `inject()` decoration with args."""
provider1 = di.Factory(object) provider1 = providers.Factory(object)
provider2 = di.Factory(list) provider2 = providers.Factory(list)
@di.inject(provider1, provider2) @injections.inject(provider1, provider2)
def test(a, b): def test(a, b):
return a, b return a, b
@ -97,10 +102,11 @@ class InjectTests(unittest.TestCase):
def test_decorated_args_extended_syntax(self): def test_decorated_args_extended_syntax(self):
"""Test `inject()` decoration with args.""" """Test `inject()` decoration with args."""
provider1 = di.Factory(object) provider1 = providers.Factory(object)
provider2 = di.Factory(list) provider2 = providers.Factory(list)
@di.inject(di.Arg(provider1), di.Arg(provider2)) @injections.inject(injections.Arg(provider1),
injections.Arg(provider2))
def test(a, b): def test(a, b):
return a, b return a, b
@ -117,11 +123,11 @@ class InjectTests(unittest.TestCase):
def test_decorated_args_several_times(self): def test_decorated_args_several_times(self):
"""Test `inject()` decoration with args several times.""" """Test `inject()` decoration with args several times."""
provider1 = di.Factory(object) provider1 = providers.Factory(object)
provider2 = di.Factory(list) provider2 = providers.Factory(list)
@di.inject(provider2) @injections.inject(provider2)
@di.inject(provider1) @injections.inject(provider1)
def test(a, b): def test(a, b):
return a, b return a, b
@ -138,10 +144,10 @@ class InjectTests(unittest.TestCase):
def test_decorated_context_args(self): def test_decorated_context_args(self):
"""Test `inject()` decoration with context args.""" """Test `inject()` decoration with context args."""
provider1 = di.Factory(object) provider1 = providers.Factory(object)
provider2 = di.Factory(list) provider2 = providers.Factory(list)
@di.inject(provider1) @injections.inject(provider1)
def test(a, b): def test(a, b):
return a, b return a, b
@ -158,11 +164,11 @@ class InjectTests(unittest.TestCase):
def test_decorated_kwargs(self): def test_decorated_kwargs(self):
"""Test `inject()` decoration with kwargs.""" """Test `inject()` decoration with kwargs."""
provider1 = di.Factory(object) provider1 = providers.Factory(object)
provider2 = di.Factory(list) provider2 = providers.Factory(list)
@di.inject(a=provider1) @injections.inject(a=provider1)
@di.inject(b=provider2) @injections.inject(b=provider2)
def test(a, b): def test(a, b):
return a, b return a, b
@ -179,12 +185,12 @@ class InjectTests(unittest.TestCase):
def test_decorated_kwargs_priority(self): def test_decorated_kwargs_priority(self):
"""Test `inject()` decorated callback kwargs priority.""" """Test `inject()` decorated callback kwargs priority."""
provider1 = di.Factory(object) provider1 = providers.Factory(object)
provider2 = di.Factory(list) provider2 = providers.Factory(list)
object_a = object() object_a = object()
@di.inject(a=provider1) @injections.inject(a=provider1)
@di.inject(b=provider2) @injections.inject(b=provider2)
def test(a, b): def test(a, b):
return a, b return a, b
@ -202,10 +208,10 @@ class InjectTests(unittest.TestCase):
def test_decorated_with_args(self): def test_decorated_with_args(self):
"""Test `inject()` decorated callback with args.""" """Test `inject()` decorated callback with args."""
provider = di.Factory(list) provider = providers.Factory(list)
object_a = object() object_a = object()
@di.inject(b=provider) @injections.inject(b=provider)
def test(a, b): def test(a, b):
return a, b return a, b
@ -223,10 +229,10 @@ class InjectTests(unittest.TestCase):
def test_injection_kwarg_syntax(self): def test_injection_kwarg_syntax(self):
"""Test `inject()` decorated callback with "old" style using KwArg.""" """Test `inject()` decorated callback with "old" style using KwArg."""
provider = di.Factory(list) provider = providers.Factory(list)
object_a = object() object_a = object()
@di.inject(di.KwArg('b', provider)) @injections.inject(injections.KwArg('b', provider))
def test(a, b): def test(a, b):
return a, b return a, b
@ -247,8 +253,8 @@ class InjectTests(unittest.TestCase):
class Test(object): class Test(object):
"""Test class.""" """Test class."""
@di.inject(arg1=123) @injections.inject(arg1=123)
@di.inject(arg2=456) @injections.inject(arg2=456)
def some_method(self, arg1, arg2): def some_method(self, arg1, arg2):
"""Some test method.""" """Some test method."""
return arg1, arg2 return arg1, arg2
@ -261,8 +267,8 @@ class InjectTests(unittest.TestCase):
def test_decorate_class_with_init(self): def test_decorate_class_with_init(self):
"""Test `inject()` decorator that decorate class with __init__.""" """Test `inject()` decorator that decorate class with __init__."""
@di.inject(arg1=123) @injections.inject(arg1=123)
@di.inject(arg2=456) @injections.inject(arg2=456)
class Test(object): class Test(object):
"""Test class.""" """Test class."""
@ -278,7 +284,7 @@ class InjectTests(unittest.TestCase):
def test_decorate_class_without_init(self): def test_decorate_class_without_init(self):
"""Test `inject()` decorator that decorate class without __init__.""" """Test `inject()` decorator that decorate class without __init__."""
with self.assertRaises(di.Error): with self.assertRaises(errors.Error):
@di.inject(arg1=123) @injections.inject(arg1=123)
class Test(object): class Test(object):
"""Test class.""" """Test class."""

286
tests/test_providers.py
View File

@ -1,7 +1,11 @@
"""Dependency injector providers unittests.""" """Dependency injector providers unittests."""
import unittest2 as unittest 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): class Example(object):
@ -35,11 +39,11 @@ class ProviderTests(unittest.TestCase):
def setUp(self): def setUp(self):
"""Set test cases environment up.""" """Set test cases environment up."""
self.provider = di.Provider() self.provider = providers.Provider()
def test_is_provider(self): def test_is_provider(self):
"""Test `is_provider` check.""" """Test `is_provider` check."""
self.assertTrue(di.is_provider(self.provider)) self.assertTrue(utils.is_provider(self.provider))
def test_call(self): def test_call(self):
"""Test call.""" """Test call."""
@ -49,34 +53,34 @@ class ProviderTests(unittest.TestCase):
"""Test creating of provider delegation.""" """Test creating of provider delegation."""
delegate1 = self.provider.delegate() delegate1 = self.provider.delegate()
self.assertIsInstance(delegate1, di.Delegate) self.assertIsInstance(delegate1, providers.Delegate)
self.assertIs(delegate1(), self.provider) self.assertIs(delegate1(), self.provider)
delegate2 = self.provider.delegate() delegate2 = self.provider.delegate()
self.assertIsInstance(delegate2, di.Delegate) self.assertIsInstance(delegate2, providers.Delegate)
self.assertIs(delegate2(), self.provider) self.assertIs(delegate2(), self.provider)
self.assertIsNot(delegate1, delegate2) self.assertIsNot(delegate1, delegate2)
def test_override(self): def test_override(self):
"""Test provider overriding.""" """Test provider overriding."""
overriding_provider = di.Provider() overriding_provider = providers.Provider()
self.provider.override(overriding_provider) self.provider.override(overriding_provider)
self.assertTrue(self.provider.is_overridden) self.assertTrue(self.provider.is_overridden)
def test_override_with_itself(self): def test_override_with_itself(self):
"""Test provider overriding with itself.""" """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): def test_override_with_not_provider(self):
"""Test provider overriding with not provider instance.""" """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): def test_last_overriding(self):
"""Test getting last overriding provider.""" """Test getting last overriding provider."""
overriding_provider1 = di.Provider() overriding_provider1 = providers.Provider()
overriding_provider2 = di.Provider() overriding_provider2 = providers.Provider()
self.provider.override(overriding_provider1) self.provider.override(overriding_provider1)
self.assertIs(self.provider.last_overriding, 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.""" """Test getting last overriding from not overridden provider."""
try: try:
self.provider.last_overriding self.provider.last_overriding
except di.Error: except errors.Error:
pass pass
else: else:
self.fail('Got en error in {}'.format( self.fail('Got en error in {}'.format(
@ -96,8 +100,8 @@ class ProviderTests(unittest.TestCase):
def test_reset_last_overriding(self): def test_reset_last_overriding(self):
"""Test reseting of last overriding provider.""" """Test reseting of last overriding provider."""
overriding_provider1 = di.Provider() overriding_provider1 = providers.Provider()
overriding_provider2 = di.Provider() overriding_provider2 = providers.Provider()
self.provider.override(overriding_provider1) self.provider.override(overriding_provider1)
self.provider.override(overriding_provider2) self.provider.override(overriding_provider2)
@ -112,11 +116,11 @@ class ProviderTests(unittest.TestCase):
def test_reset_last_overriding_of_not_overridden_provider(self): def test_reset_last_overriding_of_not_overridden_provider(self):
"""Test resetting of last overriding on not overridden provier.""" """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): def test_reset_override(self):
"""Test reset of provider's override.""" """Test reset of provider's override."""
overriding_provider = di.Provider() overriding_provider = providers.Provider()
self.provider.override(overriding_provider) self.provider.override(overriding_provider)
self.assertTrue(self.provider.is_overridden) self.assertTrue(self.provider.is_overridden)
@ -127,7 +131,7 @@ class ProviderTests(unittest.TestCase):
self.assertFalse(self.provider.is_overridden) self.assertFalse(self.provider.is_overridden)
try: try:
self.provider.last_overriding self.provider.last_overriding
except di.Error: except errors.Error:
pass pass
else: else:
self.fail('Got en error in {}'.format( self.fail('Got en error in {}'.format(
@ -139,16 +143,16 @@ class DelegateTests(unittest.TestCase):
def setUp(self): def setUp(self):
"""Set test cases environment up.""" """Set test cases environment up."""
self.delegated = di.Provider() self.delegated = providers.Provider()
self.delegate = di.Delegate(delegated=self.delegated) self.delegate = providers.Delegate(delegated=self.delegated)
def test_is_provider(self): def test_is_provider(self):
"""Test `is_provider` check.""" """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): def test_init_with_not_provider(self):
"""Test that delegate accepts only another provider as delegated.""" """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): def test_call(self):
"""Test returning of delegated provider.""" """Test returning of delegated provider."""
@ -164,19 +168,19 @@ class FactoryTests(unittest.TestCase):
def test_is_provider(self): def test_is_provider(self):
"""Test `is_provider` check.""" """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): def test_init_with_callable(self):
"""Test creation of provider with a callable.""" """Test creation of provider with a callable."""
self.assertTrue(di.Factory(credits)) self.assertTrue(providers.Factory(credits))
def test_init_with_not_callable(self): def test_init_with_not_callable(self):
"""Test creation of provider with not a callable.""" """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): def test_call(self):
"""Test creation of new instances.""" """Test creation of new instances."""
provider = di.Factory(Example) provider = providers.Factory(Example)
instance1 = provider() instance1 = provider()
instance2 = provider() instance2 = provider()
@ -189,7 +193,7 @@ class FactoryTests(unittest.TestCase):
New simplified syntax. New simplified syntax.
""" """
provider = di.Factory(Example, 'i1', 'i2') provider = providers.Factory(Example, 'i1', 'i2')
instance1 = provider() instance1 = provider()
instance2 = provider() instance2 = provider()
@ -209,7 +213,7 @@ class FactoryTests(unittest.TestCase):
New simplified syntax. 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() instance1 = provider()
instance2 = provider() instance2 = provider()
@ -229,7 +233,7 @@ class FactoryTests(unittest.TestCase):
Simplified syntax of positional and keyword arg injections. 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() instance1 = provider()
instance2 = provider() instance2 = provider()
@ -249,9 +253,9 @@ class FactoryTests(unittest.TestCase):
Extended syntax of positional and keyword arg injections. Extended syntax of positional and keyword arg injections.
""" """
provider = di.Factory(Example, provider = providers.Factory(Example,
di.Arg('i1'), injections.Arg('i1'),
di.KwArg('init_arg2', 'i2')) injections.KwArg('init_arg2', 'i2'))
instance1 = provider() instance1 = provider()
instance2 = provider() instance2 = provider()
@ -268,9 +272,9 @@ class FactoryTests(unittest.TestCase):
def test_call_with_attributes(self): def test_call_with_attributes(self):
"""Test creation of new instances with attribute injections.""" """Test creation of new instances with attribute injections."""
provider = di.Factory(Example, provider = providers.Factory(Example,
di.Attribute('attribute1', 'a1'), injections.Attribute('attribute1', 'a1'),
di.Attribute('attribute2', 'a2')) injections.Attribute('attribute2', 'a2'))
instance1 = provider() instance1 = provider()
instance2 = provider() instance2 = provider()
@ -287,9 +291,9 @@ class FactoryTests(unittest.TestCase):
def test_call_with_methods(self): def test_call_with_methods(self):
"""Test creation of new instances with method injections.""" """Test creation of new instances with method injections."""
provider = di.Factory(Example, provider = providers.Factory(Example,
di.Method('method1', 'm1'), injections.Method('method1', 'm1'),
di.Method('method2', 'm2')) injections.Method('method2', 'm2'))
instance1 = provider() instance1 = provider()
instance2 = provider() instance2 = provider()
@ -306,7 +310,7 @@ class FactoryTests(unittest.TestCase):
def test_call_with_context_args(self): def test_call_with_context_args(self):
"""Test creation of new instances with context args.""" """Test creation of new instances with context args."""
provider = di.Factory(Example, 11, 22) provider = providers.Factory(Example, 11, 22)
instance = provider(33, 44) instance = provider(33, 44)
self.assertEqual(instance.init_arg1, 11) self.assertEqual(instance.init_arg1, 11)
@ -316,8 +320,8 @@ class FactoryTests(unittest.TestCase):
def test_call_with_context_kwargs(self): def test_call_with_context_kwargs(self):
"""Test creation of new instances with context kwargs.""" """Test creation of new instances with context kwargs."""
provider = di.Factory(Example, provider = providers.Factory(Example,
di.KwArg('init_arg1', 1)) injections.KwArg('init_arg1', 1))
instance1 = provider(init_arg2=22) instance1 = provider(init_arg2=22)
self.assertEqual(instance1.init_arg1, 1) self.assertEqual(instance1.init_arg1, 1)
@ -329,7 +333,7 @@ class FactoryTests(unittest.TestCase):
def test_call_with_context_args_and_kwargs(self): def test_call_with_context_args_and_kwargs(self):
"""Test creation of new instances with context args and kwargs.""" """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) instance = provider(22, init_arg3=33, init_arg4=44)
self.assertEqual(instance.init_arg1, 11) self.assertEqual(instance.init_arg1, 11)
@ -339,9 +343,9 @@ class FactoryTests(unittest.TestCase):
def test_call_overridden(self): def test_call_overridden(self):
"""Test creation of new instances on overridden provider.""" """Test creation of new instances on overridden provider."""
provider = di.Factory(Example) provider = providers.Factory(Example)
overriding_provider1 = di.Factory(dict) overriding_provider1 = providers.Factory(dict)
overriding_provider2 = di.Factory(list) overriding_provider2 = providers.Factory(list)
provider.override(overriding_provider1) provider.override(overriding_provider1)
provider.override(overriding_provider2) provider.override(overriding_provider2)
@ -355,17 +359,14 @@ class FactoryTests(unittest.TestCase):
def test_injections(self): def test_injections(self):
"""Test getting a full list of injections using injections property.""" """Test getting a full list of injections using injections property."""
provider = di.Factory(Example, provider = providers.Factory(Example,
di.Arg(1), injections.Arg(1),
di.KwArg('init_arg2', 2), injections.KwArg('init_arg2', 2),
di.Attribute('attribute1', 3), injections.Attribute('attribute1', 3),
di.Attribute('attribute2', 4), injections.Attribute('attribute2', 4),
di.Method('method1', 5), injections.Method('method1', 5),
di.Method('method2', 6)) injections.Method('method2', 6))
self.assertEquals(len(provider.injections), 6)
injections = provider.injections
self.assertEquals(len(injections), 6)
class SingletonTests(unittest.TestCase): class SingletonTests(unittest.TestCase):
@ -373,19 +374,19 @@ class SingletonTests(unittest.TestCase):
def test_is_provider(self): def test_is_provider(self):
"""Test `is_provider` check.""" """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): def test_init_with_callable(self):
"""Test creation of provider with a callable.""" """Test creation of provider with a callable."""
self.assertTrue(di.Singleton(credits)) self.assertTrue(providers.Singleton(credits))
def test_init_with_not_callable(self): def test_init_with_not_callable(self):
"""Test creation of provider with not a callable.""" """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): def test_call(self):
"""Test getting of instances.""" """Test getting of instances."""
provider = di.Singleton(Example) provider = providers.Singleton(Example)
instance1 = provider() instance1 = provider()
instance2 = provider() instance2 = provider()
@ -398,7 +399,7 @@ class SingletonTests(unittest.TestCase):
New simplified syntax. New simplified syntax.
""" """
provider = di.Singleton(Example, 'i1', 'i2') provider = providers.Singleton(Example, 'i1', 'i2')
instance1 = provider() instance1 = provider()
instance2 = provider() instance2 = provider()
@ -418,7 +419,7 @@ class SingletonTests(unittest.TestCase):
New simplified syntax. 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() instance1 = provider()
instance2 = provider() instance2 = provider()
@ -438,7 +439,7 @@ class SingletonTests(unittest.TestCase):
Simplified syntax of positional and keyword arg injections. 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() instance1 = provider()
instance2 = provider() instance2 = provider()
@ -458,9 +459,9 @@ class SingletonTests(unittest.TestCase):
Extended syntax of positional and keyword arg injections. Extended syntax of positional and keyword arg injections.
""" """
provider = di.Singleton(Example, provider = providers.Singleton(Example,
di.Arg('i1'), injections.Arg('i1'),
di.KwArg('init_arg2', 'i2')) injections.KwArg('init_arg2', 'i2'))
instance1 = provider() instance1 = provider()
instance2 = provider() instance2 = provider()
@ -477,9 +478,11 @@ class SingletonTests(unittest.TestCase):
def test_call_with_attributes(self): def test_call_with_attributes(self):
"""Test getting of instances with attribute injections.""" """Test getting of instances with attribute injections."""
provider = di.Singleton(Example, provider = providers.Singleton(Example,
di.Attribute('attribute1', 'a1'), injections.Attribute('attribute1',
di.Attribute('attribute2', 'a2')) 'a1'),
injections.Attribute('attribute2',
'a2'))
instance1 = provider() instance1 = provider()
instance2 = provider() instance2 = provider()
@ -496,9 +499,9 @@ class SingletonTests(unittest.TestCase):
def test_call_with_methods(self): def test_call_with_methods(self):
"""Test getting of instances with method injections.""" """Test getting of instances with method injections."""
provider = di.Singleton(Example, provider = providers.Singleton(Example,
di.Method('method1', 'm1'), injections.Method('method1', 'm1'),
di.Method('method2', 'm2')) injections.Method('method2', 'm2'))
instance1 = provider() instance1 = provider()
instance2 = provider() instance2 = provider()
@ -515,7 +518,7 @@ class SingletonTests(unittest.TestCase):
def test_call_with_context_args(self): def test_call_with_context_args(self):
"""Test getting of instances with context args.""" """Test getting of instances with context args."""
provider = di.Singleton(Example) provider = providers.Singleton(Example)
instance = provider(11, 22) instance = provider(11, 22)
self.assertEqual(instance.init_arg1, 11) self.assertEqual(instance.init_arg1, 11)
@ -523,8 +526,8 @@ class SingletonTests(unittest.TestCase):
def test_call_with_context_kwargs(self): def test_call_with_context_kwargs(self):
"""Test getting of instances with context kwargs.""" """Test getting of instances with context kwargs."""
provider = di.Singleton(Example, provider = providers.Singleton(Example,
di.KwArg('init_arg1', 1)) injections.KwArg('init_arg1', 1))
instance1 = provider(init_arg2=22) instance1 = provider(init_arg2=22)
self.assertEqual(instance1.init_arg1, 1) self.assertEqual(instance1.init_arg1, 1)
@ -537,7 +540,7 @@ class SingletonTests(unittest.TestCase):
def test_call_with_context_args_and_kwargs(self): def test_call_with_context_args_and_kwargs(self):
"""Test getting of instances with context args and kwargs.""" """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) instance = provider(22, init_arg3=33, init_arg4=44)
self.assertEqual(instance.init_arg1, 11) self.assertEqual(instance.init_arg1, 11)
@ -547,9 +550,9 @@ class SingletonTests(unittest.TestCase):
def test_call_overridden(self): def test_call_overridden(self):
"""Test getting of instances on overridden provider.""" """Test getting of instances on overridden provider."""
provider = di.Singleton(Example) provider = providers.Singleton(Example)
overriding_provider1 = di.Singleton(dict) overriding_provider1 = providers.Singleton(dict)
overriding_provider2 = di.Singleton(object) overriding_provider2 = providers.Singleton(object)
provider.override(overriding_provider1) provider.override(overriding_provider1)
provider.override(overriding_provider2) provider.override(overriding_provider2)
@ -563,21 +566,18 @@ class SingletonTests(unittest.TestCase):
def test_injections(self): def test_injections(self):
"""Test getting a full list of injections using injections property.""" """Test getting a full list of injections using injections property."""
provider = di.Singleton(Example, provider = providers.Singleton(Example,
di.Arg(1), injections.Arg(1),
di.KwArg('init_arg2', 2), injections.KwArg('init_arg2', 2),
di.Attribute('attribute1', 3), injections.Attribute('attribute1', 3),
di.Attribute('attribute2', 4), injections.Attribute('attribute2', 4),
di.Method('method1', 5), injections.Method('method1', 5),
di.Method('method2', 6)) injections.Method('method2', 6))
self.assertEquals(len(provider.injections), 6)
injections = provider.injections
self.assertEquals(len(injections), 6)
def test_reset(self): def test_reset(self):
"""Test creation and reset of single object.""" """Test creation and reset of single object."""
provider = di.Singleton(object) provider = providers.Singleton(object)
instance1 = provider() instance1 = provider()
self.assertIsInstance(instance1, object) self.assertIsInstance(instance1, object)
@ -595,29 +595,29 @@ class ExternalDependencyTests(unittest.TestCase):
def setUp(self): def setUp(self):
"""Set test cases environment up.""" """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): def test_init_with_not_class(self):
"""Test creation with not a class.""" """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): def test_is_provider(self):
"""Test `is_provider` check.""" """Test `is_provider` check."""
self.assertTrue(di.is_provider(self.provider)) self.assertTrue(utils.is_provider(self.provider))
def test_call_overridden(self): def test_call_overridden(self):
"""Test call of overridden external dependency.""" """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) self.assertIsInstance(self.provider(), list)
def test_call_overridden_but_not_instance_of(self): def test_call_overridden_but_not_instance_of(self):
"""Test call of overridden external dependency, but not instance of.""" """Test call of overridden external dependency, but not instance of."""
self.provider.provided_by(di.Factory(dict)) self.provider.provided_by(providers.Factory(dict))
self.assertRaises(di.Error, self.provider) self.assertRaises(errors.Error, self.provider)
def test_call_not_overridden(self): def test_call_not_overridden(self):
"""Test call of not satisfied external dependency.""" """Test call of not satisfied external dependency."""
self.assertRaises(di.Error, self.provider) self.assertRaises(errors.Error, self.provider)
class StaticProvidersTests(unittest.TestCase): class StaticProvidersTests(unittest.TestCase):
@ -625,52 +625,52 @@ class StaticProvidersTests(unittest.TestCase):
def test_is_provider(self): def test_is_provider(self):
"""Test `is_provider` check.""" """Test `is_provider` check."""
self.assertTrue(di.is_provider(di.Class(object))) self.assertTrue(utils.is_provider(providers.Class(object)))
self.assertTrue(di.is_provider(di.Object(object()))) self.assertTrue(utils.is_provider(providers.Object(object())))
self.assertTrue(di.is_provider(di.Function(map))) self.assertTrue(utils.is_provider(providers.Function(map)))
self.assertTrue(di.is_provider(di.Value(123))) self.assertTrue(utils.is_provider(providers.Value(123)))
def test_call_class_provider(self): def test_call_class_provider(self):
"""Test Class provider call.""" """Test Class provider call."""
self.assertIs(di.Class(dict)(), dict) self.assertIs(providers.Class(dict)(), dict)
def test_call_object_provider(self): def test_call_object_provider(self):
"""Test Object provider call.""" """Test Object provider call."""
obj = object() obj = object()
self.assertIs(di.Object(obj)(), obj) self.assertIs(providers.Object(obj)(), obj)
def test_call_function_provider(self): def test_call_function_provider(self):
"""Test Function provider call.""" """Test Function provider call."""
self.assertIs(di.Function(map)(), map) self.assertIs(providers.Function(map)(), map)
def test_call_value_provider(self): def test_call_value_provider(self):
"""Test Value provider call.""" """Test Value provider call."""
self.assertEqual(di.Value(123)(), 123) self.assertEqual(providers.Value(123)(), 123)
def test_call_overridden_class_provider(self): def test_call_overridden_class_provider(self):
"""Test overridden Class provider call.""" """Test overridden Class provider call."""
cls_provider = di.Class(dict) cls_provider = providers.Class(dict)
cls_provider.override(di.Object(list)) cls_provider.override(providers.Object(list))
self.assertIs(cls_provider(), list) self.assertIs(cls_provider(), list)
def test_call_overridden_object_provider(self): def test_call_overridden_object_provider(self):
"""Test overridden Object provider call.""" """Test overridden Object provider call."""
obj1 = object() obj1 = object()
obj2 = object() obj2 = object()
obj_provider = di.Object(obj1) obj_provider = providers.Object(obj1)
obj_provider.override(di.Object(obj2)) obj_provider.override(providers.Object(obj2))
self.assertIs(obj_provider(), obj2) self.assertIs(obj_provider(), obj2)
def test_call_overridden_function_provider(self): def test_call_overridden_function_provider(self):
"""Test overridden Function provider call.""" """Test overridden Function provider call."""
function_provider = di.Function(len) function_provider = providers.Function(len)
function_provider.override(di.Function(sum)) function_provider.override(providers.Function(sum))
self.assertIs(function_provider(), sum) self.assertIs(function_provider(), sum)
def test_call_overridden_value_provider(self): def test_call_overridden_value_provider(self):
"""Test overridden Value provider call.""" """Test overridden Value provider call."""
value_provider = di.Value(123) value_provider = providers.Value(123)
value_provider.override(di.Value(321)) value_provider.override(providers.Value(321))
self.assertEqual(value_provider(), 321) self.assertEqual(value_provider(), 321)
@ -683,15 +683,15 @@ class CallableTests(unittest.TestCase):
def test_init_with_callable(self): def test_init_with_callable(self):
"""Test creation of provider with a callable.""" """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): def test_init_with_not_callable(self):
"""Test creation of provider with not a callable.""" """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): def test_call(self):
"""Test call.""" """Test call."""
provider = di.Callable(lambda: True) provider = providers.Callable(lambda: True)
self.assertTrue(provider()) self.assertTrue(provider())
def test_call_with_positional_args(self): def test_call_with_positional_args(self):
@ -699,7 +699,7 @@ class CallableTests(unittest.TestCase):
New simplified syntax. 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)) self.assertTupleEqual(provider(), (1, 2, 3, 4))
def test_call_with_keyword_args(self): def test_call_with_keyword_args(self):
@ -707,7 +707,11 @@ class CallableTests(unittest.TestCase):
New simplified syntax. 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)) self.assertTupleEqual(provider(), (1, 2, 3, 4))
def test_call_with_positional_and_keyword_args(self): 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. 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)) self.assertTupleEqual(provider(), (1, 2, 3, 4))
def test_call_with_positional_and_keyword_args_extended_syntax(self): 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. Extended syntax of positional and keyword arg injections.
""" """
provider = di.Callable(self.example, provider = providers.Callable(self.example,
di.Arg(1), injections.Arg(1),
di.Arg(2), injections.Arg(2),
di.KwArg('arg3', 3), injections.KwArg('arg3', 3),
di.KwArg('arg4', 4)) injections.KwArg('arg4', 4))
self.assertTupleEqual(provider(), (1, 2, 3, 4)) self.assertTupleEqual(provider(), (1, 2, 3, 4))
def test_call_with_context_args(self): def test_call_with_context_args(self):
"""Test call with context args.""" """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)) self.assertTupleEqual(provider(3, 4), (1, 2, 3, 4))
def test_call_with_context_kwargs(self): def test_call_with_context_kwargs(self):
"""Test call with context kwargs.""" """Test call with context kwargs."""
provider = di.Callable(self.example, provider = providers.Callable(self.example,
di.KwArg('arg1', 1)) injections.KwArg('arg1', 1))
self.assertTupleEqual(provider(arg2=2, arg3=3, arg4=4), (1, 2, 3, 4)) self.assertTupleEqual(provider(arg2=2, arg3=3, arg4=4), (1, 2, 3, 4))
def test_call_with_context_args_and_kwargs(self): def test_call_with_context_args_and_kwargs(self):
"""Test call with context args and kwargs.""" """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)) self.assertTupleEqual(provider(2, arg3=3, arg4=4), (1, 2, 3, 4))
def test_call_overridden(self): def test_call_overridden(self):
"""Test creation of new instances on overridden provider.""" """Test creation of new instances on overridden provider."""
provider = di.Callable(self.example) provider = providers.Callable(self.example)
provider.override(di.Value((4, 3, 2, 1))) provider.override(providers.Value((4, 3, 2, 1)))
provider.override(di.Value((1, 2, 3, 4))) provider.override(providers.Value((1, 2, 3, 4)))
self.assertTupleEqual(provider(), (1, 2, 3, 4)) self.assertTupleEqual(provider(), (1, 2, 3, 4))
def test_injections(self): def test_injections(self):
"""Test getting a full list of injections using injections property.""" """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) self.assertEquals(len(provider.injections), 4)
@ -767,15 +771,15 @@ class ConfigTests(unittest.TestCase):
"""Set test cases environment up.""" """Set test cases environment up."""
self.initial_data = dict(key='value', self.initial_data = dict(key='value',
category=dict(setting='setting_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): def test_is_provider(self):
"""Test `is_provider` check.""" """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): def test_init_without_initial_value(self):
"""Test provider's creation with no initial value.""" """Test provider's creation with no initial value."""
self.assertEqual(di.Config()(), dict()) self.assertEqual(providers.Config()(), dict())
def test_call(self): def test_call(self):
"""Test returning of config value.""" """Test returning of config value."""
@ -794,8 +798,8 @@ class ConfigTests(unittest.TestCase):
category = self.provider.category category = self.provider.category
category_setting = self.provider.category.setting category_setting = self.provider.category.setting
self.assertTrue(di.is_provider(category)) self.assertTrue(utils.is_provider(category))
self.assertTrue(di.is_provider(category_setting)) self.assertTrue(utils.is_provider(category_setting))
self.assertEqual(category(), self.initial_data['category']) self.assertEqual(category(), self.initial_data['category'])
self.assertEqual(category_setting(), self.assertEqual(category_setting(),
@ -803,12 +807,12 @@ class ConfigTests(unittest.TestCase):
def test_call_deferred_child_and_update_from(self): def test_call_deferred_child_and_update_from(self):
"""Test returning of deferred child config values.""" """Test returning of deferred child config values."""
self.provider = di.Config() self.provider = providers.Config()
category = self.provider.category category = self.provider.category
category_setting = self.provider.category.setting category_setting = self.provider.category.setting
self.assertTrue(di.is_provider(category)) self.assertTrue(utils.is_provider(category))
self.assertTrue(di.is_provider(category_setting)) self.assertTrue(utils.is_provider(category_setting))
self.provider.update_from(self.initial_data) self.provider.update_from(self.initial_data)
@ -818,6 +822,6 @@ class ConfigTests(unittest.TestCase):
def test_call_deferred_child_with_empty_value(self): def test_call_deferred_child_with_empty_value(self):
"""Test returning of deferred child config values.""" """Test returning of deferred child config values."""
self.provider = di.Config() self.provider = providers.Config()
category_setting = self.provider.category.setting category_setting = self.provider.category.setting
self.assertRaises(di.Error, category_setting) self.assertRaises(errors.Error, category_setting)

161
tests/test_utils.py
View File

@ -1,7 +1,12 @@
"""Dependency injector utils unittests.""" """Dependency injector utils unittests."""
import unittest2 as unittest 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): class IsProviderTests(unittest.TestCase):
@ -9,26 +14,26 @@ class IsProviderTests(unittest.TestCase):
def test_with_instance(self): def test_with_instance(self):
"""Test with instance.""" """Test with instance."""
self.assertTrue(di.is_provider(di.Provider())) self.assertTrue(utils.is_provider(providers.Provider()))
def test_with_class(self): def test_with_class(self):
"""Test with class.""" """Test with class."""
self.assertFalse(di.is_provider(di.Provider)) self.assertFalse(utils.is_provider(providers.Provider))
def test_with_string(self): def test_with_string(self):
"""Test with string.""" """Test with string."""
self.assertFalse(di.is_provider('some_string')) self.assertFalse(utils.is_provider('some_string'))
def test_with_object(self): def test_with_object(self):
"""Test with object.""" """Test with object."""
self.assertFalse(di.is_provider(object())) self.assertFalse(utils.is_provider(object()))
def test_with_subclass_instance(self): def test_with_subclass_instance(self):
"""Test with subclass of provider instance.""" """Test with subclass of provider instance."""
class SomeProvider(di.Provider): class SomeProvider(providers.Provider):
"""Some provider for test.""" """Some provider for test."""
self.assertTrue(di.is_provider(SomeProvider())) self.assertTrue(utils.is_provider(SomeProvider()))
def test_with_class_with_getattr(self): def test_with_class_with_getattr(self):
"""Test with class that has __getattr__() method implementation.""" """Test with class that has __getattr__() method implementation."""
@ -39,7 +44,7 @@ class IsProviderTests(unittest.TestCase):
"""Test implementation that just returns False.""" """Test implementation that just returns False."""
return False return False
self.assertFalse(di.is_provider(SomeClass())) self.assertFalse(utils.is_provider(SomeClass()))
class EnsureIsProviderTests(unittest.TestCase): class EnsureIsProviderTests(unittest.TestCase):
@ -47,20 +52,24 @@ class EnsureIsProviderTests(unittest.TestCase):
def test_with_instance(self): def test_with_instance(self):
"""Test with instance.""" """Test with instance."""
provider = di.Provider() provider = providers.Provider()
self.assertIs(di.ensure_is_provider(provider), provider) self.assertIs(utils.ensure_is_provider(provider), provider)
def test_with_class(self): def test_with_class(self):
"""Test with class.""" """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): def test_with_string(self):
"""Test with string.""" """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): def test_with_object(self):
"""Test with object.""" """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): class IsInjectionTests(unittest.TestCase):
@ -68,26 +77,29 @@ class IsInjectionTests(unittest.TestCase):
def test_with_instance(self): def test_with_instance(self):
"""Test with instance.""" """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): def test_with_subclass_instances(self):
"""Test with subclass instances.""" """Test with subclass instances."""
self.assertTrue(di.is_injection(di.Arg('value'))) self.assertTrue(utils.is_injection(injections.Arg('value')))
self.assertTrue(di.is_injection(di.KwArg('name', 'value'))) self.assertTrue(utils.is_injection(injections.KwArg('name',
self.assertTrue(di.is_injection(di.Attribute('name', 'value'))) 'value')))
self.assertTrue(di.is_injection(di.Method('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): def test_with_class(self):
"""Test with class.""" """Test with class."""
self.assertFalse(di.is_injection(di.Injection)) self.assertFalse(utils.is_injection(injections.Injection))
def test_with_string(self): def test_with_string(self):
"""Test with string.""" """Test with string."""
self.assertFalse(di.is_injection('some_string')) self.assertFalse(utils.is_injection('some_string'))
def test_with_object(self): def test_with_object(self):
"""Test with object.""" """Test with object."""
self.assertFalse(di.is_injection(object())) self.assertFalse(utils.is_injection(object()))
class EnsureIsInjectionTests(unittest.TestCase): class EnsureIsInjectionTests(unittest.TestCase):
@ -95,20 +107,26 @@ class EnsureIsInjectionTests(unittest.TestCase):
def test_with_instance(self): def test_with_instance(self):
"""Test with instance.""" """Test with instance."""
injection = di.Injection('value') injection = injections.Injection('value')
self.assertIs(di.ensure_is_injection(injection), injection) self.assertIs(utils.ensure_is_injection(injection), injection)
def test_with_class(self): def test_with_class(self):
"""Test with class.""" """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): def test_with_string(self):
"""Test with string.""" """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): def test_with_object(self):
"""Test with object.""" """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): class IsArgInjectionTests(unittest.TestCase):
@ -116,23 +134,23 @@ class IsArgInjectionTests(unittest.TestCase):
def test_with_instance(self): def test_with_instance(self):
"""Test with instance.""" """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): def test_with_class(self):
"""Test with class.""" """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): def test_with_parent_class(self):
"""Test with parent class.""" """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): def test_with_string(self):
"""Test with string.""" """Test with string."""
self.assertFalse(di.is_arg_injection('some_string')) self.assertFalse(utils.is_arg_injection('some_string'))
def test_with_object(self): def test_with_object(self):
"""Test with object.""" """Test with object."""
self.assertFalse(di.is_arg_injection(object())) self.assertFalse(utils.is_arg_injection(object()))
class IsKwArgInjectionTests(unittest.TestCase): class IsKwArgInjectionTests(unittest.TestCase):
@ -140,23 +158,24 @@ class IsKwArgInjectionTests(unittest.TestCase):
def test_with_instance(self): def test_with_instance(self):
"""Test with instance.""" """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): def test_with_class(self):
"""Test with class.""" """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): def test_with_parent_class(self):
"""Test with parent class.""" """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): def test_with_string(self):
"""Test with string.""" """Test with string."""
self.assertFalse(di.is_kwarg_injection('some_string')) self.assertFalse(utils.is_kwarg_injection('some_string'))
def test_with_object(self): def test_with_object(self):
"""Test with object.""" """Test with object."""
self.assertFalse(di.is_kwarg_injection(object())) self.assertFalse(utils.is_kwarg_injection(object()))
class IsAttributeInjectionTests(unittest.TestCase): class IsAttributeInjectionTests(unittest.TestCase):
@ -164,24 +183,24 @@ class IsAttributeInjectionTests(unittest.TestCase):
def test_with_instance(self): def test_with_instance(self):
"""Test with instance.""" """Test with instance."""
self.assertTrue(di.is_attribute_injection(di.Attribute('name', self.assertTrue(utils.is_attribute_injection(
'value'))) injections.Attribute('name', 'value')))
def test_with_class(self): def test_with_class(self):
"""Test with class.""" """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): def test_with_parent_class(self):
"""Test with parent class.""" """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): def test_with_string(self):
"""Test with string.""" """Test with string."""
self.assertFalse(di.is_attribute_injection('some_string')) self.assertFalse(utils.is_attribute_injection('some_string'))
def test_with_object(self): def test_with_object(self):
"""Test with object.""" """Test with object."""
self.assertFalse(di.is_attribute_injection(object())) self.assertFalse(utils.is_attribute_injection(object()))
class IsMethodInjectionTests(unittest.TestCase): class IsMethodInjectionTests(unittest.TestCase):
@ -189,23 +208,24 @@ class IsMethodInjectionTests(unittest.TestCase):
def test_with_instance(self): def test_with_instance(self):
"""Test with instance.""" """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): def test_with_class(self):
"""Test with class.""" """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): def test_with_parent_class(self):
"""Test with parent class.""" """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): def test_with_string(self):
"""Test with string.""" """Test with string."""
self.assertFalse(di.is_method_injection('some_string')) self.assertFalse(utils.is_method_injection('some_string'))
def test_with_object(self): def test_with_object(self):
"""Test with object.""" """Test with object."""
self.assertFalse(di.is_method_injection(object())) self.assertFalse(utils.is_method_injection(object()))
class IsCatalogTests(unittest.TestCase): class IsCatalogTests(unittest.TestCase):
@ -213,26 +233,26 @@ class IsCatalogTests(unittest.TestCase):
def test_with_declarative_catalog(self): def test_with_declarative_catalog(self):
"""Test with class.""" """Test with class."""
self.assertTrue(di.is_catalog(di.DeclarativeCatalog)) self.assertTrue(utils.is_catalog(catalogs.DeclarativeCatalog))
def test_with_dynamic_catalog(self): def test_with_dynamic_catalog(self):
"""Test with class.""" """Test with class."""
self.assertTrue(di.is_catalog(di.DynamicCatalog())) self.assertTrue(utils.is_catalog(catalogs.DynamicCatalog()))
def test_with_child_class(self): def test_with_child_class(self):
"""Test with parent class.""" """Test with parent class."""
class Catalog(di.AbstractCatalog): class Catalog(catalogs.DeclarativeCatalog):
"""Example catalog child class.""" """Example catalog child class."""
self.assertTrue(di.is_catalog(Catalog)) self.assertTrue(utils.is_catalog(Catalog))
def test_with_string(self): def test_with_string(self):
"""Test with string.""" """Test with string."""
self.assertFalse(di.is_catalog('some_string')) self.assertFalse(utils.is_catalog('some_string'))
def test_with_object(self): def test_with_object(self):
"""Test with object.""" """Test with object."""
self.assertFalse(di.is_catalog(object())) self.assertFalse(utils.is_catalog(object()))
class IsDynamicCatalogTests(unittest.TestCase): class IsDynamicCatalogTests(unittest.TestCase):
@ -240,11 +260,11 @@ class IsDynamicCatalogTests(unittest.TestCase):
def test_with_declarative_catalog(self): def test_with_declarative_catalog(self):
"""Test with declarative catalog.""" """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): def test_with_dynamic_catalog(self):
"""Test with dynamic catalog.""" """Test with dynamic catalog."""
self.assertTrue(di.is_dynamic_catalog(di.DynamicCatalog())) self.assertTrue(utils.is_dynamic_catalog(catalogs.DynamicCatalog()))
class IsDeclarativeCatalogTests(unittest.TestCase): class IsDeclarativeCatalogTests(unittest.TestCase):
@ -252,11 +272,13 @@ class IsDeclarativeCatalogTests(unittest.TestCase):
def test_with_declarative_catalog(self): def test_with_declarative_catalog(self):
"""Test with declarative catalog.""" """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): def test_with_dynamic_catalog(self):
"""Test with dynamic catalog.""" """Test with dynamic catalog."""
self.assertFalse(di.is_declarative_catalog(di.DynamicCatalog())) self.assertFalse(utils.is_declarative_catalog(
catalogs.DynamicCatalog()))
class IsCatalogBundleTests(unittest.TestCase): class IsCatalogBundleTests(unittest.TestCase):
@ -264,19 +286,19 @@ class IsCatalogBundleTests(unittest.TestCase):
def test_with_instance(self): def test_with_instance(self):
"""Test with instance.""" """Test with instance."""
self.assertTrue(di.is_catalog_bundle(di.CatalogBundle())) self.assertTrue(utils.is_catalog_bundle(catalogs.CatalogBundle()))
def test_with_cls(self): def test_with_cls(self):
"""Test with class.""" """Test with class."""
self.assertFalse(di.is_catalog_bundle(di.CatalogBundle)) self.assertFalse(utils.is_catalog_bundle(catalogs.CatalogBundle))
def test_with_string(self): def test_with_string(self):
"""Test with string.""" """Test with string."""
self.assertFalse(di.is_catalog_bundle('some_string')) self.assertFalse(utils.is_catalog_bundle('some_string'))
def test_with_object(self): def test_with_object(self):
"""Test with object.""" """Test with object."""
self.assertFalse(di.is_catalog_bundle(object())) self.assertFalse(utils.is_catalog_bundle(object()))
class EnsureIsCatalogBundleTests(unittest.TestCase): class EnsureIsCatalogBundleTests(unittest.TestCase):
@ -284,18 +306,23 @@ class EnsureIsCatalogBundleTests(unittest.TestCase):
def test_with_instance(self): def test_with_instance(self):
"""Test with instance.""" """Test with instance."""
bundle = di.CatalogBundle() bundle = catalogs.CatalogBundle()
self.assertIs(di.ensure_is_catalog_bundle(bundle), bundle) self.assertIs(utils.ensure_is_catalog_bundle(bundle), bundle)
def test_with_class(self): def test_with_class(self):
"""Test with class.""" """Test with class."""
self.assertRaises(di.Error, di.ensure_is_catalog_bundle, self.assertRaises(errors.Error,
di.CatalogBundle) utils.ensure_is_catalog_bundle,
catalogs.CatalogBundle)
def test_with_string(self): def test_with_string(self):
"""Test with string.""" """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): def test_with_object(self):
"""Test with object.""" """Test with object."""
self.assertRaises(di.Error, di.ensure_is_catalog_bundle, object()) self.assertRaises(errors.Error,
utils.ensure_is_catalog_bundle,
object())