Conditional fixture dependencies with indirectly parameterized fixtures

[haxtibal]

I'd like to arrange some external resources foo and bar (say hardware) by means of fixtures. Consider these constraints

• resource foo can either be in state A or in state B
• resource bar can either be in state X or in state Y
• foo in state A requires bar in state X as dependency
• foo in state B requires bar in state Y as dependency
• setup of each resource is expensive, automatic reordering of tests for the least possible setup/teardowns is a goal
• test functions that request foo are spread over the whole test suite

To my understanding, mutual exclusivity (state A or B, state X or Z), can be expressed with indirectly parameterized fixtures:

@pytest.fixture(scope="session")
def bar(request):
    handle = setup_external_resource_bar(state=request.param)
    yield handle
    reset_external_resource_bar()

@pytest.fixture(scope="session")
def foo(request):  # <== how to express conditional dependency on either bar-X or bar-Y?
    handle = setup_external_resource_foo(state=request.param)
    yield handle
    reset_external_resource_foo()

But now I've no idea how to express a conditional dependency from foo on a bar in certain state, determined by value of foo's request.param, and still static enough to allow pytest to optimize test order based on that dependency in its reorder_items_atscope?

Is it possible? As I'm afraid the answer is going to be "currently no", how would you handle the above situation in best effort?

[haxtibal]

Meanwhile figured out one can do something along that line:

# conftest
def pytest_generate_tests(metafunc):
    for mark_parametrize in filter(lambda marker: marker.name == "parametrize", metafunc.definition.own_markers):
        param_names = mark_parametrize.args[0].split(',')
        param_values = mark_parametrize.args[1]
        for param_value in param_values:
            if not isinstance(param_value, list):
                param_value = [param_value]
            for fixture, fixture_param in zip(param_names, param_value):
                if fixture == "foo" and fixture_param == 'A':
                    metafunc.parametrize("bar", ['X'], scope="module")
                elif fixture == "foo" and fixture_param == 'B':
                    metafunc.parametrize("bar", ['Y'], scope="module")

# tests
@pytest.fixture(scope="module")
def bar(request):
    return request.param

@pytest.fixture(scope="module")
def foo(request, bar):
    return request.param, bar

@pytest.mark.parametrize("foo", ["A"], indirect=True)
def test_1(foo):
    assert foo == ("A", "X")

@pytest.mark.parametrize("foo", ["B"], indirect=True)
def test_2(foo):
    assert foo == ("B", "Y")

It solves my contrived example, but is of course very limited in general. It only handles parameters given via @pytest.mark.parametrize, and only handles one level of dependencies.

Still searching for a better idea... anybody?