Fix handling of dependency names

- handle names for pytest-dependency separately to match
  behavior of pytest-dependency
- get rid of the regex match

Author: mrbean-bremen

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Fixes
+- fixed handling of names in dependencies - did not match the actual
+  behavior of `pytest-dependency`
+
 ## [Version 0.9.1](https://pypi.org/project/pytest-order/0.9.0/) (2020-11-11)
 This is a bugfix only release.
 

pytest_order/__init__.py

@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 import os
-import re
 import sys
 from collections import OrderedDict
 from warnings import warn
@@ -127,21 +126,26 @@ def full_name(item, name=None):
     return path + name
 
 
-def mark_binning(item, keys, start, end, before, after, unordered, alias):
+def mark_binning(item, keys, start, end, before, after, dep, unordered, alias):
     handled = False
-    if ("dependency" in keys and
-            (Settings.order_dependencies or "order" in keys)):
+    if "dependency" in keys:
         # always order dependencies if an order mark is present
         # otherwise only if order-dependencies is set
         mark = item.get_closest_marker("dependency")
-        dependent_mark = mark.kwargs.get("depends")
-        if dependent_mark:
-            for name in dependent_mark:
-                after.setdefault(full_name(item, name), []).append(item)
-                handled = True
+        if Settings.order_dependencies or "order" in keys:
+            dependent_mark = mark.kwargs.get("depends")
+            if dependent_mark:
+                for name in dependent_mark:
+                    dep.setdefault(name, []).append(item)
+                    handled = True
+        # we always collect the names of the dependent items, because
+        # we need them in both cases
         name_mark = mark.kwargs.get("name")
-        if name_mark:
-            alias[full_name(item, name_mark)] = full_name(item)
+        # the default name in pytest-dependency is the last part of the nodeid
+        if not name_mark:
+            # in pytest < 4 the nodeid has an unwanted ::() part
+            name_mark = item.nodeid.split("::", 1)[1].replace("::()", "")
+        alias[name_mark] = full_name(item)
 
     if "order" in keys:
         mark = item.get_closest_marker("order")
@@ -168,7 +172,8 @@ def mark_binning(item, keys, start, end, before, after, unordered, alias):
         elif before_mark:
             before.setdefault(full_name(item, before_mark), []).append(item)
         elif after_mark:
-            after.setdefault(full_name(item, after_mark), []).append(item)
+            after.setdefault(
+                full_name(item, after_mark), []).append(item)
         handled = True
     if not handled:
         unordered.append(item)
@@ -177,10 +182,8 @@ def mark_binning(item, keys, start, end, before, after, unordered, alias):
 
 
 def insert_before(name, items, sort):
-    regex_name = re.escape(name) + r"(:?\.\w+)?$"
     for pos, item in enumerate(sort):
-        item_name = full_name(item)
-        if re.match(regex_name, item_name):
+        if name == full_name(item):
             for item_to_insert in items:
                 if item_to_insert in sort:
                     index = sort.index(item_to_insert)
@@ -197,10 +200,9 @@ def insert_before(name, items, sort):
 
 
 def insert_after(name, items, sort):
-    regex_name = re.escape(name) + r"(:?\.\w+)?$"
     for pos, item in reversed(list(enumerate(sort))):
         item_name = full_name(item)
-        if re.match(regex_name, item_name):
+        if item_name == name:
             for item_to_insert in items:
                 if item_to_insert in sort:
                     index = sort.index(item_to_insert)
@@ -217,22 +219,24 @@ def insert_after(name, items, sort):
 def do_modify_items(items):
     before_item = {}
     after_item = {}
+    dep_item = {}
     start_item = {}
     end_item = {}
     unordered_list = []
     alias_names = {}
 
     for item in items:
         mark_binning(item, item.keywords.keys(), start_item, end_item,
-                     before_item, after_item, unordered_list, alias_names)
+                     before_item, after_item, dep_item,
+                     unordered_list, alias_names)
 
     start_item = sorted(start_item.items())
     end_item = sorted(end_item.items())
 
     sorted_list = sort_numbered_items(start_item, end_item, unordered_list)
 
     still_left = 0
