Fix handling of relative markers in classes

- class namespace had not been handled
- fixed handling of dependencies (had been added to unordered entries)

Author: mrbean-bremen

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Fixes
+- fixed handling of relative markers in classes
+- fixed handling of dependencies (could have been added twice) 
+
 ## [Version 0.9.0](https://pypi.org/project/pytest-order/0.9.0/) (2020-11-08)
 This is the last major version that will support Python 2 - Python 2 support
 will be dropped in version 1.0. There is no timeline for that release, as there

pytest_order/__init__.py

@@ -112,29 +112,36 @@ def initialize(cls, config):
             cls.scope = "session"
 
 
-def get_filename(item):
-    name = item.location[0]
-    if os.sep in name:
-        name = item.location[0].rsplit(os.sep, 1)[1]
-    return name[:-3]
+def full_name(item, name=None):
+    if name and "." in name:
+        # assume it is already qualified
+        return name
+    path = item.location[0]
+    if os.sep in path:
+        path = item.location[0].rsplit(os.sep, 1)[1]
+    path = path[:-3] + "."
+    if name is None:
+        return path + item.location[2]
+    if "." in item.location[2]:
+        path += item.location[2].rsplit(".", 1)[0] + "."
+    return path + name
 
 
 def mark_binning(item, keys, start, end, before, after, unordered, alias):
+    handled = False
     if ("dependency" in keys and
             (Settings.order_dependencies or "order" in keys)):
         # always order dependencies if an order mark is present
         # otherwise only if order-dependencies is set
         mark = item.get_closest_marker("dependency")
-        prefix = get_filename(item) + "."
         dependent_mark = mark.kwargs.get("depends")
         if dependent_mark:
             for name in dependent_mark:
-                if "." not in name:
-                    name = prefix + name
-                after.setdefault(name, []).append(item)
+                after.setdefault(full_name(item, name), []).append(item)
+                handled = True
         name_mark = mark.kwargs.get("name")
         if name_mark:
-            alias[prefix + name_mark] = prefix + item.name
+            alias[full_name(item, name_mark)] = full_name(item)
 
     if "order" in keys:
         mark = item.get_closest_marker("order")
@@ -150,33 +157,29 @@ def mark_binning(item, keys, start, end, before, after, unordered, alias):
                 order = orders_map[order]
             else:
                 warn("Unknown order attribute:'{}'".format(order))
-                unordered.append(item)
-                return False
+                if not handled:
+                    unordered.append(item)
+                    return False
+                return True
             if order < 0:
                 end.setdefault(order, []).append(item)
             else:
                 start.setdefault(order, []).append(item)
         elif before_mark:
-            if "." not in before_mark:
-                prefix = get_filename(item)
-                before_mark = prefix + "." + before_mark
-            before.setdefault(before_mark, []).append(item)
+            before.setdefault(full_name(item, before_mark), []).append(item)
         elif after_mark:
-            if "." not in after_mark:
-                prefix = get_filename(item)
-                after_mark = prefix + "." + after_mark
-
-            after.setdefault(after_mark, []).append(item)
-        return True
-    unordered.append(item)
-    return False
+            after.setdefault(full_name(item, after_mark), []).append(item)
+        handled = True
+    if not handled:
+        unordered.append(item)
+        return False
+    return True
 
 
 def insert_before(name, items, sort):
     regex_name = re.escape(name) + r"(:?\.\w+)?$"
     for pos, item in enumerate(sort):
-        prefix = get_filename(item)
-        item_name = prefix + "." + item.location[2]
+        item_name = full_name(item)
         if re.match(regex_name, item_name):
             for item_to_insert in items:
                 if item_to_insert in sort:
@@ -196,7 +199,7 @@ 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 = get_filename(item) + "." + item.location[2]
+        item_name = full_name(item)
         if re.match(regex_name, item_name):
             for item_to_insert in items:
                 if item_to_insert in sort:
@@ -250,7 +253,7 @@ def do_modify_items(items):
 
         length = len(before_item) + len(after_item)
     if length:
-        sys.stdout.write("WARNING: can not execute test relative to others: ")
+        sys.stdout.write("WARNING: cannot execute test relative to others: ")
         for label, entry in before_item.items():
             sys.stdout.write(label + " ")
             sorted_list += entry

