Fixed issue with ordering and setup/teardown for higher-level scope fixtures (session and module scopes) when using union fixtures. Fixes #44.

Added corresponding test

Author: Sylvain MARIE

pytest_cases/common.py

@@ -340,18 +340,16 @@ def get_pytest_nodeid(metafunc):
         return "unknown"
 
 
-def get_pytest_scopes():
-    """
-    Returns the list of scopes in order as defined in pytest.
-    :return:
-    """
-    try:
-        from _pytest.fixtures import scopes as pt_scopes
-    except ImportError:
-        # pytest 2
-        from _pytest.python import scopes as pt_scopes
-    return pt_scopes
+try:
+    from _pytest.fixtures import scopes as pt_scopes
+except ImportError:
+    # pytest 2
+    from _pytest.python import scopes as pt_scopes
+
+
+def get_pytest_scopenum(scope_str):
+    return pt_scopes.index(scope_str)
 
 
 def get_pytest_function_scopenum():
-    return get_pytest_scopes().index("function")
+    return pt_scopes.index("function")

pytest_cases/plugin.py

@@ -8,7 +8,7 @@
 import pytest
 
 from pytest_cases.common import get_pytest_nodeid, get_pytest_function_scopenum, \
-    is_function_node, get_param_names
+    is_function_node, get_param_names, get_pytest_scopenum
 from pytest_cases.main_fixtures import NOT_USED, is_fixture_union_params, UnionFixtureAlternative, apply_id_style
 
 try:  # python 3.3+
@@ -28,6 +28,7 @@
 
 
 # @hookspec(firstresult=True)
+# @pytest.hookimpl(tryfirst=True, hookwrapper=True)
 def pytest_collection(session):
     # override the fixture manager's method
     session._fixturemanager.getfixtureclosure = partial(getfixtureclosure, session._fixturemanager)
