Add List provider unit tests

src/dependency_injector/providers.c

@@ -34739,18 +34739,25 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_4__str__(struct
   PyObject *__pyx_r = NULL;
   __Pyx_RefNannyDeclarations
   PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
   __Pyx_RefNannySetupContext("__str__", 0);
 
   /* "dependency_injector/providers.pyx":2021
  *         :rtype: str
  *         """
- *         return represent_provider(provider=self, provides=list)             # <<<<<<<<<<<<<<
+ *         return represent_provider(provider=self, provides=list(self.args))             # <<<<<<<<<<<<<<
  * 
  *     @property
  */
   __Pyx_XDECREF(__pyx_r);
-  __pyx_t_1 = __pyx_f_19dependency_injector_9providers_represent_provider(((PyObject *)__pyx_v_self), ((PyObject *)(&PyList_Type)), 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2021, __pyx_L1_error)
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2021, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2021, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __pyx_f_19dependency_injector_9providers_represent_provider(((PyObject *)__pyx_v_self), __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2021, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
   __pyx_r = __pyx_t_1;
   __pyx_t_1 = 0;
   goto __pyx_L0;
@@ -34766,6 +34773,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_4__str__(struct
   /* function exit code */
   __pyx_L1_error:;
   __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
   __Pyx_AddTraceback("dependency_injector.providers.List.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename);
   __pyx_r = NULL;
   __pyx_L0:;

src/dependency_injector/providers.pyx

@@ -2018,7 +2018,7 @@ cdef class List(Provider):
 
         :rtype: str
         """
-        return represent_provider(provider=self, provides=list)
+        return represent_provider(provider=self, provides=list(self.args))
 
     @property
     def args(self):

tests/unit/providers/test_list_py2_py3.py

@@ -0,0 +1,147 @@
+"""Dependency injector list provider unit tests."""
+
+import sys
+
+import unittest2 as unittest
+
+from dependency_injector import (
+    providers,
+    errors,
+)
+
+
+class Example(object):
+
+    def __init__(self, init_arg1=None, init_arg2=None, init_arg3=None,
+                 init_arg4=None):
+        self.init_arg1 = init_arg1
+        self.init_arg2 = init_arg2
+        self.init_arg3 = init_arg3
+        self.init_arg4 = init_arg4
+
+        self.attribute1 = None
+        self.attribute2 = None
+
+
+class FactoryTests(unittest.TestCase):
+
+    def test_is_provider(self):
+        self.assertTrue(providers.is_provider(providers.List()))
+
+    def test_call_with_init_positional_args(self):
+        provider = providers.List('i1', 'i2')
+
+        list1 = provider()
+        list2 = provider()
+
+        self.assertEqual(list1, ['i1', 'i2'])
+        self.assertEqual(list2, ['i1', 'i2'])
+
+        self.assertIsNot(list1, list2)
+
+    def test_fluent_interface(self):
+        provider = providers.List() \
+            .add_args(1, 2)
+
+        self.assertEqual(provider(), [1, 2])
+
+    def test_set_args(self):
+        provider = providers.List() \
+            .add_args(1, 2) \
+            .set_args(3, 4)
+        self.assertEqual(provider.args, tuple([3, 4]))
+
+    def test_clear_args(self):
+        provider = providers.List() \
+            .add_args(1, 2) \
+            .clear_args()
+        self.assertEqual(provider.args, tuple())
+
+    def test_call_overridden(self):
+        provider = providers.List(1, 2)
+        overriding_provider1 = providers.List(2, 3)
+        overriding_provider2 = providers.List(3, 4)
+
+        provider.override(overriding_provider1)
+        provider.override(overriding_provider2)
+
+        instance1 = provider()
+        instance2 = provider()
+
+        self.assertIsNot(instance1, instance2)
+        self.assertEqual(instance1, [3, 4])
+        self.assertEqual(instance2, [3, 4])
+
+    def test_deepcopy(self):
+        provider = providers.List(1, 2)
+
+        provider_copy = providers.deepcopy(provider)
+
+        self.assertIsNot(provider, provider_copy)
+        self.assertEqual(provider.args, provider_copy.args)
+        self.assertIsInstance(provider, providers.List)
+
+    def test_deepcopy_from_memo(self):
+        provider = providers.List(1, 2)
+        provider_copy_memo = providers.List(1, 2)
+
+        provider_copy = providers.deepcopy(
+            provider, memo={id(provider): provider_copy_memo})
+
+        self.assertIs(provider_copy, provider_copy_memo)
+
+    def test_deepcopy_args(self):
+        provider = providers.List()
+        dependent_provider1 = providers.Factory(list)
+        dependent_provider2 = providers.Factory(dict)
+
+        provider.add_args(dependent_provider1, dependent_provider2)
+
+        provider_copy = providers.deepcopy(provider)
+        dependent_provider_copy1 = provider_copy.args[0]
+        dependent_provider_copy2 = provider_copy.args[1]
+
+        self.assertNotEqual(provider.args, provider_copy.args)
+
+        self.assertIs(dependent_provider1.cls, dependent_provider_copy1.cls)
+        self.assertIsNot(dependent_provider1, dependent_provider_copy1)
+
+        self.assertIs(dependent_provider2.cls, dependent_provider_copy2.cls)
+        self.assertIsNot(dependent_provider2, dependent_provider_copy2)
+
+    def test_deepcopy_overridden(self):
+        provider = providers.List()
+        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.assertEqual(provider.args, provider_copy.args)
+        self.assertIsInstance(provider, providers.List)
+
+        self.assertIsNot(object_provider, object_provider_copy)
+        self.assertIsInstance(object_provider_copy, providers.Object)
+
+    def test_deepcopy_with_sys_streams(self):
+        provider = providers.List()
+        provider.add_args(sys.stdin, sys.stdout, sys.stderr)
+
+        provider_copy = providers.deepcopy(provider)
+
+        self.assertIsNot(provider, provider_copy)
+        self.assertIsInstance(provider_copy, providers.List)
+        self.assertIs(provider.args[0], sys.stdin)
+        self.assertIs(provider.args[1], sys.stdout)
+        self.assertIs(provider.args[2], sys.stderr)
+
+    def test_repr(self):
+        provider = providers.List(1, 2)
+
+        self.assertEqual(repr(provider),
+                         '<dependency_injector.providers.'
+                         'List({0}) at {1}>'.format(
+                             repr(list(provider.args)),
+                             hex(id(provider))))