I have a test setup wherein I have multiple parametrizations, and I have secondary tests that depend on primary tests for each parametrization. I have got the following dependency setup working (see my SO question here, although for this question I’m doing everything in one file for simplicity). However, now that I’m applying it, I’m running into the issue that I have to create two new fixtures for each parametrization, resulting in a lot of duplicated code.

My setup:

tests/
  - common.py
  - test_0.py

common.py:

import numpy as np

ints = [1, 2, 3]
strs = ['a', 'b']
pars1 = list(zip(np.repeat(ints, 2), np.tile(strs, 3)))
pars2 = list(zip(np.repeat(ints[:2], 2), np.tile(strs, 2)))

test_0.py:

import numpy as np
import pytest
from pytest_dependency import depends

from common import pars1, pars2


def idfnc_mark(val):
    if isinstance(val, (int, np.int32, np.int64)):
        return f"n{val}"

def idfnc_fix(val):
    return "n{}-{}".format(*val)

# I use markers here because I have a lot of code parametrized this way
perm_mk1 = pytest.mark.parametrize('num, lbl', pars1, ids=idfnc_mark)
perm_mk2 = pytest.mark.parametrize('num, lbl', pars2, ids=idfnc_mark)

# 2 of these parametrized tests should fail
@perm_mk1
@pytest.mark.dependency()
def test_a(num, lbl):
    if num == 2:
        assert False
    else:
        assert True

# 2 of these parametrized tests should fail
@perm_mk2
@pytest.mark.dependency()
def test_b(num, lbl):
    if lbl == 'b':
        assert False
    else:
        assert True

# Following the example in the documentation for parametrized dependency
@pytest.fixture(params=pars1, ids=idfnc_fix)
def perm_fixt1(request):
    return request.param

@pytest.fixture()
def dep_perms1(request, perm_fixt1):
    depends(request, ["test_a[n{}-{}]".format(*perm_fixt1)])
    return perm_fixt1

@pytest.mark.dependency()
def test_c(dep_perms1):
    pass

This all works as expected. But, now I want to define a test_d that depends on test_b, which is parametrized by pars2 not pars1. I really don’t want to make two new fixtures – my real code has 5 parametrizations, which would be 10 fixtures all following the exact same pattern. Is there a way to generate the dependent fixture in a function or factory of some sort? I tried something like this:

def make_dependency(name, params, ref_function, perm_format, id_func):

    @pytest.fixture(params=params, ids=id_func)
    def orig(request):
        return request.param

    @pytest.fixture(name=name)
    def dep_test(request, orig):
        depends(request, [ref_function+"["+perm_format.format(*orig)+"]"])
        return orig

    return dep_test

dep_pars1 = make_dependency("dep_pars1", pars1, "test_0.py", "test_a", "n{}-{}", idfnc_fix)

But, that complains that it can’t find the orig fixture. And that makes sort of sense, maybe; I did know that calling it multiple times would probably cause naming / scope issues. Does pytest-dependency support doing something like this?