-    length = len(before_item) + len(after_item)
+    length = len(before_item) + len(after_item) + len(dep_item)
 
     while still_left != length:
         still_left = length
@@ -245,13 +249,19 @@ def do_modify_items(items):
 
         remove_labels = []
         for label, after in after_item.items():
-            name = alias_names[label] if label in alias_names else label
-            if insert_after(name, after, sorted_list):
+            if insert_after(label, after, sorted_list):
                 remove_labels.append(label)
         for label in remove_labels:
             del after_item[label]
 
-        length = len(before_item) + len(after_item)
+        remove_labels = []
+        for label, after in dep_item.items():
+            if insert_after(alias_names.get(label), after, sorted_list):
+                remove_labels.append(label)
+        for label in remove_labels:
+            del dep_item[label]
+
+        length = len(before_item) + len(after_item) + len(dep_item)
     if length:
         sys.stdout.write("WARNING: cannot execute test relative to others: ")
         for label, entry in before_item.items():
@@ -260,6 +270,9 @@ def do_modify_items(items):
         for label, entry in after_item.items():
             sys.stdout.write(label + " ")
             sorted_list += entry
+        for label, entry in dep_item.items():
+            sys.stdout.write(label + " ")
+            sorted_list += entry
         sys.stdout.flush()
         print("enqueue them behind the others")
 

tests/test_dependency.py

@@ -16,10 +16,11 @@ def test_ignore_order_with_dependency(item_names_for):
     tests_content = """
     import pytest
 
+    @pytest.mark.dependency()
     def test_a():
         pass
 
-    @pytest.mark.dependency(depends=['test_a'])
+    @pytest.mark.dependency(depends=["test_a"])
     @pytest.mark.order("first")
     def test_b():
         pass
@@ -31,11 +32,12 @@ def test_order_with_dependency(item_names_for):
     tests_content = """
     import pytest
 
-    @pytest.mark.dependency(depends=['test_b'])
+    @pytest.mark.dependency(depends=["test_b"])
     @pytest.mark.order("second")
     def test_a():
         pass
 
+    @pytest.mark.dependency()
     def test_b():
         pass
     """
@@ -47,10 +49,11 @@ def ordered_test():
     yield """
     import pytest
 
+    @pytest.mark.dependency()
     def test_a():
         pass
 
-    @pytest.mark.dependency(depends=['test_a'])
+    @pytest.mark.dependency(depends=["test_a"])
     def test_b():
         pass
     """
@@ -71,10 +74,11 @@ def order_dependency_test():
     yield """
     import pytest
 
-    @pytest.mark.dependency(depends=['test_b'])
+    @pytest.mark.dependency(depends=["test_b"])
     def test_a():
         pass
 
+    @pytest.mark.dependency()
     def test_b():
         pass
     """
@@ -98,9 +102,11 @@ def multiple_dependencies_test():
     def test_a():
         pass
 
+    @pytest.mark.dependency()
     def test_b():
         pass
 
+    @pytest.mark.dependency()
     def test_c():
         pass
     """
@@ -157,40 +163,99 @@ def test_dependency_in_class(item_names_for, order_dependencies):
     import pytest
 
     class Test:
-        @pytest.mark.dependency(depends=['test_c'])
+        @pytest.mark.dependency(depends=["Test::test_c"])
         def test_a(self):
             assert True
 
-        @pytest.mark.dependency(depends=['test_c'])
+        @pytest.mark.dependency(depends=["Test::test_c"])
         def test_b(self):
             assert True
 