@@ -340,13 +341,41 @@ def split_and_build(self,
     def has_split(self):
         return self.split_fixture_name is not None
 
+    def gather_all_required(self, include_children=True, include_parents=True):
+        """
+        Returns a list of all fixtures required by the subtree at this node
+        :param include_children:
+        :return:
+        """
+        # first the fixtures required by this node
+        required = list(self.fixture_defs.keys())
+
+        # then the ones required by the parents
+        if include_parents and self.parent is not None:
+            required = required + self.parent.gather_all_required(include_children=False)
+
+        # then the ones from all the children
+        if include_children:
+            for child in self.children.values():
+                required = required + child.gather_all_required(include_parents=False)
+
+        return required
+
+    def requires(self, fixturename):
+        """
+        Returns True if the fixture with this name is required by the subtree at this node
+        :param fixturename:
+        :return:
+        """
+        return fixturename in self.gather_all_required()
+
     def gather_all_discarded(self):
         """
         Returns a list of all fixture names discarded during splits from the parent node down to this node.
         Note: this does not include the split done at this node if any, nor all of its subtree.
         :return:
         """
-        discarded = self.split_fixture_discarded_names
+        discarded = list(self.split_fixture_discarded_names)
         if self.parent is not None:
             discarded = discarded + self.parent.gather_all_discarded()
 
@@ -730,12 +759,18 @@ def _cleanup_calls_list(self, calls, nodes, pending):
             # For this we use a dirty hack: we add a parameter with they name in the callspec, it seems to be propagated
             # in the `request`. TODO is there a better way?
             # for fixture in list(fix_closure_tree):
-            for fixture in n.gather_all_discarded():
-                if fixture not in c.params and fixture not in c.funcargs:
-                    # explicitly add it as discarded by creating a parameter value for it.
-                    c.params[fixture] = NOT_USED
-                    c.indices[fixture] = 0
-                    c._arg2scopenum[fixture] = function_scope_num
+            for fixture_name, fixdef in self.metafunc._arg2fixturedefs.items():
+                if fixture_name not in c.params and fixture_name not in c.funcargs:
+                    if not n.requires(fixture_name):
+                        # explicitly add it as discarded by creating a parameter value for it.
+                        c.params[fixture_name] = NOT_USED
+                        c.indices[fixture_name] = 0
+                        c._arg2scopenum[fixture_name] = get_pytest_scopenum(fixdef[-1].scope)
+                    else:
+                        # explicitly add it as active
+                        c.params[fixture_name] = 'used'
+                        c.indices[fixture_name] = 1
+                        c._arg2scopenum[fixture_name] = get_pytest_scopenum(fixdef[-1].scope)
 
     def _parametrize_calls(self, init_calls, argnames, argvalues, discard_id=False, indirect=False, ids=None,
                            scope=None, **kwargs):
@@ -905,3 +940,27 @@ def sort_according_to_ref_list(fixturenames, param_names):
     for old_i, new_i in zip(cur_indices, target_indices):
         sorted_fixturenames[new_i] = fixturenames[old_i]
     return sorted_fixturenames
+
+
+@pytest.hookimpl(tryfirst=True, hookwrapper=True)
+def pytest_collection_modifyitems(session, config, items):
+    """
+    An alternative to the `reorder_items` function in fixtures.py
+    (https://github.com/pytest-dev/pytest/blob/master/src/_pytest/fixtures.py#L209)
+
+    We basically set back the previous order once the pytest ordering routine has completed.
+
+    TODO we should set back an optimal ordering, but current PR https://github.com/pytest-dev/pytest/pull/3551
+     will probably not be relevant to handle our "union" fixtures > need to integrate the NOT_USED markers in the method
+
+    :param session:
+    :param config:
+    :param items:
+    :return:
+    """
+
+    # remember initial order
+    initial_order = copy(items)
+    yield
+    # put back the initial order
+    items[:] = initial_order

pytest_cases/tests/fixtures/test_so2.py

@@ -0,0 +1,68 @@
+# https://stackoverflow.com/questions/46909275/parametrizing-tests-depending-of-also-parametrized-values-in-pytest
+import pytest
+
+from pytest_cases import pytest_parametrize_plus, pytest_fixture_plus, fixture_ref
+
+datasets_contents = {
+    'datasetA': ['data1_a', 'data2_a', 'data3_a'],
+    'datasetB': ['data1_b', 'data2_b', 'data3_b']
+}
+
+DA = None
+
+@pytest_fixture_plus(scope="module")
+def datasetA():
+    global DA
+
+    # setup the database connection
+    print("setting up dataset A")
+    assert DA is None
+    DA = 'DA'
+
+    yield DA
+
+    # teardown the database connection
+    print("tearing down dataset A")
+    assert DA == 'DA'
+    DA = None
+
+
+@pytest_fixture_plus(scope="module")
+@pytest.mark.parametrize('data_index', range(len(datasets_contents['datasetA'])), ids="idx={}".format)
+def data_from_datasetA(datasetA, data_index):
+    assert datasetA == 'DA'
+    return datasets_contents['datasetA'][data_index]
+
+
+DB = None
+
+
+@pytest_fixture_plus(scope="module")
+def datasetB():
+    global DB
+
+    # setup the database connection
+    print("setting up dataset B")
+    assert DB is None
+    DB = 'DB'
+
+    yield DB
+
+    # teardown the database connection
+    print("tearing down dataset B")
+    assert DB == 'DB'
+    DB = None
+
+
+@pytest_fixture_plus(scope="module")
+@pytest.mark.parametrize('data_index', range(len(datasets_contents['datasetB'])), ids="idx={}".format)
+def data_from_datasetB(datasetB, data_index):
+    assert datasetB == 'DB'
+    return datasets_contents['datasetB'][data_index]
+
+
+@pytest_parametrize_plus('data', [fixture_ref('data_from_datasetA'),
+                                  fixture_ref('data_from_datasetB')])
+def test_databases(data):
+    # do test
+    print(data)