mirror of
https://github.com/ets-labs/python-dependency-injector.git
synced 2025-11-04 09:57:37 +03:00
Update test imports
This commit is contained in:
Roman Mogilatov
parent
4fb3a12770
commit
ad2072688b
|
|
@ -1,26 +1,19 @@
|
|||
"""Dependency injector catalog unittests."""
|
||||
|
||||
import unittest2 as unittest
|
||||
|
||||
from dependency_injector.catalog import AbstractCatalog
|
||||
from dependency_injector.catalog import override
|
||||
|
||||
from dependency_injector.providers import Object
|
||||
from dependency_injector.providers import Value
|
||||
|
||||
from dependency_injector.errors import Error
|
||||
import dependency_injector as di
|
||||
|
||||
|
||||
class CatalogTests(unittest.TestCase):
|
||||
|
||||
"""Catalog test cases."""
|
||||
|
||||
class Catalog(AbstractCatalog):
|
||||
class Catalog(di.AbstractCatalog):
|
||||
|
||||
"""Test catalog."""
|
||||
|
||||
obj = Object(object())
|
||||
another_obj = Object(object())
|
||||
obj = di.Object(object())
|
||||
another_obj = di.Object(object())
|
||||
|
||||
def test_get_used(self):
|
||||
"""Test retrieving used provider."""
|
||||
|
|
@ -30,7 +23,7 @@ class CatalogTests(unittest.TestCase):
|
|||
def test_get_unused(self):
|
||||
"""Test retrieving unused provider."""
|
||||
catalog = self.Catalog()
|
||||
self.assertRaises(Error, getattr, catalog, 'obj')
|
||||
self.assertRaises(di.Error, getattr, catalog, 'obj')
|
||||
|
||||
def test_all_providers(self):
|
||||
"""Test getting of all catalog providers."""
|
||||
|
|
@ -45,22 +38,22 @@ class CatalogTests(unittest.TestCase):
|
|||
|
||||
def test_all_providers_by_type(self):
|
||||
"""Test getting of all catalog providers of specific type."""
|
||||
self.assertTrue(len(self.Catalog.filter(Object)) == 2)
|
||||
self.assertTrue(len(self.Catalog.filter(Value)) == 0)
|
||||
self.assertTrue(len(self.Catalog.filter(di.Object)) == 2)
|
||||
self.assertTrue(len(self.Catalog.filter(di.Value)) == 0)
|
||||
|
||||
def test_metaclass_with_several_catalogs(self):
|
||||
"""Test that metaclass work well with several catalogs."""
|
||||
class Catalog1(AbstractCatalog):
|
||||
class Catalog1(di.AbstractCatalog):
|
||||
|
||||
"""Catalog1."""
|
||||
|
||||
provider = Object(object())
|
||||
provider = di.Object(object())
|
||||
|
||||
class Catalog2(AbstractCatalog):
|
||||
class Catalog2(di.AbstractCatalog):
|
||||
|
||||
"""Catalog2."""
|
||||
|
||||
provider = Object(object())
|
||||
provider = di.Object(object())
|
||||
|
||||
self.assertTrue(len(Catalog1.providers) == 1)
|
||||
self.assertIs(Catalog1.provider, Catalog1.providers['provider'])
|
||||
|
|
@ -75,22 +68,22 @@ class OverrideTests(unittest.TestCase):
|
|||
|
||||
"""Override decorator test cases."""
|
||||
|
||||
class Catalog(AbstractCatalog):
|
||||
class Catalog(di.AbstractCatalog):
|
||||
|
||||
"""Test catalog."""
|
||||
|
||||
obj = Object(object())
|
||||
another_obj = Object(object())
|
||||
obj = di.Object(object())
|
||||
another_obj = di.Object(object())
|
||||
|
||||
def test_overriding(self):
|
||||
"""Test catalog overriding with another catalog."""
|
||||
@override(self.Catalog)
|
||||
@di.override(self.Catalog)
|
||||
class OverridingCatalog(self.Catalog):
|
||||
|
||||
"""Overriding catalog."""
|
||||
|
||||
obj = Value(1)
|
||||
another_obj = Value(2)
|
||||
obj = di.Value(1)
|
||||
another_obj = di.Value(2)
|
||||
|
||||
self.assertEqual(self.Catalog.obj(), 1)
|
||||
self.assertEqual(self.Catalog.another_obj(), 2)
|
||||
|
|
|
|||
|
|
@ -1,16 +1,7 @@
|
|||
"""Dependency injector injections unittests."""
|
||||
|
||||
import unittest2 as unittest
|
||||
|
||||
from dependency_injector.injections import Injection
|
||||
from dependency_injector.injections import KwArg
|
||||
from dependency_injector.injections import Attribute
|
||||
from dependency_injector.injections import Method
|
||||
from dependency_injector.injections import inject
|
||||
|
||||
from dependency_injector.providers import Factory
|
||||
|
||||
from dependency_injector.errors import Error
|
||||
import dependency_injector as di
|
||||
|
||||
|
||||
class InjectionTests(unittest.TestCase):
|
||||
|
|
@ -19,18 +10,18 @@ class InjectionTests(unittest.TestCase):
|
|||
|
||||
def test_init(self):
|
||||
"""Test Injection creation and initialization."""
|
||||
injection = Injection('some_arg_name', 'some_value')
|
||||
injection = di.Injection('some_arg_name', 'some_value')
|
||||
self.assertEqual(injection.name, 'some_arg_name')
|
||||
self.assertEqual(injection.injectable, 'some_value')
|
||||
|
||||
def test_value_with_scalar_injectable(self):
|
||||
"""Test Injection value property with scalar value."""
|
||||
injection = Injection('some_arg_name', 'some_value')
|
||||
injection = di.Injection('some_arg_name', 'some_value')
|
||||
self.assertEqual(injection.value, 'some_value')
|
||||
|
||||
def test_value_with_provider_injectable(self):
|
||||
"""Test Injection value property with provider."""
|
||||
injection = Injection('some_arg_name', Factory(object))
|
||||
injection = di.Injection('some_arg_name', di.Factory(object))
|
||||
self.assertIsInstance(injection.value, object)
|
||||
|
||||
|
||||
|
|
@ -40,7 +31,7 @@ class KwArgTests(unittest.TestCase):
|
|||
|
||||
def test_init(self):
|
||||
"""Test KwArg creation and initialization."""
|
||||
injection = KwArg('some_arg_name', 'some_value')
|
||||
injection = di.KwArg('some_arg_name', 'some_value')
|
||||
self.assertEqual(injection.name, 'some_arg_name')
|
||||
self.assertEqual(injection.injectable, 'some_value')
|
||||
|
||||
|
|
@ -51,7 +42,7 @@ class AttributeTests(unittest.TestCase):
|
|||
|
||||
def test_init(self):
|
||||
"""Test Attribute creation and initialization."""
|
||||
injection = Attribute('some_arg_name', 'some_value')
|
||||
injection = di.Attribute('some_arg_name', 'some_value')
|
||||
self.assertEqual(injection.name, 'some_arg_name')
|
||||
self.assertEqual(injection.injectable, 'some_value')
|
||||
|
||||
|
|
@ -62,7 +53,7 @@ class MethodTests(unittest.TestCase):
|
|||
|
||||
def test_init(self):
|
||||
"""Test Method creation and initialization."""
|
||||
injection = Method('some_arg_name', 'some_value')
|
||||
injection = di.Method('some_arg_name', 'some_value')
|
||||
self.assertEqual(injection.name, 'some_arg_name')
|
||||
self.assertEqual(injection.injectable, 'some_value')
|
||||
|
||||
|
|
@ -73,11 +64,11 @@ class InjectTests(unittest.TestCase):
|
|||
|
||||
def test_decorated(self):
|
||||
"""Test `inject()` decorated callback."""
|
||||
provider1 = Factory(object)
|
||||
provider2 = Factory(list)
|
||||
provider1 = di.Factory(object)
|
||||
provider2 = di.Factory(list)
|
||||
|
||||
@inject(a=provider1)
|
||||
@inject(b=provider2)
|
||||
@di.inject(a=provider1)
|
||||
@di.inject(b=provider2)
|
||||
def test(a, b):
|
||||
return a, b
|
||||
|
||||
|
|
@ -94,12 +85,12 @@ class InjectTests(unittest.TestCase):
|
|||
|
||||
def test_decorated_kwargs_priority(self):
|
||||
"""Test `inject()` decorated callback kwargs priority."""
|
||||
provider1 = Factory(object)
|
||||
provider2 = Factory(list)
|
||||
provider1 = di.Factory(object)
|
||||
provider2 = di.Factory(list)
|
||||
object_a = object()
|
||||
|
||||
@inject(a=provider1)
|
||||
@inject(b=provider2)
|
||||
@di.inject(a=provider1)
|
||||
@di.inject(b=provider2)
|
||||
def test(a, b):
|
||||
return a, b
|
||||
|
||||
|
|
@ -117,10 +108,10 @@ class InjectTests(unittest.TestCase):
|
|||
|
||||
def test_decorated_with_args(self):
|
||||
"""Test `inject()` decorated callback with args."""
|
||||
provider = Factory(list)
|
||||
provider = di.Factory(list)
|
||||
object_a = object()
|
||||
|
||||
@inject(b=provider)
|
||||
@di.inject(b=provider)
|
||||
def test(a, b):
|
||||
return a, b
|
||||
|
||||
|
|
@ -138,10 +129,10 @@ class InjectTests(unittest.TestCase):
|
|||
|
||||
def test_injection_kwarg_syntax(self):
|
||||
"""Test `inject()` decorated callback with "old" style using KwArg."""
|
||||
provider = Factory(list)
|
||||
provider = di.Factory(list)
|
||||
object_a = object()
|
||||
|
||||
@inject(KwArg('b', provider))
|
||||
@di.inject(di.KwArg('b', provider))
|
||||
def test(a, b):
|
||||
return a, b
|
||||
|
||||
|
|
@ -159,4 +150,4 @@ class InjectTests(unittest.TestCase):
|
|||
|
||||
def test_decorate_with_not_injection(self):
|
||||
"""Test `inject()` decorator with not an injection instance."""
|
||||
self.assertRaises(Error, inject, object)
|
||||
self.assertRaises(di.Error, di.inject, object)
|
||||
|
|
|
|||
|
|
@ -1,26 +1,7 @@
|
|||
"""Dependency injector providers unittests."""
|
||||
|
||||
import unittest2 as unittest
|
||||
|
||||
from dependency_injector.providers import Provider
|
||||
from dependency_injector.providers import Delegate
|
||||
from dependency_injector.providers import Factory
|
||||
from dependency_injector.providers import Singleton
|
||||
from dependency_injector.providers import ExternalDependency
|
||||
from dependency_injector.providers import Class
|
||||
from dependency_injector.providers import Object
|
||||
from dependency_injector.providers import Function
|
||||
from dependency_injector.providers import Value
|
||||
from dependency_injector.providers import Callable
|
||||
from dependency_injector.providers import Config
|
||||
|
||||
from dependency_injector.injections import KwArg
|
||||
from dependency_injector.injections import Attribute
|
||||
from dependency_injector.injections import Method
|
||||
|
||||
from dependency_injector.utils import is_provider
|
||||
|
||||
from dependency_injector.errors import Error
|
||||
import dependency_injector as di
|
||||
|
||||
|
||||
class ProviderTests(unittest.TestCase):
|
||||
|
|
@ -29,11 +10,11 @@ class ProviderTests(unittest.TestCase):
|
|||
|
||||
def setUp(self):
|
||||
"""Set test cases environment up."""
|
||||
self.provider = Provider()
|
||||
self.provider = di.Provider()
|
||||
|
||||
def test_is_provider(self):
|
||||
"""Test `is_provider` check."""
|
||||
self.assertTrue(is_provider(self.provider))
|
||||
self.assertTrue(di.is_provider(self.provider))
|
||||
|
||||
def test_call(self):
|
||||
"""Test call."""
|
||||
|
|
@ -43,30 +24,30 @@ class ProviderTests(unittest.TestCase):
|
|||
"""Test creating of provider delegation."""
|
||||
delegate1 = self.provider.delegate()
|
||||
|
||||
self.assertIsInstance(delegate1, Delegate)
|
||||
self.assertIsInstance(delegate1, di.Delegate)
|
||||
self.assertIs(delegate1(), self.provider)
|
||||
|
||||
delegate2 = self.provider.delegate()
|
||||
|
||||
self.assertIsInstance(delegate2, Delegate)
|
||||
self.assertIsInstance(delegate2, di.Delegate)
|
||||
self.assertIs(delegate2(), self.provider)
|
||||
|
||||
self.assertIsNot(delegate1, delegate2)
|
||||
|
||||
def test_override(self):
|
||||
"""Test provider overriding."""
|
||||
overriding_provider = Provider()
|
||||
overriding_provider = di.Provider()
|
||||
self.provider.override(overriding_provider)
|
||||
self.assertTrue(self.provider.is_overridden)
|
||||
|
||||
def test_override_with_not_provider(self):
|
||||
"""Test provider overriding with not provider instance."""
|
||||
self.assertRaises(Error, self.provider.override, object())
|
||||
self.assertRaises(di.Error, self.provider.override, object())
|
||||
|
||||
def test_last_overriding(self):
|
||||
"""Test getting last overriding provider."""
|
||||
overriding_provider1 = Provider()
|
||||
overriding_provider2 = Provider()
|
||||
overriding_provider1 = di.Provider()
|
||||
overriding_provider2 = di.Provider()
|
||||
|
||||
self.provider.override(overriding_provider1)
|
||||
self.assertIs(self.provider.last_overriding, overriding_provider1)
|
||||
|
|
@ -78,7 +59,7 @@ class ProviderTests(unittest.TestCase):
|
|||
"""Test getting last overriding from not overridden provider."""
|
||||
try:
|
||||
self.provider.last_overriding
|
||||
except Error:
|
||||
except di.Error:
|
||||
pass
|
||||
else:
|
||||
self.fail('Got en error in {}'.format(
|
||||
|
|
@ -86,8 +67,8 @@ class ProviderTests(unittest.TestCase):
|
|||
|
||||
def test_reset_last_overriding(self):
|
||||
"""Test reseting of last overriding provider."""
|
||||
overriding_provider1 = Provider()
|
||||
overriding_provider2 = Provider()
|
||||
overriding_provider1 = di.Provider()
|
||||
overriding_provider2 = di.Provider()
|
||||
|
||||
self.provider.override(overriding_provider1)
|
||||
self.provider.override(overriding_provider2)
|
||||
|
|
@ -102,11 +83,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(Error, self.provider.reset_last_overriding)
|
||||
self.assertRaises(di.Error, self.provider.reset_last_overriding)
|
||||
|
||||
def test_reset_override(self):
|
||||
"""Test reset of provider's override."""
|
||||
overriding_provider = Provider()
|
||||
overriding_provider = di.Provider()
|
||||
self.provider.override(overriding_provider)
|
||||
|
||||
self.assertTrue(self.provider.is_overridden)
|
||||
|
|
@ -117,7 +98,7 @@ class ProviderTests(unittest.TestCase):
|
|||
self.assertFalse(self.provider.is_overridden)
|
||||
try:
|
||||
self.provider.last_overriding
|
||||
except Error:
|
||||
except di.Error:
|
||||
pass
|
||||
else:
|
||||
self.fail('Got en error in {}'.format(
|
||||
|
|
@ -130,16 +111,16 @@ class DelegateTests(unittest.TestCase):
|
|||
|
||||
def setUp(self):
|
||||
"""Set test cases environment up."""
|
||||
self.delegated = Provider()
|
||||
self.delegate = Delegate(delegated=self.delegated)
|
||||
self.delegated = di.Provider()
|
||||
self.delegate = di.Delegate(delegated=self.delegated)
|
||||
|
||||
def test_is_provider(self):
|
||||
"""Test `is_provider` check."""
|
||||
self.assertTrue(is_provider(self.delegate))
|
||||
self.assertTrue(di.is_provider(self.delegate))
|
||||
|
||||
def test_init_with_not_provider(self):
|
||||
"""Test that delegate accepts only another provider as delegated."""
|
||||
self.assertRaises(Error, Delegate, delegated=object())
|
||||
self.assertRaises(di.Error, di.Delegate, delegated=object())
|
||||
|
||||
def test_call(self):
|
||||
"""Test returning of delegated provider."""
|
||||
|
|
@ -184,19 +165,19 @@ class FactoryTests(unittest.TestCase):
|
|||
|
||||
def test_is_provider(self):
|
||||
"""Test `is_provider` check."""
|
||||
self.assertTrue(is_provider(Factory(self.Example)))
|
||||
self.assertTrue(di.is_provider(di.Factory(self.Example)))
|
||||
|
||||
def test_init_with_callable(self):
|
||||
"""Test creation of provider with a callable."""
|
||||
self.assertTrue(Factory(credits))
|
||||
self.assertTrue(di.Factory(credits))
|
||||
|
||||
def test_init_with_not_callable(self):
|
||||
"""Test creation of provider with not a callable."""
|
||||
self.assertRaises(Error, Factory, 123)
|
||||
self.assertRaises(di.Error, di.Factory, 123)
|
||||
|
||||
def test_call(self):
|
||||
"""Test creation of new instances."""
|
||||
provider = Factory(self.Example)
|
||||
provider = di.Factory(self.Example)
|
||||
instance1 = provider()
|
||||
instance2 = provider()
|
||||
|
||||
|
|
@ -204,11 +185,14 @@ class FactoryTests(unittest.TestCase):
|
|||
self.assertIsInstance(instance1, self.Example)
|
||||
self.assertIsInstance(instance2, self.Example)
|
||||
|
||||
def test_call_with_init_args(self):
|
||||
"""Test creation of new instances with init args injections."""
|
||||
provider = Factory(self.Example,
|
||||
KwArg('init_arg1', 'i1'),
|
||||
KwArg('init_arg2', 'i2'))
|
||||
def test_call_with_init_args_simplified_syntax(self):
|
||||
"""Test creation of new instances with init args injections.
|
||||
|
||||
New simplified syntax.
|
||||
"""
|
||||
provider = di.Factory(self.Example,
|
||||
init_arg1='i1',
|
||||
init_arg2='i2')
|
||||
|
||||
instance1 = provider()
|
||||
instance2 = provider()
|
||||
|
|
@ -223,14 +207,11 @@ class FactoryTests(unittest.TestCase):
|
|||
self.assertIsInstance(instance1, self.Example)
|
||||
self.assertIsInstance(instance2, self.Example)
|
||||
|
||||
def test_call_with_init_args_simplified_syntax(self):
|
||||
"""Test creation of new instances with init args injections.
|
||||
|
||||
Simplified syntax.
|
||||
"""
|
||||
provider = Factory(self.Example,
|
||||
init_arg1='i1',
|
||||
init_arg2='i2')
|
||||
def test_call_with_init_args_old_syntax(self):
|
||||
"""Test creation of new instances with init args injections."""
|
||||
provider = di.Factory(self.Example,
|
||||
di.KwArg('init_arg1', 'i1'),
|
||||
di.KwArg('init_arg2', 'i2'))
|
||||
|
||||
instance1 = provider()
|
||||
instance2 = provider()
|
||||
|
|
@ -247,9 +228,9 @@ class FactoryTests(unittest.TestCase):
|
|||
|
||||
def test_call_with_attributes(self):
|
||||
"""Test creation of new instances with attribute injections."""
|
||||
provider = Factory(self.Example,
|
||||
Attribute('attribute1', 'a1'),
|
||||
Attribute('attribute2', 'a2'))
|
||||
provider = di.Factory(self.Example,
|
||||
di.Attribute('attribute1', 'a1'),
|
||||
di.Attribute('attribute2', 'a2'))
|
||||
|
||||
instance1 = provider()
|
||||
instance2 = provider()
|
||||
|
|
@ -266,9 +247,9 @@ class FactoryTests(unittest.TestCase):
|
|||
|
||||
def test_call_with_methods(self):
|
||||
"""Test creation of new instances with method injections."""
|
||||
provider = Factory(self.Example,
|
||||
Method('method1', 'm1'),
|
||||
Method('method2', 'm2'))
|
||||
provider = di.Factory(self.Example,
|
||||
di.Method('method1', 'm1'),
|
||||
di.Method('method2', 'm2'))
|
||||
|
||||
instance1 = provider()
|
||||
instance2 = provider()
|
||||
|
|
@ -285,7 +266,7 @@ class FactoryTests(unittest.TestCase):
|
|||
|
||||
def test_call_with_context_args(self):
|
||||
"""Test creation of new instances with context args."""
|
||||
provider = Factory(self.Example)
|
||||
provider = di.Factory(self.Example)
|
||||
instance = provider(11, 22)
|
||||
|
||||
self.assertEqual(instance.init_arg1, 11)
|
||||
|
|
@ -293,8 +274,8 @@ class FactoryTests(unittest.TestCase):
|
|||
|
||||
def test_call_with_context_kwargs(self):
|
||||
"""Test creation of new instances with context kwargs."""
|
||||
provider = Factory(self.Example,
|
||||
KwArg('init_arg1', 1))
|
||||
provider = di.Factory(self.Example,
|
||||
di.KwArg('init_arg1', 1))
|
||||
|
||||
instance1 = provider(init_arg2=22)
|
||||
self.assertEqual(instance1.init_arg1, 1)
|
||||
|
|
@ -306,9 +287,9 @@ class FactoryTests(unittest.TestCase):
|
|||
|
||||
def test_call_overridden(self):
|
||||
"""Test creation of new instances on overridden provider."""
|
||||
provider = Factory(self.Example)
|
||||
overriding_provider1 = Factory(dict)
|
||||
overriding_provider2 = Factory(list)
|
||||
provider = di.Factory(self.Example)
|
||||
overriding_provider1 = di.Factory(dict)
|
||||
overriding_provider2 = di.Factory(list)
|
||||
|
||||
provider.override(overriding_provider1)
|
||||
provider.override(overriding_provider2)
|
||||
|
|
@ -327,7 +308,7 @@ class SingletonTests(unittest.TestCase):
|
|||
|
||||
def test_call(self):
|
||||
"""Test creation and returning of single object."""
|
||||
provider = Singleton(object)
|
||||
provider = di.Singleton(object)
|
||||
|
||||
instance1 = provider()
|
||||
instance2 = provider()
|
||||
|
|
@ -338,7 +319,7 @@ class SingletonTests(unittest.TestCase):
|
|||
|
||||
def test_reset(self):
|
||||
"""Test creation and reset of single object."""
|
||||
provider = Singleton(object)
|
||||
provider = di.Singleton(object)
|
||||
|
||||
instance1 = provider()
|
||||
self.assertIsInstance(instance1, object)
|
||||
|
|
@ -357,29 +338,29 @@ class ExternalDependencyTests(unittest.TestCase):
|
|||
|
||||
def setUp(self):
|
||||
"""Set test cases environment up."""
|
||||
self.provider = ExternalDependency(instance_of=list)
|
||||
self.provider = di.ExternalDependency(instance_of=list)
|
||||
|
||||
def test_init_with_not_class(self):
|
||||
"""Test creation with not a class."""
|
||||
self.assertRaises(Error, ExternalDependency, object())
|
||||
self.assertRaises(di.Error, di.ExternalDependency, object())
|
||||
|
||||
def test_is_provider(self):
|
||||
"""Test `is_provider` check."""
|
||||
self.assertTrue(is_provider(self.provider))
|
||||
self.assertTrue(di.is_provider(self.provider))
|
||||
|
||||
def test_call_overridden(self):
|
||||
"""Test call of overridden external dependency."""
|
||||
self.provider.provided_by(Factory(list))
|
||||
self.provider.provided_by(di.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(Factory(dict))
|
||||
self.assertRaises(Error, self.provider)
|
||||
self.provider.provided_by(di.Factory(dict))
|
||||
self.assertRaises(di.Error, self.provider)
|
||||
|
||||
def test_call_not_overridden(self):
|
||||
"""Test call of not satisfied external dependency."""
|
||||
self.assertRaises(Error, self.provider)
|
||||
self.assertRaises(di.Error, self.provider)
|
||||
|
||||
|
||||
class StaticProvidersTests(unittest.TestCase):
|
||||
|
|
@ -388,52 +369,52 @@ class StaticProvidersTests(unittest.TestCase):
|
|||
|
||||
def test_is_provider(self):
|
||||
"""Test `is_provider` check."""
|
||||
self.assertTrue(is_provider(Class(object)))
|
||||
self.assertTrue(is_provider(Object(object())))
|
||||
self.assertTrue(is_provider(Function(map)))
|
||||
self.assertTrue(is_provider(Value(123)))
|
||||
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)))
|
||||
|
||||
def test_call_class_provider(self):
|
||||
"""Test Class provider call."""
|
||||
self.assertIs(Class(dict)(), dict)
|
||||
self.assertIs(di.Class(dict)(), dict)
|
||||
|
||||
def test_call_object_provider(self):
|
||||
"""Test Object provider call."""
|
||||
obj = object()
|
||||
self.assertIs(Object(obj)(), obj)
|
||||
self.assertIs(di.Object(obj)(), obj)
|
||||
|
||||
def test_call_function_provider(self):
|
||||
"""Test Function provider call."""
|
||||
self.assertIs(Function(map)(), map)
|
||||
self.assertIs(di.Function(map)(), map)
|
||||
|
||||
def test_call_value_provider(self):
|
||||
"""Test Value provider call."""
|
||||
self.assertEqual(Value(123)(), 123)
|
||||
self.assertEqual(di.Value(123)(), 123)
|
||||
|
||||
def test_call_overridden_class_provider(self):
|
||||
"""Test overridden Class provider call."""
|
||||
cls_provider = Class(dict)
|
||||
cls_provider.override(Object(list))
|
||||
cls_provider = di.Class(dict)
|
||||
cls_provider.override(di.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 = Object(obj1)
|
||||
obj_provider.override(Object(obj2))
|
||||
obj_provider = di.Object(obj1)
|
||||
obj_provider.override(di.Object(obj2))
|
||||
self.assertIs(obj_provider(), obj2)
|
||||
|
||||
def test_call_overridden_function_provider(self):
|
||||
"""Test overridden Function provider call."""
|
||||
function_provider = Function(len)
|
||||
function_provider.override(Function(sum))
|
||||
function_provider = di.Function(len)
|
||||
function_provider.override(di.Function(sum))
|
||||
self.assertIs(function_provider(), sum)
|
||||
|
||||
def test_call_overridden_value_provider(self):
|
||||
"""Test overridden Value provider call."""
|
||||
value_provider = Value(123)
|
||||
value_provider.override(Value(321))
|
||||
value_provider = di.Value(123)
|
||||
value_provider.override(di.Value(321))
|
||||
self.assertEqual(value_provider(), 321)
|
||||
|
||||
|
||||
|
|
@ -447,18 +428,18 @@ class CallableTests(unittest.TestCase):
|
|||
|
||||
def setUp(self):
|
||||
"""Set test cases environment up."""
|
||||
self.provider = Callable(self.example,
|
||||
KwArg('arg1', 'a1'),
|
||||
KwArg('arg2', 'a2'),
|
||||
KwArg('arg3', 'a3'))
|
||||
self.provider = di.Callable(self.example,
|
||||
di.KwArg('arg1', 'a1'),
|
||||
di.KwArg('arg2', 'a2'),
|
||||
di.KwArg('arg3', 'a3'))
|
||||
|
||||
def test_init_with_not_callable(self):
|
||||
"""Test creation of provider with not callable."""
|
||||
self.assertRaises(Error, Callable, 123)
|
||||
self.assertRaises(di.Error, di.Callable, 123)
|
||||
|
||||
def test_is_provider(self):
|
||||
"""Test `is_provider` check."""
|
||||
self.assertTrue(is_provider(self.provider))
|
||||
self.assertTrue(di.is_provider(self.provider))
|
||||
|
||||
def test_call(self):
|
||||
"""Test provider call."""
|
||||
|
|
@ -466,8 +447,8 @@ class CallableTests(unittest.TestCase):
|
|||
|
||||
def test_call_with_args(self):
|
||||
"""Test provider call with kwargs priority."""
|
||||
provider = Callable(self.example,
|
||||
KwArg('arg3', 'a3'))
|
||||
provider = di.Callable(self.example,
|
||||
di.KwArg('arg3', 'a3'))
|
||||
self.assertEqual(provider(1, 2), (1, 2, 'a3'))
|
||||
|
||||
def test_call_with_kwargs_priority(self):
|
||||
|
|
@ -476,8 +457,8 @@ class CallableTests(unittest.TestCase):
|
|||
|
||||
def test_call_overridden(self):
|
||||
"""Test overridden provider call."""
|
||||
overriding_provider1 = Value((1, 2, 3))
|
||||
overriding_provider2 = Value((3, 2, 1))
|
||||
overriding_provider1 = di.Value((1, 2, 3))
|
||||
overriding_provider2 = di.Value((3, 2, 1))
|
||||
|
||||
self.provider.override(overriding_provider1)
|
||||
self.provider.override(overriding_provider2)
|
||||
|
|
@ -497,15 +478,15 @@ class ConfigTests(unittest.TestCase):
|
|||
"""Set test cases environment up."""
|
||||
self.initial_data = dict(key='value',
|
||||
category=dict(setting='setting_value'))
|
||||
self.provider = Config(self.initial_data)
|
||||
self.provider = di.Config(self.initial_data)
|
||||
|
||||
def test_is_provider(self):
|
||||
"""Test `is_provider` check."""
|
||||
self.assertTrue(is_provider(self.provider))
|
||||
self.assertTrue(di.is_provider(self.provider))
|
||||
|
||||
def test_init_without_initial_value(self):
|
||||
"""Test provider's creation with no initial value."""
|
||||
self.assertEqual(Config()(), dict())
|
||||
self.assertEqual(di.Config()(), dict())
|
||||
|
||||
def test_call(self):
|
||||
"""Test returning of config value."""
|
||||
|
|
@ -524,8 +505,8 @@ class ConfigTests(unittest.TestCase):
|
|||
category = self.provider.category
|
||||
category_setting = self.provider.category.setting
|
||||
|
||||
self.assertTrue(is_provider(category))
|
||||
self.assertTrue(is_provider(category_setting))
|
||||
self.assertTrue(di.is_provider(category))
|
||||
self.assertTrue(di.is_provider(category_setting))
|
||||
|
||||
self.assertEqual(category(), self.initial_data['category'])
|
||||
self.assertEqual(category_setting(),
|
||||
|
|
@ -533,12 +514,12 @@ class ConfigTests(unittest.TestCase):
|
|||
|
||||
def test_call_deferred_child_and_update_from(self):
|
||||
"""Test returning of deferred child config values."""
|
||||
self.provider = Config()
|
||||
self.provider = di.Config()
|
||||
category = self.provider.category
|
||||
category_setting = self.provider.category.setting
|
||||
|
||||
self.assertTrue(is_provider(category))
|
||||
self.assertTrue(is_provider(category_setting))
|
||||
self.assertTrue(di.is_provider(category))
|
||||
self.assertTrue(di.is_provider(category_setting))
|
||||
|
||||
self.provider.update_from(self.initial_data)
|
||||
|
||||
|
|
@ -548,6 +529,6 @@ class ConfigTests(unittest.TestCase):
|
|||
|
||||
def test_call_deferred_child_with_empty_value(self):
|
||||
"""Test returning of deferred child config values."""
|
||||
self.provider = Config()
|
||||
self.provider = di.Config()
|
||||
category_setting = self.provider.category.setting
|
||||
self.assertRaises(Error, category_setting)
|
||||
self.assertRaises(di.Error, category_setting)
|
||||
|
|
|
|||
|
|
@ -1,23 +1,7 @@
|
|||
"""Dependency injector utils unittests."""
|
||||
|
||||
import unittest2 as unittest
|
||||
|
||||
from dependency_injector.utils import is_provider
|
||||
from dependency_injector.utils import ensure_is_provider
|
||||
from dependency_injector.utils import is_injection
|
||||
from dependency_injector.utils import ensure_is_injection
|
||||
from dependency_injector.utils import is_kwarg_injection
|
||||
from dependency_injector.utils import is_attribute_injection
|
||||
from dependency_injector.utils import is_method_injection
|
||||
|
||||
from dependency_injector.providers import Provider
|
||||
|
||||
from dependency_injector.injections import Injection
|
||||
from dependency_injector.injections import KwArg
|
||||
from dependency_injector.injections import Attribute
|
||||
from dependency_injector.injections import Method
|
||||
|
||||
from dependency_injector.errors import Error
|
||||
import dependency_injector as di
|
||||
|
||||
|
||||
class IsProviderTests(unittest.TestCase):
|
||||
|
|
@ -26,27 +10,27 @@ class IsProviderTests(unittest.TestCase):
|
|||
|
||||
def test_with_instance(self):
|
||||
"""Test with instance."""
|
||||
self.assertTrue(is_provider(Provider()))
|
||||
self.assertTrue(di.is_provider(di.Provider()))
|
||||
|
||||
def test_with_class(self):
|
||||
"""Test with class."""
|
||||
self.assertFalse(is_provider(Provider))
|
||||
self.assertFalse(di.is_provider(di.Provider))
|
||||
|
||||
def test_with_string(self):
|
||||
"""Test with string."""
|
||||
self.assertFalse(is_provider('some_string'))
|
||||
self.assertFalse(di.is_provider('some_string'))
|
||||
|
||||
def test_with_object(self):
|
||||
"""Test with object."""
|
||||
self.assertFalse(is_provider(object()))
|
||||
self.assertFalse(di.is_provider(object()))
|
||||
|
||||
def test_with_subclass_instance(self):
|
||||
"""Test with subclass of provider instance."""
|
||||
class SomeProvider(Provider):
|
||||
class SomeProvider(di.Provider):
|
||||
|
||||
"""Some provider for test."""
|
||||
|
||||
self.assertTrue(is_provider(SomeProvider()))
|
||||
self.assertTrue(di.is_provider(SomeProvider()))
|
||||
|
||||
def test_with_class_with_getattr(self):
|
||||
"""Test with class that has __getattr__() method implementation."""
|
||||
|
|
@ -58,7 +42,7 @@ class IsProviderTests(unittest.TestCase):
|
|||
"""Test implementation that just returns False."""
|
||||
return False
|
||||
|
||||
self.assertFalse(is_provider(SomeClass()))
|
||||
self.assertFalse(di.is_provider(SomeClass()))
|
||||
|
||||
|
||||
class EnsureIsProviderTests(unittest.TestCase):
|
||||
|
|
@ -67,20 +51,20 @@ class EnsureIsProviderTests(unittest.TestCase):
|
|||
|
||||
def test_with_instance(self):
|
||||
"""Test with instance."""
|
||||
provider = Provider()
|
||||
self.assertIs(ensure_is_provider(provider), provider)
|
||||
provider = di.Provider()
|
||||
self.assertIs(di.ensure_is_provider(provider), provider)
|
||||
|
||||
def test_with_class(self):
|
||||
"""Test with class."""
|
||||
self.assertRaises(Error, ensure_is_provider, Provider)
|
||||
self.assertRaises(di.Error, di.ensure_is_provider, di.Provider)
|
||||
|
||||
def test_with_string(self):
|
||||
"""Test with string."""
|
||||
self.assertRaises(Error, ensure_is_provider, 'some_string')
|
||||
self.assertRaises(di.Error, di.ensure_is_provider, 'some_string')
|
||||
|
||||
def test_with_object(self):
|
||||
"""Test with object."""
|
||||
self.assertRaises(Error, ensure_is_provider, object())
|
||||
self.assertRaises(di.Error, di.ensure_is_provider, object())
|
||||
|
||||
|
||||
class IsInjectionTests(unittest.TestCase):
|
||||
|
|
@ -89,25 +73,25 @@ class IsInjectionTests(unittest.TestCase):
|
|||
|
||||
def test_with_instance(self):
|
||||
"""Test with instance."""
|
||||
self.assertTrue(is_injection(Injection('name', 'value')))
|
||||
self.assertTrue(di.is_injection(di.Injection('name', 'value')))
|
||||
|
||||
def test_with_subclass_instances(self):
|
||||
"""Test with subclass instances."""
|
||||
self.assertTrue(is_injection(KwArg('name', 'value')))
|
||||
self.assertTrue(is_injection(Attribute('name', 'value')))
|
||||
self.assertTrue(is_injection(Method('name', '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')))
|
||||
|
||||
def test_with_class(self):
|
||||
"""Test with class."""
|
||||
self.assertFalse(is_injection(Injection))
|
||||
self.assertFalse(di.is_injection(di.Injection))
|
||||
|
||||
def test_with_string(self):
|
||||
"""Test with string."""
|
||||
self.assertFalse(is_injection('some_string'))
|
||||
self.assertFalse(di.is_injection('some_string'))
|
||||
|
||||
def test_with_object(self):
|
||||
"""Test with object."""
|
||||
self.assertFalse(is_injection(object()))
|
||||
self.assertFalse(di.is_injection(object()))
|
||||
|
||||
|
||||
class EnsureIsInjectionTests(unittest.TestCase):
|
||||
|
|
@ -116,20 +100,20 @@ class EnsureIsInjectionTests(unittest.TestCase):
|
|||
|
||||
def test_with_instance(self):
|
||||
"""Test with instance."""
|
||||
injection = Injection('name', 'value')
|
||||
self.assertIs(ensure_is_injection(injection), injection)
|
||||
injection = di.Injection('name', 'value')
|
||||
self.assertIs(di.ensure_is_injection(injection), injection)
|
||||
|
||||
def test_with_class(self):
|
||||
"""Test with class."""
|
||||
self.assertRaises(Error, ensure_is_injection, Injection)
|
||||
self.assertRaises(di.Error, di.ensure_is_injection, di.Injection)
|
||||
|
||||
def test_with_string(self):
|
||||
"""Test with string."""
|
||||
self.assertRaises(Error, ensure_is_injection, 'some_string')
|
||||
self.assertRaises(di.Error, di.ensure_is_injection, 'some_string')
|
||||
|
||||
def test_with_object(self):
|
||||
"""Test with object."""
|
||||
self.assertRaises(Error, ensure_is_injection, object())
|
||||
self.assertRaises(di.Error, di.ensure_is_injection, object())
|
||||
|
||||
|
||||
class IsKwArgInjectionTests(unittest.TestCase):
|
||||
|
|
@ -138,23 +122,23 @@ class IsKwArgInjectionTests(unittest.TestCase):
|
|||
|
||||
def test_with_instance(self):
|
||||
"""Test with instance."""
|
||||
self.assertTrue(is_kwarg_injection(KwArg('name', 'value')))
|
||||
self.assertTrue(di.is_kwarg_injection(di.KwArg('name', 'value')))
|
||||
|
||||
def test_with_class(self):
|
||||
"""Test with class."""
|
||||
self.assertFalse(is_kwarg_injection(KwArg))
|
||||
self.assertFalse(di.is_kwarg_injection(di.KwArg))
|
||||
|
||||
def test_with_parent_class(self):
|
||||
"""Test with parent class."""
|
||||
self.assertFalse(is_kwarg_injection(Injection))
|
||||
self.assertFalse(di.is_kwarg_injection(di.Injection))
|
||||
|
||||
def test_with_string(self):
|
||||
"""Test with string."""
|
||||
self.assertFalse(is_kwarg_injection('some_string'))
|
||||
self.assertFalse(di.is_kwarg_injection('some_string'))
|
||||
|
||||
def test_with_object(self):
|
||||
"""Test with object."""
|
||||
self.assertFalse(is_kwarg_injection(object()))
|
||||
self.assertFalse(di.is_kwarg_injection(object()))
|
||||
|
||||
|
||||
class IsAttributeInjectionTests(unittest.TestCase):
|
||||
|
|
@ -163,23 +147,24 @@ class IsAttributeInjectionTests(unittest.TestCase):
|
|||
|
||||
def test_with_instance(self):
|
||||
"""Test with instance."""
|
||||
self.assertTrue(is_attribute_injection(Attribute('name', 'value')))
|
||||
self.assertTrue(di.is_attribute_injection(di.Attribute('name',
|
||||
'value')))
|
||||
|
||||
def test_with_class(self):
|
||||
"""Test with class."""
|
||||
self.assertFalse(is_attribute_injection(Attribute))
|
||||
self.assertFalse(di.is_attribute_injection(di.Attribute))
|
||||
|
||||
def test_with_parent_class(self):
|
||||
"""Test with parent class."""
|
||||
self.assertFalse(is_attribute_injection(Injection))
|
||||
self.assertFalse(di.is_attribute_injection(di.Injection))
|
||||
|
||||
def test_with_string(self):
|
||||
"""Test with string."""
|
||||
self.assertFalse(is_attribute_injection('some_string'))
|
||||
self.assertFalse(di.is_attribute_injection('some_string'))
|
||||
|
||||
def test_with_object(self):
|
||||
"""Test with object."""
|
||||
self.assertFalse(is_attribute_injection(object()))
|
||||
self.assertFalse(di.is_attribute_injection(object()))
|
||||
|
||||
|
||||
class IsMethodInjectionTests(unittest.TestCase):
|
||||
|
|
@ -188,20 +173,20 @@ class IsMethodInjectionTests(unittest.TestCase):
|
|||
|
||||
def test_with_instance(self):
|
||||
"""Test with instance."""
|
||||
self.assertTrue(is_method_injection(Method('name', 'value')))
|
||||
self.assertTrue(di.is_method_injection(di.Method('name', 'value')))
|
||||
|
||||
def test_with_class(self):
|
||||
"""Test with class."""
|
||||
self.assertFalse(is_method_injection(Method))
|
||||
self.assertFalse(di.is_method_injection(di.Method))
|
||||
|
||||
def test_with_parent_class(self):
|
||||
"""Test with parent class."""
|
||||
self.assertFalse(is_method_injection(Injection))
|
||||
self.assertFalse(di.is_method_injection(di.Injection))
|
||||
|
||||
def test_with_string(self):
|
||||
"""Test with string."""
|
||||
self.assertFalse(is_method_injection('some_string'))
|
||||
self.assertFalse(di.is_method_injection('some_string'))
|
||||
|
||||
def test_with_object(self):
|
||||
"""Test with object."""
|
||||
self.assertFalse(is_method_injection(object()))
|
||||
self.assertFalse(di.is_method_injection(object()))
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user