'case_funcs_new' and 'case_info' merged again in module 'case_funcs', and _CaseInfo made private again. Now a clearer explanation is provided about why this class is private.

Author: Sylvain MARIE

pytest_cases/__init__.py

@@ -20,7 +20,7 @@
 from .case_parametrizer_legacy import cases_data, CaseDataGetter, get_all_cases_legacy, \
     get_pytest_parametrize_args_legacy, cases_fixture
 
-from .case_funcs_new import case, copy_case_info, set_case_id, get_case_id, get_case_marks, \
+from .case_funcs import case, copy_case_info, set_case_id, get_case_id, get_case_marks, \
     get_case_tags, matches_tag_query, is_case_class, is_case_function
 from .case_parametrizer_new import parametrize_with_cases, THIS_MODULE, get_all_cases, get_parametrize_args
 
@@ -38,7 +38,7 @@
 __all__ = [
     '__version__',
     # the submodules
-    'case_funcs_legacy', 'case_funcs_new', 'case_info',
+    'case_funcs_legacy', 'case_funcs',
     'case_parametrizer_legacy', 'case_parametrizer_new',
     'common_mini_six', 'common_others', 'common_pytest', 'common_pytest_lazy_values', 'common_pytest_marks',
     'filters',

pytest_cases/case_funcs_new.py renamed to pytest_cases/case_funcs.py

@@ -2,15 +2,15 @@
 #          + All contributors to <https://github.com/smarie/python-pytest-cases>
 #
 # License: 3-clause BSD, <https://github.com/smarie/python-pytest-cases/blob/master/LICENSE>
+from copy import copy
 from decopatch import function_decorator, DECORATED
 
-from .case_info import CaseInfo, _tags_match_query
-
 try:  # python 3.5+
     from typing import Type, Callable, Union, Optional, Any, Tuple, Dict, Iterable, List, Set
 except ImportError:
     pass
 
+from .common_mini_six import string_types
 from .common_pytest import safe_isclass
 from .common_pytest_marks import get_pytest_marks_on_function, markdecorators_as_tuple, markdecorators_to_markinfos
 
@@ -28,18 +28,117 @@
 """Prefix used by default to identify case functions within a module"""
 
 
+CASE_FIELD = '_pytestcase'
+
+
+class _CaseInfo(object):
+    """
+    Contains all information available about a case.
+    It is attached to a case function as an attribute.
+
+    Currently we do not wish to export an object-oriented API for this but rather a set of functions.
+    This is why this class remains private. Public functions to access the various elements in this class
+    are provided below (`get_case_id`, `get_case_tags` and `get_case_marks`). This is a safeguard to allow us
+    to change this class design later while easily guaranteeing retrocompatibility.
+    """
+    __slots__ = ('id', 'marks', 'tags')
+
+    def __init__(self,
+                 id=None,   # type: str
+                 marks=(),  # type: Tuple[MarkDecorator, ...]
+                 tags=()    # type: Tuple[Any]
+                 ):
+        self.id = id
+        self.marks = marks
+        self.tags = ()
+        self.add_tags(tags)
+
+    def __repr__(self):
+        return "_CaseInfo(id=%r,marks=%r,tags=%r)" % (self.id, self.marks, self.tags)
+
+    @classmethod
+    def get_from(cls,
+                 case_func,               # type: Callable
+                 create_if_missing=False  # type: bool
+                 ):
+        """ Return the _CaseInfo associated with case_fun or None
+
+        :param case_func:
+        :param create_if_missing: if no case information is present on the function, by default None is returned. If
+            this flag is set to True, a new _CaseInfo will be created and attached on the function, and returned.
+        """
+        ci = getattr(case_func, CASE_FIELD, None)
+        if ci is None and create_if_missing:
+            ci = cls()
+            ci.attach_to(case_func)
+        return ci
+
+    def attach_to(self,
+                  case_func  # type: Callable
+                  ):
+        """attach this case_info to the given case function"""
+        setattr(case_func, CASE_FIELD, self)
+
+    def add_tags(self,
+                 tags  # type: Union[Any, Union[List, Set, Tuple]]
+                 ):
+        """add the given tag or tags"""
+        if tags:
+            if isinstance(tags, string_types) or not isinstance(tags, (set, list, tuple)):
+                # a single tag, create a tuple around it
+                tags = (tags,)
+
+            self.tags += tuple(tags)
+
+    def matches_tag_query(self,
+                          has_tag=None,  # type: Union[str, Iterable[str]]
+                          ):
+        """
+        Returns True if the case function with this case_info is selected by the query
+
+        :param has_tag:
+        :return:
+        """
+        return _tags_match_query(self.tags, has_tag)
+
+    @classmethod
+    def copy_info(cls,
+                  from_case_func,
+                  to_case_func):
+        case_info = cls.get_from(from_case_func)
+        if case_info is not None:
+            # there is something to copy: do it
+            cp = copy(case_info)
+            cp.attach_to(to_case_func)
+
+
+def _tags_match_query(tags,    # type: Iterable[str]
+                      has_tag  # type: Optional[Union[str, Iterable[str]]]
+                      ):
+    """Internal routine to determine is all tags in `has_tag` are persent in `tags`
+    Note that `has_tag` can be a single tag, or none
+    """
+    if has_tag is None:
+        return True
+
+    if not isinstance(has_tag, (tuple, list, set)):
+        has_tag = (has_tag,)
+
+    return all(t in tags for t in has_tag)
+
+
 def copy_case_info(from_fun,  # type: Callable
                    to_fun     # type: Callable
                    ):
     """Copy all information from case function `from_fun` to `to_fun`."""
-    CaseInfo.copy_info(from_fun, to_fun)
+    _CaseInfo.copy_info(from_fun, to_fun)
 
 
 def set_case_id(id,        # type: str
                 case_func  # type: Callable
                 ):
     """Set an explicit id on case function `case_func`."""
-    ci = CaseInfo.get_from(case_func, create_if_missing=True)
+    ci = _CaseInfo.get_from(case_func, create_if_missing=True)
     ci.id = id
 
 
@@ -57,7 +156,7 @@ def get_case_id(case_func,                              # type: Callable
         case id.
     :return:
     """
-    _ci = CaseInfo.get_from(case_func)
+    _ci = _CaseInfo.get_from(case_func)
     _id = _ci.id if _ci is not None else None
 
     if _id is None:
@@ -95,7 +194,7 @@ def get_case_marks(case_func,                         # type: Callable
         returned. Otherwise (default) the marks are returned as is.
     :return:
     """
-    _ci = CaseInfo.get_from(case_func)
+    _ci = _CaseInfo.get_from(case_func)
     if _ci is None:
         _ci_marks = None
     else:
@@ -119,7 +218,7 @@ def get_case_marks(case_func,                         # type: Callable
 def get_case_tags(case_func  # type: Callable
                   ):
     """Return the tags on this case function or an empty tuple"""
-    ci = CaseInfo.get_from(case_func)
+    ci = _CaseInfo.get_from(case_func)
     return ci.tags if ci is not None else ()
 
 
@@ -198,7 +297,7 @@ def case_hi():
     :return:
     """
     marks = markdecorators_as_tuple(marks)
-    case_info = CaseInfo(id, marks, tags)
+    case_info = _CaseInfo(id, marks, tags)
     case_info.attach_to(case_func)
     return case_func
 

pytest_cases/case_funcs_legacy.py

@@ -19,7 +19,7 @@
 except ImportError:
     pass
 
-from .case_funcs_new import case
+from .case_funcs import case
 
 
 @function_decorator

pytest_cases/case_info.py

@@ -34,7 +34,7 @@
 from .common_pytest_marks import get_pytest_marks_on_function, make_marked_parameter_value
 
 from .case_funcs_legacy import is_case_generator, get_case_generator_details
-from .case_funcs_new import matches_tag_query
+from .case_funcs import matches_tag_query
 from .case_parametrizer_new import THIS_MODULE, extract_cases_from_module
 
 from .fixture_core2 import fixture_plus

pytest_cases/case_parametrizer_legacy.py

@@ -23,7 +23,7 @@
 from .common_pytest import safe_isclass, MiniMetafunc, is_fixture, get_fixture_name, inject_host, add_fixture_params
 
 from . import fixture
-from .case_funcs_new import matches_tag_query, is_case_function, is_case_class, CASE_PREFIX_FUN, copy_case_info, \
+from .case_funcs 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