tests/test_dependency.py

@@ -14,45 +14,45 @@ def order_dependencies(ignore_settings):
 
 def test_ignore_order_with_dependency(item_names_for):
     tests_content = """
-import pytest
+    import pytest
 
-def test_a():
-    pass
+    def test_a():
+        pass
 
-@pytest.mark.dependency(depends=['test_a'])
-@pytest.mark.order("first")
-def test_b():
-    pass
+    @pytest.mark.dependency(depends=['test_a'])
+    @pytest.mark.order("first")
+    def test_b():
+        pass
     """
     assert item_names_for(tests_content) == ["test_a", "test_b"]
 
 
 def test_order_with_dependency(item_names_for):
     tests_content = """
-import pytest
+    import pytest
 
-@pytest.mark.dependency(depends=['test_b'])
-@pytest.mark.order("second")
-def test_a():
-    pass
+    @pytest.mark.dependency(depends=['test_b'])
+    @pytest.mark.order("second")
+    def test_a():
+        pass
 
-def test_b():
-    pass
+    def test_b():
+        pass
     """
     assert item_names_for(tests_content) == ["test_b", "test_a"]
 
 
 @pytest.fixture(scope="module")
 def ordered_test():
     yield """
-import pytest
+    import pytest
 
-def test_a():
-    pass
+    def test_a():
+        pass
 
-@pytest.mark.dependency(depends=['test_a'])
-def test_b():
-    pass
+    @pytest.mark.dependency(depends=['test_a'])
+    def test_b():
+        pass
     """
 
 
@@ -69,14 +69,14 @@ def test_dependency_already_ordered_with_ordering(ordered_test,
 @pytest.fixture(scope="module")
 def order_dependency_test():
     yield """
-import pytest
+    import pytest
 
-@pytest.mark.dependency(depends=['test_b'])
-def test_a():
-    pass
+    @pytest.mark.dependency(depends=['test_b'])
+    def test_a():
+        pass
 
-def test_b():
-    pass
+    def test_b():
+        pass
     """
 
 
@@ -92,17 +92,17 @@ def test_order_dependency_ordered(order_dependency_test, item_names_for,
 @pytest.fixture(scope="module")
 def multiple_dependencies_test():
     yield """
-import pytest
+    import pytest
 
-@pytest.mark.dependency(depends=["test_b", "test_c"])
-def test_a():
-    pass
+    @pytest.mark.dependency(depends=["test_b", "test_c"])
+    def test_a():
+        pass
 
-def test_b():
-    pass
+    def test_b():
+        pass
 
-def test_c():
-    pass
+    def test_c():
+        pass
     """
 
 
@@ -124,18 +124,18 @@ def test_order_multiple_dependencies_ordered(multiple_dependencies_test,
 @pytest.fixture(scope="module")
 def named_dependency_test():
     yield """
-import pytest
+    import pytest
 
-@pytest.mark.dependency(depends=["my_test"])
-def test_a():
-    pass
+    @pytest.mark.dependency(depends=["my_test"])
+    def test_a():
+        pass
 
-@pytest.mark.dependency(name="my_test")
-def test_b():
-    pass
+    @pytest.mark.dependency(name="my_test")
+    def test_b():
+        pass
 
-def test_c():
-    pass
+    def test_c():
+        pass
     """
 
 
@@ -150,3 +150,65 @@ def test_order_named_dependency_ordered(named_dependency_test,
     assert item_names_for(named_dependency_test) == [
         "test_b", "test_a", "test_c"
     ]
+
+
+def test_dependency_in_class(item_names_for, order_dependencies):
+    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
+
+        def test_c(self):
+            assert True
+    """
+    assert item_names_for(tests_content) == ["test_c", "test_a", "test_b"]
+
+
+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'])
+        def test_a(self):
+            assert True
+
+        @pytest.mark.dependency(name='test_2', depends=['test_3'])
+        def test_b(self):
+            assert True
+
+        @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_unknown_dependency(item_names_for, order_dependencies, capsys):
+    tests_content = """
+    import pytest
+
+    class Test:
+        def test_a(self):
+            assert True
+
+        @pytest.mark.dependency(depends=['test_3'])
+        def test_b(self):
+            assert True
+
+        def test_c(self):
+            assert True
+    """
+    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")
+    assert warning in out