How can I rewrite this fixture call so it won't be called directly?

user_2075859 0
Viewed 441

I defined the following fixture in a test file:

import os
from dotenv import load_dotenv, find_dotenv
from packaging import version # for comparing version numbers

load_dotenv(find_dotenv())
VERSION = os.environ.get("VERSION")
API_URL = os.environ.get("API_URL")

@pytest.fixture()
def skip_before_version():
    """
    Creates a fixture that takes parameters
    skips a test if it depends on certain features implemented in a certain version

    :parameter target_version:
    :parameter type: string
    """
    def _skip_before(target_version):
        less_than = version.parse(current_version) < version.parse(VERSION) 
        return pytest.mark.skipif(less_than)
    return _skip_before


skip_before = skip_before_version()("0.0.1")

I want to use skip_before as a fixture in certain tests. I call it like this:

#@skip_before_version("0.0.1")     # tried this before and got the same error, so tried reworking it...
@when(parsers.cfparse("{categories} are added as categories"))
def add_categories(skip_before, create_tree, categories):   # now putting the fixture alongside parameters
    pass

When I run this, I get the following error:

Fixture "skip_before_version" called directly. Fixtures are not meant to be called directly,
but are created automatically when test functions request them as parameters.
See https://docs.pytest.org/en/stable/fixture.html for more information about fixtures, and
https://docs.pytest.org/en/stable/deprecations.html#calling-fixtures-directly about how to update your code.

How is this still being called directly? How can I fix this?

pytest fixtures decorator python
1 Answers

If I understand your goal correctly, you want to be able to skip tests based on a version restriction specifier. There are many ways to do that; I can suggest an autouse fixture that will skip the test based on a custom marker condition. Example:

import os
import pytest
from packaging.specifiers import SpecifierSet


VERSION = "1.2.3"  # read from environment etc.


@pytest.fixture(autouse=True)
def skip_based_on_version_compat(request):
    # get the version_compat marker
    version_compat = request.node.get_closest_marker("version_compat")
    if version_compat is None:  # test is not marked
        return

    if not version_compat.args:  # no specifier passed to marker
        return

    spec_arg = version_compat.args[0]
    spec = SpecifierSet(spec_arg)

    if VERSION not in spec:
        pytest.skip(f"Current version {VERSION} doesn't match test specifiers {spec_arg!r}.")

The fixture skip_based_on_version_compat will be invoked on each test, but only do something if the test is marked with @pytest.mark.version_compat. Example tests:

@pytest.mark.version_compat(">=1.0.0")
def test_current_gen():
    assert True


@pytest.mark.version_compat(">=2.0.0")
def test_next_gen():
    raise NotImplementedError()

With VERSION = "1.2.3", the first test will be executed, the second one will be skipped. Notice the invocation of pytest.skip to immediately skip the test. Returning pytest.mark.skip in the fixture will bring you nothing since the markers are already evaluated long before that.

Also, I noticed you are writing gherkin tests (using pytest-bdd presumably). With the above approach, skipping the whole scenarios should be also possible:

@pytest.mark.version_compat(">=1.0.0")
@scenario("my.feature", "my scenario")
def test_scenario():
    pass

Alternatively, you can mark the scenarios in feature files:

Feature: Foo
    Lorem ipsum dolor sit amet.

    @version_compat(">=1.0.0")
    Scenario: doing future stuff
        Given foo is implemented
        When I see foo
        Then I do bar

and use pytest-bdd-own hooks:

def pytest_bdd_apply_tag(tag, function):
    matcher = re.match(r'^version_compat\("(?P<spec_arg>.*)"\)$', tag)
    spec_arg = matcher.groupdict()["spec_arg"]
    spec = SpecifierSet(spec_arg)
    if VERSION not in spec:
        marker = pytest.mark.skip(
            reason=f"Current version {VERSION} doesn't match restriction {spec_arg!r}."
        )
        marker(function)
        return True

Unfortunately, neither custom fixtures nor markers will work with skipping in single steps (and you will still be skipping the whole scenario since it is an atomic test unit in gherkin). I didn't find a reliable way to befriend pytest-bdd steps with pytest stuff; looks like they are simply ignored. Nevertheless, you can easily write a custom decorator serving the same purpose:

import functools


def version_compat(spec_arg):

    def deco(func):

        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            spec = SpecifierSet(spec_arg)
            if VERSION not in spec:
                pytest.skip(f"Current version {VERSION} doesn't match test specifiers {spec_arg!r}.")
            return func(*args, **kwargs)

        return wrapper

    return deco

Using version_compat deco in a step:

@when('I am foo')
@version_compat(">=2.0.0")
def i_am_foo():
    ...

Pay attention to the ordering - placing decorators outside of pytest-bdd's own stuff will not trigger them (I guess worth opening an issue, but meh).

user_26502490
Related