How to reference one of two parameters from test on fixtures?

[julianonunes]

I have the following code sample to reproduce the behavior I need:

@pytest.fixture
def mocker_search_posts(mocker):
    post = Post(
        id=1,
        title='Title',
        body='Body',
        tags=['tag A']
    )

    patch = mocker.patch('path.to.search_posts', return_value=[post])
    
    return [post, patch]


@pytest.fixture
def mocker_create_post(mocker, request):
    post = Post(
        id=0,
        title='New Post Title',
        body='Body',
        tags=request.node.funcargs['tags']
    )

    return mocker.patch('path.to.create_post', return_value=post)

@pytest.fixture
def mocker_search_comments(mocker, request):
    comment = Comment(
        id=1,
        content='Comment content',
        moderation_date: request.node.funcargs['date']
    )

    patch = mocker.patch('path.to.search_comments', return_value=[comment])
    
    return [comment, patch]
    

@pytest.mark.parametrize("tags",
                     [["tag A"], ["tag A", "tag B"]],
                     indirect=True)
@pytest.mark.parametrize("date",
                     [datetime.now(pytz.utc), datetime.now(pytz.utc) - timedelta(minutes=26)],
                     indirect=True)    
@pytest.mark.usefixtures("mocker_search_comments")
def test_row_creation(mocker_search_posts, mocker_create_post):
    pass # just for the sake of clarity

As you may check, I defined two parametrize on test_row_creation, then I need to access tags parameter value on mocker_create_post fixture and to access date parameter value on mocker_search_comments.

The example above gives the error "KeyError: 'date' at moderation_date: request.node.funcargs['date']"

This is so I can have a more generic fixture and add the scenarios using two parametrize in my test. If you know a more apropriate way to achieve it, it will be certainly welcome too.

[nicoddemus]

Hi @julianonunes,

You should use the same name of the fixtures that you want the pass the parameters to, and also access the parametrization value using request.param, see Indirect parametrization in the documentation.

Updated your example (only the relevant parts):

@pytest.fixture
def mocker_create_post(mocker, request):
    post = Post(
        id=0,
        title='New Post Title',
        body='Body',
        tags=request.param
    )

    return mocker.patch('path.to.create_post', return_value=post)

@pytest.fixture
def mocker_search_comments(mocker, request):
    comment = Comment(
        id=1,
        content='Comment content',
        moderation_date=request.param
    )

    patch = mocker.patch('path.to.search_comments', return_value=[comment])
    
    return [comment, patch]
    

@pytest.mark.parametrize("mocker_create_post",
                     [["tag A"], ["tag A", "tag B"]],
                     indirect=True)
@pytest.mark.parametrize("mocker_search_comments",
                     [datetime.now(pytz.utc), datetime.now(pytz.utc) - timedelta(minutes=26)],
                     indirect=True)    
@pytest.mark.usefixtures("mocker_search_comments")
def test_row_creation(mocker_search_posts, mocker_create_post):
    pass # just for the sake of clarity

[julianonunes]

Thanks, Bruno. It worked.
Just one more question. Is it possible to access the value of these two fixtures in a third fixture? I'm looking for a way to create a fixture of expected output, like this:

expected_call_output = {
    "tag A": {
        str(datetime.now(pytz.utc)): True,
        str(datetime.now(pytz.utc) - timedelta(minutes=26)): True },
    ("tag A", "tag B"): {
        str(datetime.now(pytz.utc)): False,
        str(datetime.now(pytz.utc) - timedelta(minutes=26)): True }
}

@pytest.fixture
def expected_output_multiple_packages_dispute(request):
    #tags = tuple(request.node.funcargs['ticket_with_create_dispute_tag'])
    #date = request.node.funcargs['mocker_search_zen_comments']
    return expected_call_output.get(tags, {}).get(date, None)

So I would do this in the test:

@pytest.mark.parametrize("mocker_create_post",
                     [["tag A"], ["tag A", "tag B"]],
                     indirect=True)
@pytest.mark.parametrize("mocker_search_comments",
                     [datetime.now(pytz.utc), datetime.now(pytz.utc) - timedelta(minutes=26)],
                     indirect=True)    
@pytest.mark.usefixtures("mocker_search_comments")
def test_row_creation(mocker_search_posts, mocker_create_post, expected_output_multiple_packages_dispute):
    assert mocker_create_post.called == expected_output_multiple_packages_dispute

[nicoddemus]

Hmm probably the best way to do that is just to update the fixtures to return tags and date as part of their return values.

However I think this got pretty complicated already, perhaps it is best to just change from fixtures to functions? Something like:

def mock_search_post(mocker, tags):
    post = Post(
        id=1,
        title="Title",
        body="Body",
        tags=tags,
    )
    mocker.patch("path.to.search_posts", return_value=[post])
    return post


def mock_create_post(mocker, tags):
    post = Post(
        id=0,
        title="New Post Title",
        body="Body",
        tags=tags,
    )

    mocker.patch("path.to.create_post", return_value=post)
    return post


def mock_search_comments(mocker, date):
    comment = Comment(id=1, content="Comment content", moderation_date=date)

    patch = mocker.patch("path.to.search_comments", return_value=[comment])
    return comment


@pytest.mark.parametrize("tags", [["tag A"], ["tag A", "tag B"]])
@pytest.mark.parametrize(
    "date",
    [datetime.now(pytz.utc), datetime.now(pytz.utc) - timedelta(minutes=26)],
)
def test_row_creation(mocker, tags, date):
    post = mock_create_post(mocker, tags)
    comment = mock_search_comments(mocker, date)
    ...

[nicoddemus]

Also because you are now trying to match an expected output against a set of specific tags and a date, I would not use the automatic composition of parameters, instead I would list them individually together with each expected output:

@pytest.mark.parametrize(
    "tags, date, expected_output",
    [
        (["tag A"], datetime.now(pytz.utc), "expected output A-now"),
        (["tag A", "tag B"], datetime.now(pytz.utc), "expected output AB-now"),
        (
            ["tag A"],
            datetime.now(pytz.utc) - timedelta(minutes=26),
            "expected output A-later",
        ),
        (
            ["tag A", "tag B"],
            datetime.now(pytz.utc) - timedelta(minutes=26),
            "expected output AB-later",
        ),
    ],
)
def test_row_creation(mocker, tags, date, expected_output):
    post = mock_create_post(mocker, tags)
    comment = mock_search_comments(mocker, date)
    ...

So we can list each set of tags and date along with their expected output, which is more straightforward and easier to maintain.

[julianonunes]

Awesome. I'll try that in my codebase. Thank you so much.