Pytest: How to know which fixture is used in a test

Question

Maybe I'm not "getting" the philosophy of py.test... I'm trying to re-write a bunch of tests for aws lambda code that receives events (webhooks with json payloads) and processes them. I have stored a bunch of these events in .json files and have used them as fixtures. Now, in some tests, I would like to test that the code I'm running returns the correct value for different specific fixtures. Currently I have it structured like so

OD_SHIPMENT_EVENT_FILE = 'od_shipment_event.json'

def event_file_path(file_name):
    return os.path.join(
        os.path.dirname(__file__),
        'events',
        file_name
    )

@pytest.fixture()
def event(event_file=EVENT_FILE):
    '''Trigger event'''
    with open(event_file) as f:
        return json.load(f)

def load_event(event_file_path):
    with open(event_file_path) as f:
        return json.load(f)

@pytest.fixture(params=[event_file_path(OD_SHIPMENT_EVENT_FILE),
                        event_file_path(OD_SHIPMENT_EVENT_FILE_EU), 
                        event_file_path(OD_SHIPMENT_EVENT_FILE_MULTIPLE),
                        event_file_path(OD_BADART_SHIPMENT_EVENT_FILE),
                        ])
def od_event(request):
    return load_event(request.param) 

...

def test__get_order_item_ids_from_od_shipment(od_event):
    items = get_order_item_ids_from_od_shipment_event(od_event)
    assert items

That last test will be run with each of the fixtures passed in as parameters. But depending on which one it is, I would like to check that 'items' is some value.

The closest thing I found was Parametrizing fixtures and test functions but I'm not sure this is the correct way to go or if I'm missing something in the philosophy of Pytest. Would love any pointers or feedback.

Also, that even file loading code is probably bloated and could be cleaned up. Suggestions are welcome.

Update

Based on the answer by Christian Karcher below, this helps a bit

@pytest.fixture
def parametrized_od_event(request):
    yield load_event(request.param)

@pytest.mark.parametrize("parametrized_od_event", 
                         [event_file_path(OD_BADART_ORDER_UPDATE),], 
                         indirect=True)
def test__get_badart_items_from_order_metadata(parametrized_od_event):
    bad_art_items = get_badart_item_ids_from_order_metadata(parametrized_od_event)
    assert 3 == len(bad_art_items)

But I would like to do something a bit cleaner like this:

    @pytest.mark.parametrize("parametrized_od_event,expected",                          
                       [(event_file_path(OD_BADART_ORDER_UPDATE), 3),
                       (event_file_path(OD_NOBADART_ORDER_UPDATE), 0)],
                         indirect=True)
    def test__get_badart_items_from_order_metadata_multi(parametrized_od_event,expected):
            bad_art_items = get_badart_item_ids_from_order_metadata(parametrized_od_event)
            assert expected == len(bad_art_items)

In the second example, if I use indirect=True it can't find the expected fixture, and if I don't use indirect=True it doesn't actually call the parametrized_od_event fixture and simply passes the path to the file, without loading it.

Answer 1

Your way of parametrizing the fixture looks okay to me.

An alternative way would be indirect parametrization of the fixture during the test. This way, each test can have its own subset of individual parameters:

import pytest


@pytest.fixture
def od_event(request):
    yield request.param * 5


@pytest.mark.parametrize("od_event", [1, 2, 3], indirect=True)
def test_get_order_item_ids_from_od_shipment(od_event):
    assert od_event < 10

Some further pointers:

Make your fixtures yield instead of return its value, this way you can optionally include teardown code afterwards.

Suggestion for the file loading code: pathlib.Path with slash as a path join operator is always a nice option:

from pathlib import Path

def event_file_path(file_name):
    return Path(__file__).parent / 'events' / file_name