Moved @named_data into main ddt.py module so it can be imported. (datadriventests#109)

* Move @named_data into main ddt.py module. Leave NamedData types in a named_data_types.py.

* Move named_data_types.py into ddt.py

Co-authored-by: Or Gadish <or.gadish@berkeleylights.com>

Author: orgadish

ddt.py

@@ -33,10 +33,30 @@
 INDEX_LEN = '%index_len'           # store the index length of the data
 
 
+# These are helper classes for @named_data that allow ddt tests to have meaningful names.
+class NamedDataList(list):
+    def __init__(self, name, *args):
+        super(NamedDataList, self).__init__(args)
+        self.name = name
+
+    def __str__(self):
+        return str(self.name)
+
+
+class NamedDataDict(dict):
+    def __init__(self, name, **kwargs):
+        super(NamedDataDict, self).__init__(kwargs)
+        self.name = name
+
+    def __str__(self):
+        return str(self.name)
+
+
+trivial_types = (type(None), bool, int, float, NamedDataList, NamedDataDict)
 try:
-    trivial_types = (type(None), bool, int, float, basestring)
+    trivial_types += (basestring, )
 except NameError:
-    trivial_types = (type(None), bool, int, float, str)
+    trivial_types += (str, )
 
 
 @unique
@@ -382,3 +402,68 @@ def wrapper(cls):
     # ``arg`` is the unittest's test class when decorating with ``@ddt`` while
     # it is ``None`` when decorating a test class with ``@ddt(k=v)``.
     return wrapper(arg) if inspect.isclass(arg) else wrapper
+
+
+def named_data(*named_values):
+    """
+    This decorator is to allow for meaningful names to be given to tests that would otherwise use @ddt.data and
+    @ddt.unpack.
+
+    Example of original ddt usage:
+        @ddt.ddt
+        class TestExample(TemplateTest):
+            @ddt.data(
+                [0, 1],
+                [10, 11]
+            )
+            @ddt.unpack
+            def test_values(self, value1, value2):
+                ...
+
+    Example of new usage:
+        @ddt.ddt
+        class TestExample(TemplateTest):
+            @named_data(
+                ['A', 0, 1],
+                ['B', 10, 11],
+            )
+            def test_values(self, value1, value2):
+                ...
+
+    Note that @unpack is not used.
+
+    :param list[Any] | dict[Any,Any] named_values: Each named_value should be a list with the name as the first
+        argument, or a dictionary with 'name' as one of the keys. The name will be coerced to a string and all other
+        values will be passed unchanged to the test.
+    """
+    type_of_first = None
+    values = []
+    for named_value in named_values:
+        if type_of_first is None:
+            type_of_first = type(named_value)
+
+        if not isinstance(named_value, type_of_first):
+            raise TypeError("@named_data expects all values to be of the same type.")
+
+        if isinstance(named_value, list):
+            value = NamedDataList(named_value[0], *named_value[1:])
+            type_of_first = type_of_first or list
+
+        elif isinstance(named_value, dict):
+            if "name" not in named_value.keys():
+                raise ValueError("@named_data expects a dictionary with a 'name' key.")
+            value = NamedDataDict(**named_value)
+            type_of_first = type_of_first or dict
+        else:
+            raise TypeError("@named_data expects a list or dictionary.")
+
+        # Remove the __doc__ attribute so @ddt.data doesn't add the NamedData class docstrings to the test name.
+        value.__doc__ = None
+
+        values.append(value)
+
+    def wrapper(func):
+        data(*values)(unpack(func))
+        return func
+
+    return wrapper

named_data.py

@@ -1,35 +1,33 @@
 import ddt
 import unittest
 
-from named_data import named_data
-
 
 @ddt.ddt
 class TestNamedData(unittest.TestCase):
     class NonTrivialClass(object):
         pass
 
-    @named_data(
+    @ddt.named_data(
         ['Single', 0, 1]
     )
     def test_single_named_value(self, value1, value2):
         self.assertGreater(value2, value1)
 
-    @named_data(
+    @ddt.named_data(
         ['1st', 1, 2],
         ['2nd', 3, 4]
     )
     def test_multiple_named_value_lists(self, value1, value2):
         self.assertGreater(value2, value1)
 
-    @named_data(
+    @ddt.named_data(
         dict(name='1st', value2=1, value1=0),
         {'name': '2nd', 'value2': 1, 'value1': 0}
     )
     def test_multiple_named_value_dicts(self, value1, value2):
         self.assertGreater(value2, value1)
 
-    @named_data(
+    @ddt.named_data(
         ['Passes', NonTrivialClass(), True],
         ['Fails', 1, False]
     )
@@ -39,7 +37,7 @@ def test_list_with_nontrivial_type(self, value, passes):
         else:
             self.assertNotIsInstance(value, self.NonTrivialClass)
 
-    @named_data(
+    @ddt.named_data(
         {'name': 'Passes', 'value': NonTrivialClass(), 'passes': True},
         {'name': 'Fails', 'value': 1, 'passes': False}
     )