+        @pytest.mark.dependency()
         def test_c(self):
             assert True
     """
     assert item_names_for(tests_content) == ["test_c", "test_a", "test_b"]
 
 
+def test_unresolved_dependency_in_class(item_names_for, order_dependencies,
+                                        capsys):
+    tests_content = """
+    import pytest
+
+    class Test:
+        @pytest.mark.dependency(depends=["test_c"])
+        def test_a(self):
+            assert True
+
+        @pytest.mark.dependency(depends=["test_c"])
+        def test_b(self):
+            assert True
+
+        @pytest.mark.dependency()
+        def test_c(self):
+            assert True
+    """
+    assert item_names_for(tests_content) == ["test_c", "test_a", "test_b"]
+    out, err = capsys.readouterr()
+    warning = ("cannot execute test relative to others: "
+               "test_c enqueue them behind the others")
+    assert warning in out
+
+
 def test_named_dependency_in_class(item_names_for, order_dependencies):
     tests_content = """
     import pytest
 
     class Test:
-        @pytest.mark.dependency(name='test_1', depends=['test_3'])
+        @pytest.mark.dependency(name="test_1", depends=["test_3"])
         def test_a(self):
             assert True
 
-        @pytest.mark.dependency(name='test_2', depends=['test_3'])
+        @pytest.mark.dependency(name="test_2", depends=["test_3"])
         def test_b(self):
             assert True
 
-        @pytest.mark.dependency(name='test_3')
+        @pytest.mark.dependency(name="test_3")
         def test_c(self):
             assert True
     """
     assert item_names_for(tests_content) == ["test_c", "test_a", "test_b"]
 
 
+def test_dependencies_in_classes(item_names_for, order_dependencies):
+    tests_content = """
+    import pytest
+
+    class TestA:
+        @pytest.mark.dependency(depends=["test_2"])
+        def test_a(self):
+            assert True
+
+        @pytest.mark.dependency(depends=["TestB::test_e"])
+        def test_b(self):
+            assert True
+
+        def test_c(self):
+            assert True
+
+    class TestB:
+        @pytest.mark.dependency(name="test_2")
+        def test_d(self):
+            assert True
+
+        @pytest.mark.dependency()
+        def test_e(self):
+            assert True
+
+        def test_f(self):
+            assert True
+    """
+    assert item_names_for(tests_content) == [
+        "test_c", "test_d", "test_a", "test_e", "test_b", "test_f"
+    ]
+
+
 def test_unknown_dependency(item_names_for, order_dependencies, capsys):
     tests_content = """
     import pytest
@@ -199,7 +264,7 @@ class Test:
         def test_a(self):
             assert True
 
-        @pytest.mark.dependency(depends=['test_3'])
+        @pytest.mark.dependency(depends=["test_3"])
         def test_b(self):
             assert True
 
@@ -209,6 +274,5 @@ def test_c(self):
     assert item_names_for(tests_content) == ["test_a", "test_c", "test_b"]
     out, err = capsys.readouterr()
     warning = ("cannot execute test relative to others: "
-               "test_unknown_dependency.Test.test_3 "
-               "enqueue them behind the others")
+               "test_3 enqueue them behind the others")
     assert warning in out

tests/test_ordering.py

@@ -425,7 +425,7 @@ def test_relative_in_class(item_names_for):
     import pytest
 
     class Test:
-        @pytest.mark.order(after='test_b')
+        @pytest.mark.order(after="test_b")
         def test_a(self):
             assert True
 

tox.ini

@@ -28,7 +28,7 @@ deps =
     pytest{37,38,39,310,40,41,42,43}: pytest-xdist<1.28.0
     pytest{44,45,46,50,51,52,53,54}: pytest-xdist<2.0.0
     pytest{60,61}: pytest-xdist
-    pytest{36,37}: pytest-dependency<0.5.0
+    pytest{37}: pytest-dependency<0.5.0
     pytest{38,39,310,40,41,42,43,44,45,46,50,51,52,53,54,60,61}: pytest-dependency
     pytest{37,38,39,310,40,41,42,43,44,45,46,50,51,52,53,54,60,61}: pytest-mock