Add support for --indulgent-ordering option

This requests that the plugin be run first, allowing other plugins to
override its ordering. This is useful if the order requirements
provided by this plugin are intended to be priorities, rather than
absolute requirements. For example, if some test cases run slower than
others in your test suite, you can mark them as desirable to run first
when running tests in parallel, allowing a more efficient use of a
multi-core processor. By adding the `--indulgent-ordering` option,
this ordering can still be overridden by, for example, the
`--failed-first` option, which prioritizes tests which failed during
the last run. Without `--indulgent-ordering`, the `--failed-first`
option will be overridden by pytest-ordering, reducing its usefulness
by increasing the total time until the results are available.

Author: andyg0808

AUTHORS

@@ -2,3 +2,4 @@ Frank Tobia <[email protected]>
 Sergei Chipiga <[email protected]>
 Ben Greene <[email protected]>
 Adam Talsma <[email protected]>
+Andrew Gilbert <[email protected]>

CHANGELOG

@@ -1,3 +1,8 @@
+Unreleased
+---
+- #?? Add ``--indulgent-ordering`` to request that the sort from
+  pytest-ordering be run before other plugins.  This allows the built-in
+  ``--failed-first`` implementation to override the ordering.
 
 0.6
 ---

docs/source/index.rst

@@ -114,6 +114,21 @@ You can also use markers such as "first", "second", "last", and "second_to_last"
 
     =========================== 4 passed in 0.02 seconds ===========================
 
+``--indulgent-ordering`` and overriding ordering
+-------------
+
+You may sometimes find that you want to suggest an ordering of tests, while
+allowing it to be overridden for good reson. For example, if you run your test
+suite in parallel and have a number of tests which are particularly slow, it
+might be desirable to start those tests running first, in order to optimize
+your completion time. You can use the pytest-ordering plugin to inform pytest
+of this. Now suppose you also want to prioritize tests which failed during the
+previous run, by using the ``--failed-first`` option. By default,
+pytest-ordering will override the ``--failed-first`` order, but by adding the
+``--indulgent-ordering`` option, you can ask pytest to run the sort from
+pytest-ordering *before* the sort from ``--failed-first``, allowing the failed
+tests to be sorted to the front.
+
 
 Aspirational
 ============

pytest_ordering/__init__.py

@@ -26,47 +26,71 @@
 
 
 def pytest_configure(config):
-    """Register the "run" marker."""
+    """Register the "run" marker and configur the plugin depending on the CLI
+    options"""
 
     config_line = (
         'run: specify ordering information for when tests should run '
         'in relation to one another. Provided by pytest-ordering. '
         'See also: http://pytest-ordering.readthedocs.org/'
     )
     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.
+        OrderingPlugin.pytest_collection_modifyitems = pytest.hookimpl(
+            function=OrderingPlugin.pytest_collection_modifyitems, tryfirst=True)
+    config.pluginmanager.register(OrderingPlugin(), 'orderingplugin')
 
 
-def pytest_collection_modifyitems(session, config, items):
-    grouped_items = {}
+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-ordering be applied before other sorting, allowing the \
+other sorting to have priority''')
 
-    for item in items:
+class OrderingPlugin:
+    """
+    Plugin implementation
 
-        for mark_name, order in orders_map.items():
-            mark = item.get_closest_marker(mark_name)
+    By putting this in a class, we are able to dynamically register it after
+    the CLI is parsed.
+    """
+    def pytest_collection_modifyitems(session, config, items):
+        grouped_items = {}
 
-            if mark:
-                item.add_marker(pytest.mark.run(order=order))
-                break
+        for item in items:
+
+            for mark_name, order in orders_map.items():
+                mark = item.get_closest_marker(mark_name)
 
-        mark = item.get_closest_marker('run')
+                if mark:
+                    item.add_marker(pytest.mark.run(order=order))
+                    break
 
-        if mark:
-            order = mark.kwargs.get('order')
-        else:
-            order = None
+            mark = item.get_closest_marker('run')
+
+            if mark:
+                order = mark.kwargs.get('order')
+            else:
+                order = None
 
-        grouped_items.setdefault(order, []).append(item)
+            grouped_items.setdefault(order, []).append(item)
 
-    sorted_items = []
-    unordered_items = [grouped_items.pop(None, [])]
+        sorted_items = []
+        unordered_items = [grouped_items.pop(None, [])]
 
-    start_list = sorted((i for i in grouped_items.items() if i[0] >= 0),
-                        key=operator.itemgetter(0))
-    end_list = sorted((i for i in grouped_items.items() if i[0] < 0),
-                      key=operator.itemgetter(0))
+        start_list = sorted((i for i in grouped_items.items() if i[0] >= 0),
+                            key=operator.itemgetter(0))
+        end_list = sorted((i for i in grouped_items.items() if i[0] < 0),
+                          key=operator.itemgetter(0))
 
-    sorted_items.extend([i[1] for i in start_list])
-    sorted_items.extend(unordered_items)
-    sorted_items.extend([i[1] for i in end_list])
+        sorted_items.extend([i[1] for i in start_list])
+        sorted_items.extend(unordered_items)
+        sorted_items.extend([i[1] for i in end_list])
 
-    items[:] = [item for sublist in sorted_items for item in sublist]
+        items[:] = [item for sublist in sorted_items for item in sublist]