How to gracefully skip pytest tests if optional dependencies are not installed?

[sam-hey]

I have a Python package with optional dependencies defined in pyproject.toml. I want to run pytest while ensuring that specific tests are executed only if the relevant optional dependencies are installed. Otherwise, these tests should be skipped.

For example, given optional dependencies like this in pyproject.toml:

[project.optional-dependencies]
extra_name = ["package_name>=1.0"]

I want to use a decorator like this:

@skip_if_optionals_are_not_installed("extra_name")
def test_something():
    # Test logic here
    pass

My current implementation idea looks like this:

import toml
from pathlib import Path
from functools import wraps

def __get_optional_requirements(module: str):
    with Path("pyproject.toml").open() as file:
        data = toml.load(file)

    optional_requirements = data.get("project", {}).get("optional-dependencies", {})
    return optional_requirements.get(module, [])

def requires_pip_optional_or_skip_test(optional_module_name):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            requirements = __get_optional_requirements(optional_module_name)
            for requirement in requirements:
                compare_versions(requirement)  # Some function to check if the         dependency is installed
            return func(*args, **kwargs)

        return wrapper
    return decorator

It feels cumbersome and could be improved.

Moved from: https://stackoverflow.com/questions/79361888/how-to-gracefully-skip-pytest-tests-if-optional-dependencies-are-not-installed

[nicoddemus]

The builtin way is to call importorskip inside the test.

def test_something():
    extra_name = pytest.importorskip("extra_name")
    # Test logic here
    pass

[sam-hey]

Hello @nicoddemus,

Yes, I’m aware of the option to skip a test. However, I’m not particularly fond of this approach. I would prefer using a marker, as it makes the test-skipping process more uniform and consistent.

This might also be related to this issue, where it was discussed that it’s not entirely clear to users whether skipping can be implemented as a marker or not.

I’d really love to see this functionality supported in pytest, as skipping tests du to not installed dependencies is likely a common use case.

[sam-hey]

As you can see here, it is a common misconception that using @pytest.importorskip("extra_name") works

[The-Compiler]

I wouldn't say "common", given that a GitHub search shows some < 10 repositories with wrong usage.

[The-Compiler]

Personally I'd be in favor of a @pytest.mark.import_or_skip("somelibrary"), especially because from somelibrary import a_thing feels way more ergonomic than doing a_thing = pytest.importorskip("somelibrary").a_thing.

Perhaps it could even have a version check (via importlib.metadata) if that' s something that people end up wanting.

However, I see no reason why this needs to start in the core rather than a plugin. The usual approach for this is that someone starts with a plugin, and once the details are figured out and there is some usage behind it, it's worth a discussion whether to merge the functionality into pytest core (like happened with faulthandler or logging).

I'm completely lost in the example implementation of the OP though. Where is skip_if_optionals_are_not_installed defined (is that actually requires_pip_optional_or_skip_test?), and why does read things from pyproject.toml at all (which has PyPI package names, which is not necessarily the same thing as an import name)?

[sam-hey]

Thank you so much for the explanation and the tip! I've clarified my question a bit further. Perhaps it might be worthwhile to consider turning this into a project.

[The-Compiler]

For what it's worth, here is how I currently would implement a helper like what you describe:

import pytest
import importlib


def skip_if_missing(name: str):
    try:
        importlib.import_module(name)
    except ModuleNotFoundError:
        return pytest.mark.skip(f"{name} missing")
    return lambda func: func


@skip_if_missing("extra_name")
def test_something():
    pass

[sam-hey]

Maybe my question needs a little more explanation:
The problem revolves around optional dependencies defined in the pyproject.toml file under the [project.optional-dependencies] section. These dependencies can be installed as a group using the syntax:

pip install package_name[extra_name]
For example:

[project.optional-dependencies]
extra_name = ["package_name>=1.0", "another_package>=1.0"]

Currently, there is no built-in or straightforward way to test if all the optional dependencies in a group are valid and available. A standard import test is not sufficient because:

The package name used in the dependency list may differ from the actual module name used for imports.
For example:
The package PyStemmer is installed via pip install PyStemmer, but you import it in Python using import stemmer.

I would like to test this without having to write out every individual import statement. Instead, I want to validate the entire dependency group specified as package_name[extra_name]. Since there are so many projects that might face a similar challenge, I was hoping to find experts here who could offer some guidance or solutions.