Fix handling of combined index and dependency attributes

- could cause duplicated entries
- add ``index`` keyword for ordering as alternative to raw number
- refactor some tests to avoid writing test files where possible
- remove support for pytest 3.6 (too many exceptions)

Author: mrbean-bremen

CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## Unreleased
 
+### Changes
+- removed support for pytest 3.6 (it still may work, just isn't tested anymore)
+
 ### Added
 - added configuration option for sparse sorting, e.g. the possibility to
   fill gaps between ordinals with unordered tests (see also 
@@ -11,6 +14,10 @@
   `pytest-dependency` plugin
 - experimental: added configuration option for ordering all dependencies
   defined by the `pytest-dependency` plugin
+- added ``index`` keyword for ordering as alternative to raw number
+
+### Fixed
+- correctly handle combined index and dependency attributes
 
 ### Infrastructure
 - added list of open issues in `pytest-ordering` with respective state

README.md

@@ -8,7 +8,7 @@ your tests are run. It uses the marker `order` that defines when a specific
 test shall be run relative to the other tests.  
 
 `pytest-order` works with Python 2.7 and 3.5 - 3.9, with pytest 
-versions >= 3.6.0, and runs on Linux, MacOs and Windows.
+versions >= 3.7.0, and runs on Linux, MacOs and Windows.
 
 
 Documentation

docs/source/index.rst

@@ -35,7 +35,7 @@ Here are examples for which markers correspond to markers in
 Supported Python and pytest versions
 ------------------------------------
 ``pytest-order`` supports python 2.7, 3.5 - 3.9, and pypy/pypy3, and is
-compatible with pytest 3.6.0 or newer. Note that support for Python 2 will
+compatible with pytest 3.7.0 or newer. Note that support for Python 2 will
 be removed in one of the next versions.
 
 All supported combinations of Python and pytest versions are tested in
@@ -124,10 +124,14 @@ The above is a trivial example, but ordering is respected across test files.
 
 There are currently three possibilities to define the order:
 
-Order by number
----------------
-As already shown above, the order can be defined using ordinal numbers.
-Negative numbers are also allowed--they are used the same way as indexes
+Order by index
+--------------
+As already shown above, the order can be defined using the ordinal numbers.
+There is a long form that uses the keyword ``index``, and a short form, that
+uses just the ordinal number--both are shown in the example below. The long
+form may be better readable if you want to combine it with a dependency marker
+(``before`` or ``after``, see below).
+Negative numbers are also allowed--they are used the same way as indices
 are used in Python lists, e.g. to count from the end:
 
 .. code:: python
@@ -138,11 +142,11 @@ are used in Python lists, e.g. to count from the end:
  def test_three():
      assert True
 
- @pytest.mark.order(-1)
+ @pytest.mark.order(index=-1)
  def test_four():
      assert True
 
- @pytest.mark.order(2)
+ @pytest.mark.order(index=2)
  def test_two():
      assert True
 

pytest_order/__init__.py

@@ -139,6 +139,8 @@ def mark_binning(item, keys, start, end, before, after, unordered, alias):
     if "order" in keys:
         mark = item.get_closest_marker("order")
         order = mark.args[0] if mark.args else None
+        if order is None:
+            order = mark.kwargs.get("index")
         before_mark = mark.kwargs.get("before")
         after_mark = mark.kwargs.get("after")
         if order is not None:
@@ -176,23 +178,36 @@ def insert_before(name, items, sort):
         prefix = get_filename(item)
         item_name = prefix + "." + item.location[2]
         if re.match(regex_name, item_name):
-            if pos == 0:
-                sort[:] = items + sort
-            else:
-                sort[pos:1] = items
+            for item_to_insert in items:
+                if item_to_insert in sort:
+                    index = sort.index(item_to_insert)
+                    if index > pos:
+                        del sort[index]
+                        sort.insert(pos, item_to_insert)
+                else:
+                    if pos == 0:
+                        sort[:] = items + sort
+                    else:
+                        sort[pos:1] = items
             return True
     return False
 
 
 def insert_after(name, items, sort):
     regex_name = re.escape(name) + r"(:?\.\w+)?$"
     for pos, item in reversed(list(enumerate(sort))):
-        prefix = get_filename(item)
-        item_name = prefix + "." + item.location[2]
+        item_name = get_filename(item) + "." + item.location[2]
         if re.match(regex_name, item_name):
-            sort[pos + 1:1] = items
+            for item_to_insert in items:
+                if item_to_insert in sort:
+                    index = sort.index(item_to_insert)
+                    if index < pos + 1:
+                        del sort[index]
+                        pos -= 1
+                        sort.insert(pos + 1, item_to_insert)
+                else:
+                    sort[pos + 1:1] = items
             return True
-
     return False
 
 

setup.py

@@ -26,7 +26,7 @@
             "pytest_order = pytest_order",
         ]
     },
