Allow markers relative to parametrized tests

- the parameter value has no more to be included
- see #38

Author: mrbean-bremen

CHANGELOG.md

@@ -9,10 +9,15 @@
 - changed notation of relative markers in other modules - instead of using
   the dot notation, the standard pytest nodeid is used,
   see [#24](https://github.com/pytest-dev/pytest-order/issues/24)
+- using parametrized test names that include the parameter is no longer 
+  supported, just use the name without the parameter instead 
 
 ### New features
 - added support for the ``pytest-dependency`` option ``automark_dependency``
-
+- added support for relative ordering of parametrized tests using the test 
+  name without the parameter value,
+  see [#38](https://github.com/pytest-dev/pytest-order/issues/38)
+  
 ## [Version 0.11.0](https://pypi.org/project/pytest-order/0.11.0/) (2021-04-11)
 Adds support for multiple relative markers for the same test.
 

docs/source/usage.rst

@@ -350,3 +350,24 @@ attributes by using a list or tuple of test names:
 
 This will ensure that ``test_first`` is executed both after ``test_second``
 and after ``test_other`` which resides in the module ``other_module.py``.
+
+Relationships with parameterized tests
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+If you want to reference parametrized tests, you can just use the test name
+without the parameter part, for example:
+
+.. code:: python
+
+ import pytest
+
+ @pytest.mark.order(after=["test_second"])
+ def test_first():
+     assert True
+
+ @pytest.parametrize(param, [1, 2, 3])
+ def test_second(param):
+     assert True
+
+Note that using the fully qualified test name, which would include the
+parameter (in this case ``test_second[1]``, ``test_second[2]`` etc) is not
+supported.

pytest_order/sorter.py

@@ -59,7 +59,9 @@ def __init__(self, config: Config, items: List[Function]) -> None:
         self.node_id_last: Dict[str, List[str]] = {}
         for item in self.items:
             self.node_ids[item.node_id] = item
-            _, _, last_part = item.node_id.rpartition("::")
+            last_part = item.node_id.rpartition("::")[2]
+            if "[" in last_part:
+                last_part = last_part.rpartition("[")[0]
             # save last nodeid component to avoid to iterate over all
             # items for each label
             self.node_id_last.setdefault(last_part, []).append(
@@ -174,22 +176,30 @@ def handle_order_mark(self, item: Item) -> None:
         if order is not None:
             item.nr_rel_items = 0
 
-    def item_from_label(
+    def items_from_label(
         self, label: str, item: Item, is_cls_mark: bool
-    ) -> Optional[Item]:
+    ) -> List[Item]:
+        """
+        Return the list of matching items from the given label.
+        The list contains one item for a single matching test, several items
+        in the case of a matching parametrized test, or no item in case of
+        an invalid label.
+        """
         item_id = item.node_id
         label_len = len(label)
         last_comp = label.split("/")[-1].split("::")[-1]
+        items = []
         with suppress(KeyError):
             node_ids = self.node_id_last[last_comp]
             for node_id in node_ids:
-                if node_id.endswith(label):
+                if (node_id.endswith(label) or node_id.endswith("]") and
+                        node_id.rpartition("[")[0].endswith(label)):
                     id_start = node_id[:-label_len]
                     if is_cls_mark and id_start.count("::") == 2:
                         continue
                     if item_id.startswith(id_start):
-                        return self.node_ids[node_id]
-        return None
+                        items.append(self.node_ids[node_id])
+        return items
 
     def items_from_class_label(self, label: str, item: Item) -> List[Item]:
         items = []
@@ -216,14 +226,16 @@ def is_mark_for_class() -> bool:
             return "::" not in marker_name and is_class_mark()
 
         is_cls_mark = is_class_mark()
-        item_for_label = self.item_from_label(marker_name, item, is_cls_mark)
-        if item_for_label:
-            rel_mark = RelativeMark(item_for_label, item, move_after=is_after)
-            if is_after or not is_cls_mark:
-                self.rel_marks.append(rel_mark)
-            else:
-                self.rel_marks.insert(0, rel_mark)
-            item.inc_rel_marks()
+        items_for_label = self.items_from_label(marker_name, item, is_cls_mark)
+        if items_for_label:
+            for item_for_label in items_for_label:
+                rel_mark = RelativeMark(
+                    item_for_label, item, move_after=is_after)
+                if is_after or not is_cls_mark:
+                    self.rel_marks.append(rel_mark)
+                else:
+                    self.rel_marks.insert(0, rel_mark)
+                item.inc_rel_marks()
             return True
         else:
             if is_mark_for_class():

tests/test_relative_ordering.py

@@ -490,3 +490,26 @@ def test_3():
         "test_dependency_loop.py::test_3"
     )
     assert warning in out
+
+
+def test_dependency_on_parametrized_test(item_names_for):
+    test_content = (
+        """
+        import pytest
+
+        @pytest.mark.order(after="test_2")
+        def test_1():
+            pass
+
+        @pytest.mark.parametrize("arg", [1, 2, 3, 4])
+        def test_2(arg):
+            pass
+
+        @pytest.mark.order(before="test_2")
+        def test_3():
+            pass
+        """
+    )
+    assert item_names_for(test_content) == [
+        "test_3", "test_2[1]", "test_2[2]", "test_2[3]", "test_2[4]", "test_1"
+    ]