@parametrize_with_cases now by default (cases=AUTO) looks for both file naming patterns test_<name>_cases.py and cases_<name>.py. Removed the AUTO2 constant. Fixed #140

Nested classes containing cases are now officially supported (they were, but undocumented). Fixed #160

Author: Sylvain MARIE

docs/api_reference.md

@@ -197,7 +197,7 @@ Returns True if the provided object is a function or callable and, if `check_pre
 
 A decorator for test functions or fixtures, to parametrize them based on test cases. It works similarly to [`@pytest.mark.parametrize`](https://docs.pytest.org/en/stable/parametrize.html): argnames represent a coma-separated string of arguments to inject in the decorated test function or fixture. The argument values (`argvalues` in [`@pytest.mark.parametrize`](https://docs.pytest.org/en/stable/parametrize.html)) are collected from the various case functions found according to `cases`, and injected as lazy values so that the case functions are called just before the test or fixture is executed.
 
-By default (`cases=AUTO`) the list of test cases is automatically drawn from the python module file named `test_<name>_cases.py` where `test_<name>` is the current module name. An alternate naming convention `cases_<name>.py` can be used by setting `cases=AUTO2`.
+By default (`cases=AUTO`) the list of test cases is automatically drawn from the python module file named `test_<name>_cases.py` or if not found, `case_<name>.py`,  where `test_<name>` is the current module name.
 
 Finally, the `cases` argument also accepts an explicit case function, cases-containing class, module or module name; or a list of such elements. Note that both absolute and relative module names are suported.
 
@@ -216,7 +216,7 @@ argvalues = get_parametrize_args(host_class_or_module_of_f, cases_funs)
 
  - `argnames`: same than in `@pytest.mark.parametrize`
 
- - `cases`: a case function, a class containing cases, a module object or a module name string (relative module names accepted). Or a list of such items. You may use `THIS_MODULE` or `'.'` to include current module. `AUTO` (default) means that the module named `test_<name>_cases.py` will be loaded, where `test_<name>.py` is the module file of the decorated function. `AUTO2` allows you to use the alternative naming scheme `case_<name>.py`. When a module is listed, all of its functions matching the `prefix`, `filter` and `has_tag` are selected, including those functions nested in classes following naming pattern `*Case*`. When classes are explicitly provided in the list, they can have any name and do not need to follow this `*Case*` pattern.
+ - `cases`: a case function, a class containing cases, a module object or a module name string (relative module names accepted). Or a list of such items. You may use `THIS_MODULE` or `'.'` to include current module. `AUTO` (default) means that the module named `test_<name>_cases.py` or if not found, `case_<name>.py`, will be loaded, where `test_<name>.py` is the module file of the decorated function. When a module is listed, all of its functions matching the `prefix`, `filter` and `has_tag` are selected, including those functions nested in classes following naming pattern `*Case*`. Nested subclasses are taken into account, as long as they follow the `*Case*` naming pattern. When classes are explicitly provided in the list, they can have any name and do not need to follow this `*Case*` pattern.
 
  - `prefix`: the prefix for case functions. Default is 'case_' but you might wish to use different prefixes to denote different kind of cases, for example 'data_', 'algo_', 'user_', etc.
 

pytest_cases/__init__.py

@@ -3,7 +3,10 @@
 #
 # License: 3-clause BSD, <https://github.com/smarie/python-pytest-cases/blob/master/LICENSE>
 from .common_pytest_lazy_values import lazy_value, is_lazy
-from .common_others import unfold_expected_err, assert_exception, AUTO, AUTO2
+from .common_others import unfold_expected_err, assert_exception, AUTO
+
+AUTO2 = AUTO
+"""Deprecated symbol, for retrocompatibility. Will be dropped soon."""
 
 from .fixture_core1_unions import fixture_union, NOT_USED, unpack_fixture, ignore_unused
 from .fixture_core2 import pytest_fixture_plus, fixture_plus, param_fixtures, param_fixture

pytest_cases/case_parametrizer_new.py

@@ -17,7 +17,7 @@
     pass
 
 from .common_mini_six import string_types
-from .common_others import get_code_first_line, AUTO, AUTO2, qname, funcopy
+from .common_others import get_code_first_line, AUTO, qname, funcopy
 from .common_pytest_marks import copy_pytest_marks, make_marked_parameter_value, remove_pytest_mark, filter_marks
 from .common_pytest_lazy_values import lazy_value
 from .common_pytest import safe_isclass, MiniMetafunc, is_fixture, get_fixture_name, inject_host, add_fixture_params
@@ -26,7 +26,13 @@
 from .case_funcs_new import matches_tag_query, is_case_function, is_case_class, CASE_PREFIX_FUN, copy_case_info, \
     get_case_id, get_case_marks, GEN_BY_US
 from .fixture__creation import check_name_available, CHANGE
-from .fixture_parametrize_plus import fixture_ref, _parametrize_plus, _IDGEN
+from .fixture_parametrize_plus import fixture_ref, _parametrize_plus
+
+try:
+    ModuleNotFoundError
+except NameError:
+    # python < 3.6
+    ModuleNotFoundError = ImportError
 
 
 THIS_MODULE = object()
@@ -36,7 +42,7 @@
     from typing import Literal, Optional  # noqa
     from types import ModuleType  # noqa
 
-    ModuleRef = Union[str, ModuleType, Literal[AUTO], Literal[AUTO2], Literal[THIS_MODULE]]  # noqa
+    ModuleRef = Union[str, ModuleType, Literal[AUTO], Literal[THIS_MODULE]]  # noqa
 
 except:  # noqa
     pass
@@ -66,8 +72,7 @@ def parametrize_with_cases(argnames,                # type: Union[str, List[str]
     just before the test or fixture is executed.
 
     By default (`cases=AUTO`) the list of test cases is automatically drawn from the python module file named
-    `test_<name>_cases.py` where `test_<name>` is the current module name. An alternate naming convention
-    `cases_<name>.py` can be used by setting `cases=AUTO2`.
+    `test_<name>_cases.py` or if not found, `cases_<name>.py`, where `test_<name>` is the current module name.
 
     Finally, the `cases` argument also accepts an explicit case function, cases-containing class, module or module name;
     or a list of such elements. Note that both absolute and relative module names are suported.
@@ -86,11 +91,12 @@ def parametrize_with_cases(argnames,                # type: Union[str, List[str]
     :param argnames: same than in @pytest.mark.parametrize
     :param cases: a case function, a class containing cases, a module object or a module name string (relative module
         names accepted). Or a list of such items. You may use `THIS_MODULE` or `'.'` to include current module.
-        `AUTO` (default) means that the module named `test_<name>_cases.py` will be loaded, where `test_<name>.py` is
-        the module file of the decorated function. `AUTO2` allows you to use the alternative naming scheme
-        `case_<name>.py`. When a module is listed, all of its functions matching the `prefix`, `filter` and `has_tag`
-        are selected, including those functions nested in classes following naming pattern `*Case*`. When classes are
-        explicitly provided in the list, they can have any name and do not need to follow this `*Case*` pattern.
+        `AUTO` (default) means that the module named `test_<name>_cases.py` or if not found, `case_<name>.py`, will be
+        loaded, where `test_<name>.py` is the module file of the decorated function. When a module is listed, all of
+        its functions matching the `prefix`, `filter` and `has_tag` are selected, including those functions nested in
+        classes following naming pattern `*Case*`. Nested subclasses are taken into account, as long as they follow the
+        `*Case*` naming pattern. When classes are explicitly provided in the list, they can have any name and do not
+        need to follow this `*Case*` pattern.
     :param prefix: the prefix for case functions. Default is 'case_' but you might wish to use different prefixes to
         denote different kind of cases, for example 'data_', 'algo_', 'user_', etc.
     :param glob: an optional glob-like pattern for case ids, for example "*_success" or "*_failure". Note that this
@@ -263,9 +269,9 @@ def get_all_cases(parametrization_target,  # type: Callable
         else:
             # module
             if c is AUTO:
+                # First try `test_<name>_cases.py` Then `case_<name>.py`
                 c = import_default_cases_module(parametrization_target)
-            elif c is AUTO2:
-                c = import_default_cases_module(parametrization_target, alt_name=True)
+
             elif c is THIS_MODULE or c == '.':
                 c = caller_module_name
             new_cases = extract_cases_from_module(c, package_name=parent_pkg_name, case_fun_prefix=prefix)
@@ -504,33 +510,35 @@ def _get_fixture_cases(module  # type: ModuleType
     return cache
 
 
-def import_default_cases_module(f, alt_name=False):
+def import_default_cases_module(f):
     """
     Implements the `module=AUTO` behaviour of `@parameterize_cases`: based on the decorated test function `f`,
-    it finds its containing module name "<test_module>.py" and then tries to import the python module
-    "<test_module>_cases.py".
+    it finds its containing module name "test_<module>.py" and then tries to import the python module
+    "test_<module>_cases.py".
 
-    Alternately if `alt_name=True` the name pattern to use will be `cases_<module>.py` when the test module is named
-    `test_<module>.py`.
+    If the module is not found it looks for the alternate file `cases_<module>.py`.
 
     :param f: the decorated test function
-    :param alt_name: a boolean (default False) to use the alternate naming scheme.
     :return:
     """
-    if alt_name:
+    # First try `test_<name>_cases.py`
+    cases_module_name1 = "%s_cases" % f.__module__
+    try:
+        cases_module = import_module(cases_module_name1)
+    except ModuleNotFoundError:
+        # Then try `case_<name>.py`
         parts = f.__module__.split('.')
         assert parts[-1][0:5] == 'test_'
-        cases_module_name = "%s.cases_%s" % ('.'.join(parts[:-1]), parts[-1][5:])
-    else:
-        cases_module_name = "%s_cases" % f.__module__
+        cases_module_name2 = "%s.cases_%s" % ('.'.join(parts[:-1]), parts[-1][5:])
+        try:
+            cases_module = import_module(cases_module_name2)
+        except ModuleNotFoundError:
+            # Nothing worked
+            raise ValueError("Error importing test cases module to parametrize function %r: unable to import AUTO "
+                             "cases module %r nor %r. Maybe you wish to import cases from somewhere else ? In that case"
+                             "please specify `cases=...`."
+                             % (f, cases_module_name1, cases_module_name2))
 
-    try:
-        cases_module = import_module(cases_module_name)
-    except ImportError:
-        raise ValueError("Error importing test cases module to parametrize function %r: unable to import AUTO%s "
-                         "cases module %r. Maybe you wish to import cases from somewhere else ? In that case please "
-                         "specify `cases=...`."
-                         % (f, '2' if alt_name else '', cases_module_name))
     return cases_module
 
 

pytest_cases/common_others.py

@@ -210,9 +210,6 @@ def __exit__(self, exc_type, exc_val, exc_tb):
 AUTO = object()
 """Marker for automatic defaults"""
 
-AUTO2 = object()
-"""Marker that alternate automatic defaults"""
-
 
 def get_function_host(func):
     """

pytest_cases/tests/cases/doc/cases_doc.py renamed to pytest_cases/tests/cases/doc/cases_doc_alternate.py

@@ -5,10 +5,10 @@
 import pytest
 
 from pytest_harvest import get_session_synthesis_dct
-from pytest_cases import parametrize_with_cases, AUTO2, fixture, case
+from pytest_cases import parametrize_with_cases, fixture, case, AUTO
 from pytest_cases.common_pytest_marks import has_pytest_param
 
-from . import cases_doc
+from . import cases_doc_alternate
 from .example import foo
 
 
@@ -35,28 +35,6 @@ def test_foo_default_cases_file_synthesis(request):
     ]
 
 
-@parametrize_with_cases("a,b", cases=AUTO2)
-def test_foo_alternate_cases_file_and_two_marked_skip(a, b):
-    assert isinstance(foo(a, b), tuple)
-
-
-def test_foo_alternate_cases_file_and_two_marked_skip_synthesis(request):
-    results_dct = get_session_synthesis_dct(request, filter=test_foo_alternate_cases_file_and_two_marked_skip,
-                                            test_id_format='function')
-    if has_pytest_param:
-        assert list(results_dct) == [
-            'test_foo_alternate_cases_file_and_two_marked_skip[hello]',
-            'test_foo_alternate_cases_file_and_two_marked_skip[two_negative_ints0]',
-            'test_foo_alternate_cases_file_and_two_marked_skip[two_negative_ints1]'
-        ]
-    else:
-        assert list(results_dct) == [
-            'test_foo_alternate_cases_file_and_two_marked_skip[0hello[0]-hello[1]]',
-            'test_foo_alternate_cases_file_and_two_marked_skip[2two_negative_ints[0]-two_negative_ints[1]]',
-            'test_foo_alternate_cases_file_and_two_marked_skip[4two_negative_ints[0]-two_negative_ints[1]]'
-        ]
-
-
 def strange_ints():
     """ Inputs are two negative integers """
     return -1, -2
@@ -138,7 +116,7 @@ def test_foo_cls_synthesis(request):
         ]
 
 
-@parametrize_with_cases("a,b", cases=(CasesFoo, strange_ints, cases_doc, CasesFoo, '.test_doc_cases'))
+@parametrize_with_cases("a,b", cases=(CasesFoo, strange_ints, cases_doc_alternate, CasesFoo, '.test_doc_cases'))
 def test_foo_cls_list(a, b):
     assert isinstance(foo(a, b), tuple)
 
@@ -151,7 +129,7 @@ def test_foo_cls_list_synthesis(request):
         'test_foo_cls_list[two_negative_ints0]',
         # strange_ints
         'test_foo_cls_list[strange_ints]',
-        # cases_doc.py
+        # cases_doc_alternate.py
         'test_foo_cls_list[hello]',
         'test_foo_cls_list[two_negative_ints1]',
         'test_foo_cls_list[two_negative_ints2]',
@@ -169,7 +147,7 @@ def test_foo_cls_list_synthesis(request):
 
 
 @fixture
-@parametrize_with_cases("a,b")
+@parametrize_with_cases("a,b", cases=AUTO)  # just checking that explicit AUTO is same as implicit
 def c(a, b):
     return a + b
 

pytest_cases/tests/cases/doc/test_doc.py

@@ -0,0 +1,33 @@
+from pytest_harvest import get_session_synthesis_dct
+
+from pytest_cases.common_pytest_marks import has_pytest_param
+from pytest_cases import parametrize_with_cases, AUTO
+
+from .example import foo
+
+
+@parametrize_with_cases("a,b")
+def test_foo_alternate_cases_file_and_two_marked_skip(a, b):
+    assert isinstance(foo(a, b), tuple)
+
+
+@parametrize_with_cases("a,b", cases=AUTO)
+def test_foo_alternate_cases_file_and_two_marked_skip(a, b):
+    assert isinstance(foo(a, b), tuple)
+
+
+def test_foo_alternate_cases_file_and_two_marked_skip_synthesis(request):
+    results_dct = get_session_synthesis_dct(request, filter=test_foo_alternate_cases_file_and_two_marked_skip,
+                                            test_id_format='function')
+    if has_pytest_param:
+        assert list(results_dct) == [
+            'test_foo_alternate_cases_file_and_two_marked_skip[hello]',
+            'test_foo_alternate_cases_file_and_two_marked_skip[two_negative_ints0]',
+            'test_foo_alternate_cases_file_and_two_marked_skip[two_negative_ints1]'
+        ]
+    else:
+        assert list(results_dct) == [
+            'test_foo_alternate_cases_file_and_two_marked_skip[0hello[0]-hello[1]]',
+            'test_foo_alternate_cases_file_and_two_marked_skip[2two_negative_ints[0]-two_negative_ints[1]]',
+            'test_foo_alternate_cases_file_and_two_marked_skip[4two_negative_ints[0]-two_negative_ints[1]]'
+        ]

pytest_cases/tests/cases/doc/test_doc_alternate.py

@@ -0,0 +1,18 @@
+from pytest_cases import parametrize_with_cases
+
+
+class FooCases:
+    def case_1(self):
+        return 1
+
+    class SubFooCases:
+        def case_2(self):
+            return 2
+
+    def case_3(self):
+        return 3
+
+
+@parametrize_with_cases("x", FooCases)
+def test_foo(x):
+    print(x)