Cases generators can now support explicit name lists, and name generator callables, in addition to the name template strings. Fixed #24

Author: Sylvain MARIE

pytest_cases/case_funcs.py

@@ -108,7 +108,7 @@ def test_target(target  # type: Any
 test_target.__test__ = False  # disable this function in pytest (otherwise name starts with 'test' > it will appear)
 
 
-def cases_generator(name_template,    # type: str
+def cases_generator(names=None,       # type: Union[str, Callable[[Any], str], Iterable[str]]
                     lru_cache=False,  # type: bool
                     **param_ranges    # type: Iterable[Any]
                     ):
@@ -127,9 +127,11 @@ def cases_generator(name_template,    # type: str
     >>>     outs = i+1, i+2
     >>>     return ins, outs, None
 
-    :param name_template: a name template, that will be transformed into the case name using
-        `name_template.format(**params)` for each case, where params is the dictionary of parameter values for this
-        generated case.
+    :param names: a name template, that will be transformed into the case name using
+        `names.format(**params)` for each case, where `params` is the dictionary of parameter values for this
+        generated case. Alternately a callable returning a string can be provided, in which case
+        `names(**params)` will be used. Finally an explicit list of names can be provided, in which case it should have
+        the correct length (an error will be raised otherwise).
     :param lru_cache: a boolean (default False) indicating if the generated cases should be cached. This is identical
         to decorating the function with an additional `@lru_cache(maxsize=n)` where n is the total number of generated
         cases.
@@ -141,7 +143,7 @@ def cases_generator(name_template,    # type: str
 
     def cases_generator_decorator(test_func):
         kwarg_values = list(product(*param_ranges.values()))
-        setattr(test_func, _GENERATOR_FIELD, (name_template, param_ranges.keys(), kwarg_values))
+        setattr(test_func, _GENERATOR_FIELD, (names, param_ranges.keys(), kwarg_values))
         if lru_cache:
             nb_cases = len(kwarg_values)
             # decorate the function with the appropriate lru cache size

pytest_cases/main.py

@@ -727,15 +727,30 @@ def _get_case_getter_s(f,
     if gen:
         already_used_names = []
 
-        name_template, param_ids, all_param_values_combinations = gen
+        names, param_ids, all_param_values_combinations = gen
+
+        if isinstance(names, str):
+            # then this is a string formatter
+            _formatter = names
+            names = lambda **params: _formatter.format(**params)
+
         nb_cases_generated = len(all_param_values_combinations)
+        if not callable(names):
+            if len(names) != nb_cases_generated:
+                raise ValueError("An explicit list of names has been provided but it has not the same length (%s) than"
+                                 " the number of cases to be generated (%s)" % (len(names), nb_cases_generated))
 
         for gen_case_id, case_params_values in enumerate(all_param_values_combinations):
             # build the dictionary of parameters for the case functions
             gen_case_params_dct = dict(zip(param_ids, case_params_values))
 
             # generate the case name by applying the name template
-            gen_case_name = name_template.format(**gen_case_params_dct)
+            if callable(names):
+                gen_case_name = names(**gen_case_params_dct)
+            else:
+                # an explicit list is provided
+                gen_case_name = names[gen_case_id]
+
             if gen_case_name in already_used_names:
                 raise ValueError("Generated function names for generator case function {} are not "
                                  "unique. Please use all parameter names in the string format variables"

pytest_cases/tests/simple/test_generators.py

@@ -23,14 +23,33 @@ def case_simple():
 #         yield ins, outs, None
 
 
-@cases_generator("test with i={i}, j={j}", i=range(2), j=range(3))
+@cases_generator("test with i={i}, j={j} and name template", i=range(2), j=range(3))
 def case_simple_generator(i, j):
     # type: (...) -> CaseData
     ins = dict(a=i, b=j)
     outs = i+1, j+1
     return ins, outs, None
 
 
+@cases_generator("test with i={i}, j={j} and names callable provider", i=range(2), j=range(3))
+def case_simple_generator_callable_name(i, j):
+    # type: (...) -> CaseData
+    ins = dict(a=i, b=j)
+    outs = i+1, j+1
+    return ins, outs, None
+
+
+names_list = ["test with i={i}, j={j} and explicit names list".format(i=i, j=j) for i in range(2) for j in range(3)]
+
+
+@cases_generator(names_list, i=range(2), j=range(3))
+def case_simple_generator_explicit_name_list(i, j):
+    # type: (...) -> CaseData
+    ins = dict(a=i, b=j)
+    outs = i+1, j+1
+    return ins, outs, None
+
+
 @cases_data(module=THIS_MODULE)
 def test_with_cases_decorated(case_data  # type: CaseDataGetter
                               ):