Add tests and a little improvement

Author: sadra-barikbin

src/_pytest/python.py

@@ -1175,38 +1175,35 @@ def get_direct_param_fixture_func(request: FixtureRequest) -> Any:
     return request.param
 
 
-def resolve_unique_values_and_their_indices_in_parametersets(
+def resolve_values_indices_in_parametersets(
     argnames: Sequence[str],
     parametersets: Sequence[ParameterSet],
-) -> Tuple[Dict[str, List[object]], List[Tuple[int]]]:
-    """Resolve unique values and represent parameter sets by values' indices. The index of
-    a value in a parameter set is determined by where the value appears in the existing values
-    of the argname for the first time. For example, given ``argnames`` and ``parametersets``
-    below, the result would be:
+) -> List[Tuple[int]]:
+    """Resolve indices of the values in parameter sets. The index of a value is determined by
+    where the value first appears in the existing values of the argname. For example, given
+    ``argnames`` and ``parametersets`` below, the result would be:
 
     ::
 
         argnames = ["A", "B", "C"]
         parametersets = [("a1", "b1", "c1"), ("a1", "b2", "c1"), ("a1", "b3", "c2")]
-        result[0] = {"A": ["a1"], "B": ["b1", "b2", "b3"], "C": ["c1", "c2"]}
-        result[1] = [(0, 0, 0), (0, 1, 0), (0, 2, 1)]
+        result = [(0, 0, 0), (0, 1, 0), (0, 2, 1)]
 
     result is used in reordering tests to keep items using the same fixture close together.
 
     :param argnames:
-        Argument names passed to ``parametrize()``.
+        Argument names passed to ``metafunc.parametrize()``.
     :param parametersets:
         The parameter sets, each containing a set of values corresponding
         to ``argnames``.
     :returns:
-        Tuple of unique parameter values and their indices in parametersets.
+        List of tuples of indices, each tuple for a parameter set.
     """
     indices = []
     argname_value_indices_for_hashable_ones: Dict[str, Dict[object, int]] = defaultdict(
         dict
     )
     argvalues_count: Dict[str, int] = defaultdict(lambda: 0)
-    unique_values: Dict[str, List[object]] = defaultdict(list)
     for i, argname in enumerate(argnames):
         argname_indices = []
         for parameterset in parametersets:
@@ -1221,13 +1218,11 @@ def resolve_unique_values_and_their_indices_in_parametersets(
                 ] = argvalues_count[argname]
                 argname_indices.append(argvalues_count[argname])
                 argvalues_count[argname] += 1
-                unique_values[argname].append(value)
             except TypeError:  # `value` is not hashable
                 argname_indices.append(argvalues_count[argname])
                 argvalues_count[argname] += 1
-                unique_values[argname].append(value)
         indices.append(argname_indices)
-    return unique_values, list(zip(*indices))
+    return list(zip(*indices))
 
 
 # Used for storing artificial fixturedefs for direct parametrization.
@@ -1384,12 +1379,7 @@ def parametrize(
         ids = self._resolve_parameter_set_ids(
             argnames, ids, parametersets, nodeid=self.definition.nodeid
         )
-        (
-            params_values,
-            param_indices_list,
-        ) = resolve_unique_values_and_their_indices_in_parametersets(
-            argnames, parametersets
-        )
+        param_indices_list = resolve_values_indices_in_parametersets(argnames, parametersets)
         # Store used (possibly generated) ids with parametrize Marks.
         if _param_mark and _param_mark._param_ids_from and generated_ids is None:
             object.__setattr__(_param_mark._param_ids_from, "_param_ids_generated", ids)
@@ -1427,7 +1417,7 @@ def parametrize(
                     argname=argname,
                     func=get_direct_param_fixture_func,
                     scope=scope_,
-                    params=params_values[argname],
+                    params=None,
                     unittest=False,
                     ids=None,
                     is_pseudo=True,

testing/python/fixtures.py

@@ -2,7 +2,6 @@
 import sys
 import textwrap
 from pathlib import Path
-from unittest.mock import Mock
 
 import pytest
 from _pytest import fixtures
@@ -13,7 +12,6 @@
 from _pytest.pytester import get_public_names
 from _pytest.pytester import Pytester
 from _pytest.python import Function
-from _pytest.scope import HIGH_SCOPES
 
 
 def test_getfuncargnames_functions():

testing/python/metafunc.py

@@ -1504,6 +1504,31 @@ def test_foo(x):
                 "*= no tests collected, 1 error in *",
             ]
         )
+    
+    def test_parametrize_module_level_test_with_class_scope(self, pytester: Pytester) -> None:
+        pytester.makepyfile(
+            """
+            import pytest
+
+            @pytest.fixture
+            def item(request):
+                return request._pyfuncitem
+
+            fixturedef = None
+
+            @pytest.mark.parametrize("x", [0, 1], scope="class")
+            def test_1(item, x):
+                global fixturedef
+                fixturedef = item._fixtureinfo.name2fixturedefs['x'][-1]
+            
+            @pytest.mark.parametrize("x", [1, 2], scope="module")
+            def test_2(item, x):
+                global fixturedef
+                assert fixturedef == item._fixtureinfo.name2fixturedefs['x'][-1]
+        """
+        )
+        result = pytester.runpytest()
+        assert result.ret == 0
 
 
 class TestMetafuncFunctionalAuto: