Move plugin code from __init__.py to plugin.py

- move version into __init__.py
- adapt tests, use standard testdir fixture

Author: mrbean-bremen

.github/workflows/performance.yml

@@ -38,6 +38,7 @@ jobs:
         python -m pip install wheel
         python -m pip install pytest
         python -m pip install pytest-dependency
+        python -m pip install -e .
     - name: Run tests
       run: |
         python -m pytest -s perf_tests

.github/workflows/pythontests.yml

@@ -94,11 +94,10 @@ jobs:
       uses: actions/setup-python@v2
       with:
         python-version: "3.8"
-    - name: Install wheel and pytest
+    - name: Install wheel
       run: |
         python -m pip install --upgrade pip
         pip install wheel
-        pip install pytest
     - name: Build package
       run: |
         cd main

perf_tests/test_dependencies.py

@@ -1,20 +1,15 @@
-import os
-import shutil
 from unittest import mock
 
 import pytest
-
-import pytest_order
 from perf_tests.util import TimedSorter
-from tests.utils import write_test
+
+pytest_plugins = ["pytester"]
 
 
 @pytest.fixture
-def fixture_path_relative(tmpdir_factory):
-    fixture_path = str(tmpdir_factory.mktemp("dep_perf_sparse"))
-    for module_index in range(10):
-        testname = os.path.join(
-            fixture_path, "test_dep_perf{}.py".format(module_index))
+def fixture_path_relative(testdir):
+    for i_mod in range(10):
+        test_name = testdir.tmpdir.join("test_dep_perf{}.py".format(i_mod))
         test_contents = """
 import pytest
 """
@@ -30,16 +25,14 @@ def test_{}():
 def test_{}():
     assert True
 """.format(i + 40)
-        write_test(testname, test_contents)
-    yield fixture_path
-    shutil.rmtree(fixture_path, ignore_errors=True)
+        test_name.write(test_contents)
+    yield testdir
 
 
-@mock.patch("pytest_order.Sorter", TimedSorter)
+@mock.patch("pytest_order.plugin.Sorter", TimedSorter)
 def test_performance_dependency(fixture_path_relative):
     """Test performance of dependency markers that point to tests without
     an order mark (same as for test_relative does for after markers)."""
-    args = ["--order-dependencies", fixture_path_relative]
     TimedSorter.nr_marks = 400
-    pytest.main(args, [pytest_order])
-    assert TimedSorter.elapsed < 0.2
+    fixture_path_relative.runpytest("--quiet", "--order-dependencies")
+    assert TimedSorter.elapsed < 0.15

perf_tests/test_ordinal.py

@@ -1,19 +1,15 @@
-import os
-import shutil
 from unittest import mock
 
 import pytest
-import pytest_order
 from perf_tests.util import TimedSorter
-from tests.utils import write_test
+
+pytest_plugins = ["pytester"]
 
 
 @pytest.fixture
-def fixture_path_ordinal(tmpdir_factory):
-    fixture_path = str(tmpdir_factory.mktemp("ordinal_perf"))
-    for module_index in range(10):
-        testname = os.path.join(
-            fixture_path, "test_performance{}.py".format(module_index))
+def fixture_path_ordinal(testdir):
+    for i_mod in range(10):
+        test_name = testdir.tmpdir.join("test_performance{}.py".format(i_mod))
         test_contents = """
 import pytest
 """
@@ -23,14 +19,12 @@ def fixture_path_ordinal(tmpdir_factory):
 def test_{}():
     assert True
 """.format(50 - i, i)
-        write_test(testname, test_contents)
-    yield fixture_path
-    shutil.rmtree(fixture_path, ignore_errors=True)
+        test_name.write(test_contents)
+    yield testdir
 
 
-@mock.patch("pytest_order.Sorter", TimedSorter)
+@mock.patch("pytest_order.plugin.Sorter", TimedSorter)
 def test_performance_ordinal(fixture_path_ordinal):
-    args = [fixture_path_ordinal]
     TimedSorter.nr_marks = 1000
-    pytest.main(args, [pytest_order])
+    fixture_path_ordinal.runpytest("--quiet")
     assert TimedSorter.elapsed < 0.02

perf_tests/test_relative.py

@@ -1,20 +1,16 @@
-import os
-import shutil
 from unittest import mock
 
 import pytest
-
-import pytest_order
 from perf_tests.util import TimedSorter
-from tests.utils import write_test
+
+pytest_plugins = ["pytester"]
 
 
 @pytest.fixture
-def fixture_path_relative(tmpdir_factory):
-    fixture_path = str(tmpdir_factory.mktemp("relative_perf"))
-    for module_index in range(10):
-        testname = os.path.join(
-            fixture_path, "test_relative_perf{}.py".format(module_index))
+def fixture_path_relative(testdir):
+    for i_mod in range(10):
+        test_name = testdir.tmpdir.join(
+            "test_relative_perf{}.py".format(i_mod))
         test_contents = """
 import pytest
 """
@@ -29,16 +25,14 @@ def test_{}():
 def test_{}():
     assert True
 """.format(i + 40)
-        write_test(testname, test_contents)
-    yield fixture_path
-    shutil.rmtree(fixture_path, ignore_errors=True)
+        test_name.write(test_contents)
+    yield testdir
 
 
-@mock.patch("pytest_order.Sorter", TimedSorter)
+@mock.patch("pytest_order.plugin.Sorter", TimedSorter)
 def test_performance_relative(fixture_path_relative):
     """Test performance of after markers that point to tests without
     an order mark (the usual case)."""
-    args = [fixture_path_relative]
     TimedSorter.nr_marks = 400
-    pytest.main(args, [pytest_order])
+    fixture_path_relative.runpytest("--quiet")
     assert TimedSorter.elapsed < 0.15

perf_tests/test_relative_dense.py

@@ -1,20 +1,16 @@
-import os
-import shutil
 from unittest import mock
 
 import pytest
-
-import pytest_order
 from perf_tests.util import TimedSorter
-from tests.utils import write_test
+
+pytest_plugins = ["pytester"]
 
 
 @pytest.fixture
-def fixture_path_relative_dense(tmpdir_factory):
-    fixture_path = str(tmpdir_factory.mktemp("relative_dense_perf"))
-    for module_index in range(10):
-        testname = os.path.join(
-            fixture_path, "test_relative_dense_perf{}.py".format(module_index))
+def fixture_path_relative_dense(testdir):
+    for i_mod in range(10):
+        test_name = testdir.tmpdir.join(
+            "test_relative_dense_perf{}.py".format(i_mod))
         test_contents = """
 import pytest
 """
@@ -29,16 +25,14 @@ def test_{}():
 def test_{}():
     assert True
 """.format(i + 90)
-        write_test(testname, test_contents)
-    yield fixture_path
-    shutil.rmtree(fixture_path, ignore_errors=True)
+        test_name.write(test_contents)
+    yield testdir
 
 
-@mock.patch("pytest_order.Sorter", TimedSorter)
+@mock.patch("pytest_order.plugin.Sorter", TimedSorter)
 def test_performance_relative(fixture_path_relative_dense):
     """Test performance of after markers that mostly point to tests with
     another order mark, so items are evaluated multiple times."""
-    args = [fixture_path_relative_dense]
     TimedSorter.nr_marks = 900
-    pytest.main(args, [pytest_order])
+    fixture_path_relative_dense.runpytest("--quiet")
     assert TimedSorter.elapsed < 0.15

perf_tests/util.py

@@ -1,6 +1,6 @@
 import time
 
-from pytest_order import Sorter
+from pytest_order.sorter import Sorter
 
 
 class TimedSorter(Sorter):
@@ -13,5 +13,5 @@ def sort_items(self):
         items = super().sort_items()
         self.__class__.elapsed = ((time.time() - start_time)
                                   / self.nr_marks * 1000)
-        print("Time per test: {:.3f} ms".format(self.__class__.elapsed))
+        print("\nTime per test: {:.3f} ms".format(self.__class__.elapsed))
         return items

pytest_order/__init__.py

@@ -1,88 +1 @@
-# -*- coding: utf-8 -*-
-
-import pytest
-
-from pytest_order.sorter import Sorter
-from ._version import __version__  # noqa: F401
-
-
-def pytest_configure(config):
-    """Register the "order" marker and configure the plugin depending
-     on the CLI options"""
-
-    provided_by_pytest_order = (
-        "Provided by pytest-order. "
-        "See also: https://pytest-dev.github.io/pytest-order/"
-    )
-
-    config_line = (
-            "order: specify ordering information for when tests should run "
-            "in relation to one another. " + provided_by_pytest_order
-    )
-    config.addinivalue_line("markers", config_line)
-
-    if config.getoption("indulgent_ordering"):
-        # We need to dynamically add this `tryfirst` decorator to the plugin:
-        # only when the CLI option is present should the decorator be added.
-        # Thus, we manually run the decorator on the class function and
-        # manually replace it.
-        # Python 2.7 didn't allow arbitrary attributes on methods, so we have
-        # to keep the function as a function and then add it to the class as a
-        # pseudo method.  Since the class is purely for structuring and `self`
-        # is never referenced, this seems reasonable.
-        OrderingPlugin.pytest_collection_modifyitems = pytest.hookimpl(
-            function=modify_items, tryfirst=True)
-    else:
-        OrderingPlugin.pytest_collection_modifyitems = pytest.hookimpl(
-            function=modify_items, trylast=True)
-    config.pluginmanager.register(OrderingPlugin(), "orderingplugin")
-
-
-def pytest_addoption(parser):
-    """Set up CLI option for pytest"""
-    group = parser.getgroup("ordering")
-    group.addoption("--indulgent-ordering", action="store_true",
-                    dest="indulgent_ordering",
-                    help="Request that the sort order provided by "
-                         "pytest-order be applied before other sorting, "
-                         "allowing the other sorting to have priority")
-    group.addoption("--order-scope", action="store",
-                    dest="order_scope",
-                    help="Defines the scope used for ordering. Possible values"
-                         "are 'session' (default), 'module', and 'class'."
-                         "Ordering is only done inside a scope.")
-    group.addoption("--order-scope-level", action="store", type=int,
-                    dest="order_scope_level",
-                    help="Defines that the given directory level is used as "
-                         "order scope. Cannot be used with --order-scope. "
-                         "The value is a number that defines the "
-                         "hierarchical index of the directories used as "
-                         "order scope, starting with 0 at session scope.")
-    group.addoption("--order-group-scope", action="store",
-                    dest="order_group_scope",
-                    help="Defines the scope used for order groups. Possible "
-                         "values are 'session' (default), 'module', "
-                         "and 'class'. Ordering is first done inside a group, "
-                         "then between groups.")
-    group.addoption("--sparse-ordering", action="store_true",
-                    dest="sparse_ordering",
-                    help="If there are gaps between ordinals they are filled "
-                         "with unordered tests.")
-    group.addoption("--order-dependencies", action="store_true",
-                    dest="order_dependencies",
-                    help="If set, dependencies added by pytest-dependency will"
-                         "be ordered if needed.")
-
-
-class OrderingPlugin(object):
-    """
-    Plugin implementation
-
-    By putting this in a class, we are able to dynamically register it after
-    the CLI is parsed.
-    """
-
-
-def modify_items(session, config, items):
-    sorter = Sorter(config, items)
-    items[:] = sorter.sort_items()
+__version__ = "1.0.dev0"