parametrize_plus and fixture_plus are now deprecated in favour of parametrize and fixture, as most users seem to have adopted these names without issues.

Author: Sylvain MARIE

pytest_cases/__init__.py

@@ -9,12 +9,8 @@
 """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
-from .fixture_parametrize_plus import pytest_parametrize_plus, parametrize_plus, fixture_ref
-
-# additional symbols without the 'plus' suffix
-parametrize = parametrize_plus
-fixture = fixture_plus
+from .fixture_core2 import pytest_fixture_plus, fixture_plus, fixture, param_fixtures, param_fixture
+from .fixture_parametrize_plus import pytest_parametrize_plus, parametrize_plus, parametrize, fixture_ref
 
 
 from .case_funcs import case, copy_case_info, set_case_id, get_case_id, get_case_marks, \

pytest_cases/common_pytest.py

@@ -462,7 +462,7 @@ def get_marked_parameter_id(v):
     def ParameterSet(values,
                      id,  # noqa
                      marks):
-        """ Dummy function (not a class) used only by parametrize_plus """
+        """ Dummy function (not a class) used only by `parametrize` """
         if id is not None:
             raise ValueError("This should not happen as `pytest.param` does not exist in pytest 2")
 

pytest_cases/common_pytest_lazy_values.py

@@ -120,7 +120,7 @@ def partial_to_str(partialfun):
 # noinspection PyPep8Naming
 class _LazyValue(Lazy):
     """
-    A reference to a value getter, to be used in `parametrize_plus`.
+    A reference to a value getter, to be used in `parametrize`.
 
     A `lazy_value` is the same thing than a function-scoped fixture, except that the value getter function is not a
     fixture and therefore can neither be parametrized nor depend on fixtures. It should have no mandatory argument.
@@ -446,7 +446,7 @@ def lazy_value(valuegetter,  # type: Callable[[], Any]
                marks=()      # type: Union[MarkDecorator, Iterable[MarkDecorator]]
                ):
     """
-    Creates a reference to a value getter, to be used in `parametrize_plus`.
+    Creates a reference to a value getter, to be used in `parametrize`.
 
     A `lazy_value` is the same thing than a function-scoped fixture, except that the value getter function is not a
     fixture and therefore can neither be parametrized nor depend on fixtures. It should have no mandatory argument.

pytest_cases/common_pytest_marks.py

@@ -71,9 +71,9 @@ def get_parametrize_signature():
 
 class _ParametrizationMark:
     """
-    Container for the mark information that we grab from the fixtures (`@fixture_plus`)
+    Container for the mark information that we grab from the fixtures (`@fixture`)
 
-    Represents the information required by `@fixture_plus` to work.
+    Represents the information required by `@fixture` to work.
     """
     __slots__ = "param_names", "param_values", "param_ids"
 

pytest_cases/fixture_core1_unions.py

@@ -347,8 +347,8 @@ def _fixture_union(fixtures_dest,
                    **kwargs):
     """
     Internal implementation for fixture_union.
-    The "alternatives" have to be created beforehand, by the caller. This allows `fixture_union` and `parametrize_plus`
-    to use the same implementation while `parametrize_plus` uses customized "alternatives" containing more information.
+    The "alternatives" have to be created beforehand, by the caller. This allows `fixture_union` and `parametrize`
+    to use the same implementation while `parametrize` uses customized "alternatives" containing more information.
 
     :param fixtures_dest:
     :param name:
@@ -423,9 +423,9 @@ def unpack_fixture(argnames,  # type: str
 
     ```python
     import pytest
-    from pytest_cases import unpack_fixture, fixture_plus
+    from pytest_cases import unpack_fixture, fixture
 
-    @fixture_plus
+    @fixture
     @pytest.mark.parametrize("o", ['hello', 'world'])
     def c(o):
         return o, o[0]

pytest_cases/fixture_core2.py

@@ -113,7 +113,7 @@ def __param_fixture():
         if debug:
             print("Creating unparametrized fixture %r returning %r" % (argname, argvalue_to_return))
 
-        fix = fixture_plus(name=argname, scope=scope, autouse=autouse, ids=ids, hook=hook, **kwargs)(__param_fixture)
+        fix = fixture(name=argname, scope=scope, autouse=autouse, ids=ids, hook=hook, **kwargs)(__param_fixture)
     else:
         # create the fixture - set its name so that the optional hook can read it easily
         @with_signature("%s(request)" % argname)
@@ -123,8 +123,8 @@ def __param_fixture(request):
         if debug:
             print("Creating parametrized fixture %r returning %r" % (argname, argvalues))
 
-        fix = fixture_plus(name=argname, scope=scope, autouse=autouse, params=argvalues, ids=ids,
-                           hook=hook, **kwargs)(__param_fixture)
+        fix = fixture(name=argname, scope=scope, autouse=autouse, params=argvalues, ids=ids,
+                      hook=hook, **kwargs)(__param_fixture)
 
     # Dynamically add fixture to caller's module as explained in https://github.com/pytest-dev/pytest/issues/2424
     check_name_available(fixtures_dest, argname, if_name_exists=WARN, caller=param_fixture)
@@ -213,7 +213,7 @@ def _create_params_fixture(fixtures_dest,
     if debug:
         print("Creating parametrized 'root' fixture %r returning %r" % (root_fixture_name, argvalues))
 
-    @fixture_plus(name=root_fixture_name, autouse=autouse, scope=scope, hook=hook, **kwargs)
+    @fixture(name=root_fixture_name, autouse=autouse, scope=scope, hook=hook, **kwargs)
     @pytest.mark.parametrize(argnames, argvalues, ids=ids)
     @with_signature("%s(%s)" % (root_fixture_name, argnames))
     def _root_fixture(**_kwargs):
@@ -232,7 +232,7 @@ def _create_fixture(_param_idx):
             if debug:
                 print("Creating nonparametrized 'view' fixture %r returning %r[%s]" % (argname, root_fixture_name, _param_idx))
 
-            @fixture_plus(name=argname, scope=scope, autouse=autouse, hook=hook, **kwargs)
+            @fixture(name=argname, scope=scope, autouse=autouse, hook=hook, **kwargs)
             @with_signature("%s(%s)" % (argname, root_fixture_name))
             def _param_fixture(**_kwargs):
                 params = _kwargs.pop(root_fixture_name)
@@ -261,7 +261,7 @@ def _param_fixture(**_kwargs):
 @pytest.hookimpl(optionalhook=True)
 def pytest_fixture_plus(*args,
                         **kwargs):
-    warn("`pytest_fixture_plus` is deprecated. Please use the new alias `fixture_plus`. "
+    warn("`pytest_fixture_plus` and `fixture_plus` are deprecated. Please use the new alias `fixture`. "
          "See https://github.com/pytest-dev/pytest/issues/6475", category=DeprecationWarning, stacklevel=2)
     if len(args) == 1:
         if callable(args[0]):
@@ -272,14 +272,18 @@ def _fixture_plus(f):
     return _fixture_plus
 
 
+fixture_plus = pytest_fixture_plus
+"""Deprecated too"""
+
+
 @function_decorator
-def fixture_plus(scope="function",  # type: str
-                 autouse=False,     # type: bool
-                 name=None,         # type: str
-                 unpack_into=None,  # type: Iterable[str]
-                 hook=None,         # type: Callable[[Callable], Callable]
-                 fixture_func=DECORATED,  # noqa
-                 **kwargs):
+def fixture(scope="function",        # type: str
+            autouse=False,           # type: bool
+            name=None,               # type: str
+            unpack_into=None,        # type: Iterable[str]
+            hook=None,               # type: Callable[[Callable], Callable]
+            fixture_func=DECORATED,  # noqa
+            **kwargs):
     """ decorator to mark a fixture factory function.
 
     Identical to `@pytest.fixture` decorator, except that
@@ -389,7 +393,7 @@ def _decorate_fixture_plus(fixture_func,
     else:
         if 'params' in kwargs:
             raise ValueError(
-                "With `fixture_plus` you cannot mix usage of the keyword argument `params` and of "
+                "With `fixture` you cannot mix usage of the keyword argument `params` and of "
                 "the pytest.mark.parametrize marks")
 
     # (2) create the huge "param" containing all params combined
@@ -403,7 +407,7 @@ def _decorate_fixture_plus(fixture_func,
 
         # check number of parameter names in this parameterset
         if len(pmark.param_names) < 1:
-            raise ValueError("Fixture function '%s' decorated with '@fixture_plus' has an empty parameter "
+            raise ValueError("Fixture function '%s' decorated with '@fixture' has an empty parameter "
                              "name in a @pytest.mark.parametrize mark")
 
         # remember the argnames

pytest_cases/fixture_parametrize_plus.py

@@ -32,7 +32,7 @@
 from .fixture__creation import check_name_available, CHANGE, WARN
 from .fixture_core1_unions import InvalidParamsList, NOT_USED, UnionFixtureAlternative, _make_fixture_union, \
     _make_unpack_fixture, UnionIdMakers
-from .fixture_core2 import _create_param_fixture, fixture_plus
+from .fixture_core2 import _create_param_fixture, fixture
 
 
 def _fixture_product(fixtures_dest,
@@ -102,8 +102,8 @@ def _new_fixture(request, **all_fixtures):
     _new_fixture.__name__ = name
 
     # finally create the fixture per se.
-    # WARNING we do not use pytest.fixture but fixture_plus so that NOT_USED is discarded
-    f_decorator = fixture_plus(scope=scope, autouse=autouse, hook=hook, **kwargs)
+    # WARNING we do not use pytest.fixture but fixture so that NOT_USED is discarded
+    f_decorator = fixture(scope=scope, autouse=autouse, hook=hook, **kwargs)
     fix = f_decorator(_new_fixture)
 
     # Dynamically add fixture to caller's module as explained in https://github.com/pytest-dev/pytest/issues/2424
@@ -123,7 +123,7 @@ def _new_fixture(request, **all_fixtures):
 
 class fixture_ref(object):  # noqa
     """
-    A reference to a fixture, to be used in `@parametrize_plus`.
+    A reference to a fixture, to be used in `@parametrize`.
     You can create it from a fixture name or a fixture object (function).
     """
     __slots__ = 'fixture', 'theoretical_size', '_id'
@@ -199,13 +199,16 @@ def __repr__(self):
 @pytest.hookimpl(optionalhook=True)
 def pytest_parametrize_plus(*args,
                             **kwargs):
-    warn("`pytest_parametrize_plus` is deprecated. Please use the new alias `parametrize_plus`. "
+    warn("`pytest_parametrize_plus` and `parametrize_plus` are deprecated. Please use the new alias `parametrize`. "
          "See https://github.com/pytest-dev/pytest/issues/6475", category=DeprecationWarning, stacklevel=2)
-    return parametrize_plus(*args, **kwargs)
+    return parametrize(*args, **kwargs)
+
+
+parametrize_plus = pytest_parametrize_plus
 
 
 class ParamAlternative(UnionFixtureAlternative):
-    """Defines an "alternative", used to parametrize a fixture union in the context of parametrize_plus
+    """Defines an "alternative", used to parametrize a fixture union in the context of parametrize
 
     It is similar to a union fixture alternative, except that it also remembers the parameter argnames.
     They are used to generate the test id corresponding to this alternative. See `_get_minimal_id` implementations.
@@ -593,17 +596,17 @@ def nostyle(cls,
 _IDGEN = object()
 
 
-def parametrize_plus(argnames=None,       # type: str
-                     argvalues=None,      # type: Iterable[Any]
-                     indirect=False,      # type: bool
-                     ids=None,            # type: Union[Callable, Iterable[str]]
-                     idstyle=None,        # type: Union[str, Callable]
-                     idgen=_IDGEN,        # type: Union[str, Callable]
-                     auto_refs=True,      # type: bool
-                     scope=None,          # type: str
-                     hook=None,           # type: Callable[[Callable], Callable]
-                     debug=False,         # type: bool
-                     **args):
+def parametrize(argnames=None,   # type: str
+                argvalues=None,  # type: Iterable[Any]
+                indirect=False,  # type: bool
+                ids=None,        # type: Union[Callable, Iterable[str]]
+                idstyle=None,    # type: Union[str, Callable]
+                idgen=_IDGEN,    # type: Union[str, Callable]
+                auto_refs=True,  # type: bool
+                scope=None,      # type: str
+                hook=None,       # type: Callable[[Callable], Callable]
+                debug=False,     # type: bool
+                **args):
     """
     Equivalent to `@pytest.mark.parametrize` but also supports
 
@@ -918,7 +921,7 @@ def parametrize_plus_decorate(test_func, fixtures_dest):
             main_fixture_style_template = "%s_%s"
             fixture_union_name = main_fixture_style_template % (test_func_name, param_names_str)
             fixture_union_name = check_name_available(fixtures_dest, fixture_union_name, if_name_exists=CHANGE,
-                                                      caller=parametrize_plus)
+                                                      caller=parametrize)
 
             # Retrieve (if ref) or create (for normal argvalues) the fixtures that we will union
             fixture_alternatives = []
@@ -984,7 +987,7 @@ def parametrize_plus_decorate(test_func, fixtures_dest):
                 _idstyle = idstyle
 
             # note: the function automatically registers it in the module
-            _make_fixture_union(fixtures_dest, name=fixture_union_name, hook=hook, caller=parametrize_plus,
+            _make_fixture_union(fixtures_dest, name=fixture_union_name, hook=hook, caller=parametrize,
                                 fix_alternatives=fixture_alternatives, unique_fix_alt_names=fix_alt_names,
                                 idstyle=_idstyle, scope=scope)