-    install_requires=["pytest>=3.6"],
+    install_requires=["pytest>=3.7"],
     classifiers=[
         "Development Status :: 4 - Beta",
         "Intended Audience :: Developers",

tests/conftest.py

@@ -22,3 +22,9 @@ def test_path(tmpdir):
     path = tmpdir.join("{}.py".format(str(uuid.uuid4())))
     yield str(path)
     path.remove()
+
+
+@pytest.fixture
+def ignore_settings(mocker):
+    mocker.patch("pytest_order.Settings.initialize")
+    yield

tests/test_dependency.py

@@ -3,10 +3,16 @@
 import pytest
 
 import pytest_order
-from utils import write_test, assert_test_order
 
 
-def test_ignore_order_with_dependency(test_path, capsys):
+@pytest.fixture
+def order_dependencies(ignore_settings):
+    pytest_order.Settings.order_dependencies = True
+    yield
+    pytest_order.Settings.order_dependencies = False
+
+
+def test_ignore_order_with_dependency(item_names_for):
     tests_content = """
 import pytest
 
@@ -18,13 +24,10 @@ def test_a():
 def test_b():
     pass
     """
-    write_test(test_path, tests_content)
-    pytest.main(["-v", test_path], [pytest_order])
-    out, err = capsys.readouterr()
-    assert_test_order(["test_a", "test_b"], out)
+    assert item_names_for(tests_content) == ["test_a", "test_b"]
 
 
-def test_order_with_dependency(test_path, capsys):
+def test_order_with_dependency(item_names_for):
     tests_content = """
 import pytest
 
@@ -36,14 +39,12 @@ def test_a():
 def test_b():
     pass
     """
-    write_test(test_path, tests_content)
-    pytest.main(["-v", test_path], [pytest_order])
-    out, err = capsys.readouterr()
-    assert_test_order(["test_b", "test_a"], out)
+    assert item_names_for(tests_content) == ["test_b", "test_a"]
 
 
-def test_dependency_already_ordered(test_path, capsys):
-    tests_content = """
+@pytest.fixture(scope="module")
+def ordered_test():
+    yield """
 import pytest
 
 def test_a():
@@ -53,17 +54,21 @@ def test_a():
 def test_b():
     pass
     """
-    write_test(test_path, tests_content)
-    pytest.main(["-v", test_path], [pytest_order])
-    out, err = capsys.readouterr()
-    assert_test_order(["test_a", "test_b"], out)
-    pytest.main(["-v", "--order-dependencies", test_path], [pytest_order])
-    out, err = capsys.readouterr()
-    assert_test_order(["test_a", "test_b"], out)
 
 
-def test_order_dependency(test_path, capsys):
-    tests_content = """
+def test_dependency_already_ordered_default(ordered_test, item_names_for):
+    assert item_names_for(ordered_test) == ["test_a", "test_b"]
+
+
+def test_dependency_already_ordered_with_ordering(ordered_test,
+                                                  item_names_for,
+                                                  order_dependencies):
+    assert item_names_for(ordered_test) == ["test_a", "test_b"]
+
+
+@pytest.fixture(scope="module")
+def order_dependency_test():
+    yield """
 import pytest
 
 @pytest.mark.dependency(depends=['test_b'])
@@ -73,17 +78,20 @@ def test_a():
 def test_b():
     pass
     """
-    write_test(test_path, tests_content)
-    pytest.main(["-v", test_path], [pytest_order])
-    out, err = capsys.readouterr()
-    assert_test_order(["test_a", "test_b"], out)
-    pytest.main(["-v", "--order-dependencies", test_path], [pytest_order])
-    out, err = capsys.readouterr()
-    assert_test_order(["test_b", "test_a"], out)
 
 
-def test_order_multiple_dependencies(test_path, capsys):
-    tests_content = """
+def test_order_dependency_default(order_dependency_test, item_names_for):
+    assert item_names_for(order_dependency_test) == ["test_a", "test_b"]
+
+
+def test_order_dependency_ordered(order_dependency_test, item_names_for,
+                                  order_dependencies):
+    assert item_names_for(order_dependency_test) == ["test_b", "test_a"]
+
+
+@pytest.fixture(scope="module")
+def multiple_dependencies_test():
+    yield """
 import pytest
 
 @pytest.mark.dependency(depends=["test_b", "test_c"])
@@ -96,17 +104,26 @@ def test_b():
 def test_c():
     pass
     """
-    write_test(test_path, tests_content)
-    pytest.main(["-v", test_path], [pytest_order])
-    out, err = capsys.readouterr()
-    assert_test_order(["test_a", "test_b", "test_c"], out)
-    pytest.main(["-v", "--order-dependencies", test_path], [pytest_order])
-    out, err = capsys.readouterr()
-    assert_test_order(["test_b", "test_c", "test_a"], out)
 
 
-def test_order_named_dependency(test_path, capsys):
-    tests_content = """
+def test_order_multiple_dependencies_default(multiple_dependencies_test,
+                                             item_names_for):
+    assert item_names_for(multiple_dependencies_test) == [
+        "test_a", "test_b", "test_c"
+    ]
+
+
+def test_order_multiple_dependencies_ordered(multiple_dependencies_test,
+                                             item_names_for,
+                                             order_dependencies):
+    assert item_names_for(multiple_dependencies_test) == [
+        "test_b", "test_c", "test_a"
+    ]
+
+
+@pytest.fixture(scope="module")
+def named_dependency_test():
+    yield """
 import pytest
 
 @pytest.mark.dependency(depends=["my_test"])
@@ -120,10 +137,16 @@ def test_b():
 def test_c():
     pass
     """
-    write_test(test_path, tests_content)
-    pytest.main(["-v", test_path], [pytest_order])
-    out, err = capsys.readouterr()
-    assert_test_order(["test_a", "test_b", "test_c"], out)
-    pytest.main(["-v", "--order-dependencies", test_path], [pytest_order])
-    out, err = capsys.readouterr()
-    assert_test_order(["test_b", "test_a", "test_c"], out)
+
+
+def test_order_named_dependency_default(named_dependency_test, item_names_for):
+    assert item_names_for(named_dependency_test) == [
+        "test_a", "test_b", "test_c"
+    ]
+
+
+def test_order_named_dependency_ordered(named_dependency_test,
+                                        item_names_for, order_dependencies):
+    assert item_names_for(named_dependency_test) == [
+        "test_b", "test_a", "test_c"
+    ]

tests/test_order_scope.py

@@ -164,7 +164,7 @@ def test_class_scope(fixture_path, capsys):
     assert_test_order(expected, out)
 
 
-@pytest.mark.skipif(pytest.__version__.startswith(("3.6.", "3.7.")),
+@pytest.mark.skipif(pytest.__version__.startswith("3.7."),
                     reason="Warning does not appear in output in pytest < 3.8")
 def test_invalid_scope(fixture_path, capsys):
     args = ["-v", "--order-scope=function", fixture_path]

tests/test_ordering.py

@@ -72,6 +72,23 @@ def test_3(): pass
     assert item_names_for(tests_content) == ["test_3", "test_2", "test_1"]
 
 
+def test_order_marks_by_index(item_names_for):
+    tests_content = """
+    import pytest
+
+    @pytest.mark.order(index=-1)
+    def test_1(): pass
+
+    @pytest.mark.order(index=-2)
+    def test_2(): pass
+
+    @pytest.mark.order(index=1)
+    def test_3(): pass
+    """
+
+    assert item_names_for(tests_content) == ["test_3", "test_2", "test_1"]
+
+
 def test_non_contiguous_positive(item_names_for):
     tests_content = """
     import pytest
@@ -460,6 +477,24 @@ def test_3():
     assert item_names_for(test_content) == ["test_3", "test_2", "test_1"]
 
 
+def test_combined_markers(item_names_for):
+    test_content = """
+    import pytest
+
+    @pytest.mark.order(2)
+    def test_1():
+        pass
+
+    def test_2():
+        pass
+
+    @pytest.mark.order(index=1, before="test_2")
+    def test_3():
+        pass
+    """
+    assert item_names_for(test_content) == ["test_3", "test_1", "test_2"]
+
+
 def test_dependency_after_unknown_test(item_names_for, capsys):
     test_content = """
     import pytest