Add tests for selector provider

docs/main/changelog.rst

@@ -7,6 +7,11 @@ that were made in every particular version.
 From version 0.7.6 *Dependency Injector* framework strictly 
 follows `Semantic versioning`_
 
+Development version
+-------------------
+- Fix ``Configuration.override()`` to return ``OverridingContext`` manager for non-dictionary
+values.
+
 3.18.1
 ------
 - Add interpolation of environment variables to ``Configuration.from_yaml()`` and

src/dependency_injector/containers.c

@@ -1289,13 +1289,13 @@ struct __pyx_obj_19dependency_injector_9providers_Container {
  * 
  * 
  * cdef class Selector(Provider):             # <<<<<<<<<<<<<<
- *     cdef object selector
- *     cdef dict providers
+ *     cdef object __selector
+ *     cdef dict __providers
  */
 struct __pyx_obj_19dependency_injector_9providers_Selector {
   struct __pyx_obj_19dependency_injector_9providers_Provider __pyx_base;
-  PyObject *selector;
-  PyObject *providers;
+  PyObject *__pyx___selector;
+  PyObject *__pyx___providers;
 };
 
 
@@ -1879,8 +1879,8 @@ static struct __pyx_vtabstruct_19dependency_injector_9providers_Container *__pyx
  * 
  * 
  * cdef class Selector(Provider):             # <<<<<<<<<<<<<<
- *     cdef object selector
- *     cdef dict providers
+ *     cdef object __selector
+ *     cdef dict __providers
  */
 
 struct __pyx_vtabstruct_19dependency_injector_9providers_Selector {

src/dependency_injector/providers.pxd

@@ -185,8 +185,8 @@ cdef class Container(Provider):
 
 
 cdef class Selector(Provider):
-    cdef object selector
-    cdef dict providers
+    cdef object __selector
+    cdef dict __providers
 
     cpdef object _provide(self, tuple args, dict kwargs)
 

src/dependency_injector/providers.pyx

@@ -1152,7 +1152,7 @@ cdef class Configuration(Object):
 
         value = self.__call__()
         if not isinstance(value, dict):
-            return
+            return overriding_context
 
         for name in value.keys():
             child_provider = self.__children.get(name)
@@ -2300,8 +2300,8 @@ cdef class Selector(Provider):
 
     def __init__(self, selector, **providers):
         """Initialize provider."""
-        self.selector = selector
-        self.providers = providers
+        self.__selector = selector
+        self.__providers = providers
         super(Selector, self).__init__()
 
     def __deepcopy__(self, memo):
@@ -2311,8 +2311,8 @@ cdef class Selector(Provider):
             return copied
 
         copied = self.__class__(
-            deepcopy(self.selector, memo)
-            **deepcopy(self.providers, memo),
+            deepcopy(self.__selector, memo),
+            **deepcopy(self.__providers, memo),
         )
         self._copy_overridings(copied, memo)
 
@@ -2325,22 +2325,43 @@ cdef class Selector(Provider):
                 '\'{cls}\' object has no attribute '
                 '\'{attribute_name}\''.format(cls=self.__class__.__name__,
                                               attribute_name=name))
-        if name not in self.providers:
+        if name not in self.__providers:
             raise AttributeError('Selector has no "{0}" provider'.format(name))
 
-        return getattr(self.container, name)
+        return self.__providers[name]
+
+    def __str__(self):
+        """Return string representation of provider.
+
+        :rtype: str
+        """
+
+        return '<{provider}({selector}, {providers}) at {address}>'.format(
+            provider='.'.join(( self.__class__.__module__, self.__class__.__name__)),
+            selector=self.__selector,
+            providers=', '.join((
+                '{0}={1}'.format(name, provider)
+                for name, provider in self.__providers.items()
+            )),
+            address=hex(id(self)),
+        )
+
+    @property
+    def providers(self):
+        """Return providers."""
+        return dict(self.__providers)
 
     cpdef object _provide(self, tuple args, dict kwargs):
         """Return single instance."""
-        selector_value = self.selector()
+        selector_value = self.__selector()
 
         if selector_value is None:
             raise Error('Selector value is undefined')
 
-        if selector_value not in self.providers:
+        if selector_value not in self.__providers:
             raise Error('Selector has no "{0}" provider'.format(selector_value))
 
-        return self.providers[selector_value](*args, **kwargs)
+        return self.__providers[selector_value](*args, **kwargs)
 
 
 cdef class Injection(object):

tests/unit/providers/test_selector_py2_py3.py

@@ -0,0 +1,152 @@
+"""Dependency injector selector provider unit tests."""
+
+import functools
+import itertools
+import sys
+
+import unittest2 as unittest
+
+from dependency_injector import providers
+
+
+class SelectorTests(unittest.TestCase):
+
+    selector = providers.Configuration()
+
+    def test_is_provider(self):
+        self.assertTrue(providers.is_provider(providers.Selector(self.selector)))
+
+    def test_call(self):
+        provider = providers.Selector(
+            self.selector,
+            one=providers.Object(1),
+            two=providers.Object(2),
+        )
+
+        with self.selector.override('one'):
+            self.assertEqual(provider(), 1)
+
+        with self.selector.override('two'):
+            self.assertEqual(provider(), 2)
+
+    def test_call_any_callable(self):
+        provider = providers.Selector(
+            functools.partial(next, itertools.cycle(['one', 'two'])),
+            one=providers.Object(1),
+            two=providers.Object(2),
+        )
+
+        self.assertEqual(provider(), 1)
+        self.assertEqual(provider(), 2)
+        self.assertEqual(provider(), 1)
+        self.assertEqual(provider(), 2)
+
+    def test_call_with_context_args(self):
+        provider = providers.Selector(
+            self.selector,
+            one=providers.Callable(lambda *args, **kwargs: (args, kwargs)),
+        )
+
+        with self.selector.override('one'):
+            args, kwargs = provider(1, 2, three=3, four=4)
+
+        self.assertEqual(args, (1, 2))
+        self.assertEqual(kwargs, {'three': 3, 'four': 4})
+
+    def test_getattr(self):
+        provider_one = providers.Object(1)
+        provider_two = providers.Object(2)
+
+        provider = providers.Selector(
+            self.selector,
+            one=provider_one,
+            two=provider_two,
+        )
+
+        self.assertIs(provider.one, provider_one)
+        self.assertIs(provider.two, provider_two)
+
+    def test_call_overridden(self):
+        provider = providers.Selector(self.selector, sample=providers.Object(1))
+        overriding_provider1 = providers.Selector(self.selector, sample=providers.Object(2))
+        overriding_provider2 = providers.Selector(self.selector, sample=providers.Object(3))
+
+        provider.override(overriding_provider1)
+        provider.override(overriding_provider2)
+
+        with self.selector.override('sample'):
+            self.assertEqual(provider(), 3)
+
+    def test_deepcopy(self):
+        provider = providers.Selector(self.selector)
+
+        provider_copy = providers.deepcopy(provider)
+
+        self.assertIsNot(provider, provider_copy)
+        self.assertIsInstance(provider, providers.Selector)
+
+    def test_deepcopy_from_memo(self):
+        provider = providers.Selector(self.selector)
+        provider_copy_memo = providers.Selector(self.selector)
+
+        provider_copy = providers.deepcopy(
+            provider,
+            memo={id(provider): provider_copy_memo},
+        )
+
+        self.assertIs(provider_copy, provider_copy_memo)
+
+    def test_deepcopy_overridden(self):
+        provider = providers.Selector(self.selector)
+        object_provider = providers.Object(object())
+
+        provider.override(object_provider)
+
+        provider_copy = providers.deepcopy(provider)
+        object_provider_copy = provider_copy.overridden[0]
+
+        self.assertIsNot(provider, provider_copy)
+        self.assertIsInstance(provider, providers.Selector)
+
+        self.assertIsNot(object_provider, object_provider_copy)
+        self.assertIsInstance(object_provider_copy, providers.Object)
+
+    def test_deepcopy_with_sys_streams(self):
+        provider = providers.Selector(
+            self.selector,
+            stdin=providers.Object(sys.stdin),
+            stdout=providers.Object(sys.stdout),
+            stderr=providers.Object(sys.stderr),
+
+        )
+
+        provider_copy = providers.deepcopy(provider)
+
+        self.assertIsNot(provider, provider_copy)
+        self.assertIsInstance(provider_copy, providers.Selector)
+
+        with self.selector.override('stdin'):
+            self.assertIs(provider(), sys.stdin)
+
+        with self.selector.override('stdout'):
+            self.assertIs(provider(), sys.stdout)
+
+        with self.selector.override('stderr'):
+            self.assertIs(provider(), sys.stderr)
+
+    def test_repr(self):
+        provider = providers.Selector(
+            self.selector,
+            one=providers.Object(1),
+            two=providers.Object(2),
+        )
+
+        self.assertEqual(
+            repr(provider),
+            '<dependency_injector.providers.Selector({0}, one={1}, two={2}) at {3}>'.format(
+                repr(self.selector),
+                repr(provider.one),
+                repr(provider.two),
+                hex(id(provider)),
+            ),
+        )