Passer un paramètre à une fonction de fixation

J'utilise py.test pour tester du code DLL enveloppé dans une classe python MyTester. À des fins de validation, je dois enregistrer certaines données de test pendant les tests et faire plus de traitement par la suite. Comme j'ai de nombreux fichiers de test _..., je souhaite réutiliser la création d'objet testeur (instance de MyTester) pour la plupart de mes tests.

Comme l'objet testeur est celui qui a obtenu les références aux variables et fonctions de la DLL, je dois transmettre une liste des variables de la DLL à l'objet testeur pour chacun des fichiers de test (les variables à enregistrer sont les mêmes pour un test_ .. . fichier). Le contenu de la liste est utilisé pour enregistrer les données spécifiées.

Mon idée est de le faire comme ceci:

import pytest

class MyTester():
    def __init__(self, arg = ["var0", "var1"]):
        self.arg = arg
        # self.use_arg_to_init_logging_part()

    def dothis(self):
        print "this"

    def dothat(self):
        print "that"

# located in conftest.py (because other test will reuse it)

@pytest.fixture()
def tester(request):
    """ create tester object """
    # how to use the list below for arg?
    _tester = MyTester()
    return _tester

# located in test_...py

# @pytest.mark.usefixtures("tester") 
class TestIt():

    # def __init__(self):
    #     self.args_for_tester = ["var1", "var2"]
    #     # how to pass this list to the tester fixture?

    def test_tc1(self, tester):
       tester.dothis()
       assert 0 # for demo purpose

    def test_tc2(self, tester):
       tester.dothat()
       assert 0 # for demo purpose

Est-il possible d'y parvenir comme ça ou y a-t-il encore une manière plus élégante?

Habituellement, je pourrais le faire pour chaque méthode de test avec une sorte de fonction de configuration (style xUnit). Mais je veux gagner une sorte de réutilisation. Est-ce que quelqu'un sait si cela est possible avec des luminaires?

Je sais que je peux faire quelque chose comme ça: (à partir de la documentation)

@pytest.fixture(scope="module", params=["merlinux.eu", "mail.python.org"])

Mais j'ai besoin de la paramétrisation directement dans le module de test. Est-il possible d'accéder à l'attribut params de l'appareil depuis le module de test?

Mise à jour: Étant donné que c'est la réponse acceptée à cette question et qu'elle est toujours votée parfois, je devrais ajouter une mise à jour. Bien que ma réponse originale (ci-dessous) était le seul moyen de le faire dans les anciennes versions de pytest, comme d' autres l' ont noté, pytest prend désormais en charge la paramétrisation indirecte des appareils. Par exemple, vous pouvez faire quelque chose comme ceci (via @imiric):

# test_parameterized_fixture.py
import pytest

class MyTester:
    def __init__(self, x):
        self.x = x

    def dothis(self):
        assert self.x

@pytest.fixture
def tester(request):
    """Create tester object"""
    return MyTester(request.param)


class TestIt:
    @pytest.mark.parametrize('tester', [True, False], indirect=['tester'])
    def test_tc1(self, tester):
       tester.dothis()
       assert 1

$ pytest -v test_parameterized_fixture.py
================================================================================= test session starts =================================================================================
platform cygwin -- Python 3.6.8, pytest-5.3.1, py-1.8.0, pluggy-0.13.1 -- /usr/bin/python3
cachedir: .pytest_cache
rootdir: .
collected 2 items

test_parameterized_fixture.py::TestIt::test_tc1[True] PASSED                                                                                                                    [ 50%]
test_parameterized_fixture.py::TestIt::test_tc1[False] FAILED

Cependant, bien que cette forme de paramétrisation indirecte soit explicite, comme le souligne @Yukihiko Shinoda , elle prend désormais en charge une forme de paramétrisation indirecte implicite (bien que je n'ai pas trouvé de référence évidente à cela dans la documentation officielle):

# test_parameterized_fixture2.py
import pytest

class MyTester:
    def __init__(self, x):
        self.x = x

    def dothis(self):
        assert self.x

@pytest.fixture
def tester(tester_arg):
    """Create tester object"""
    return MyTester(tester_arg)


class TestIt:
    @pytest.mark.parametrize('tester_arg', [True, False])
    def test_tc1(self, tester):
       tester.dothis()
       assert 1

$ pytest -v test_parameterized_fixture2.py
================================================================================= test session starts =================================================================================
platform cygwin -- Python 3.6.8, pytest-5.3.1, py-1.8.0, pluggy-0.13.1 -- /usr/bin/python3
cachedir: .pytest_cache
rootdir: .
collected 2 items

test_parameterized_fixture2.py::TestIt::test_tc1[True] PASSED                                                                                                                   [ 50%]
test_parameterized_fixture2.py::TestIt::test_tc1[False] FAILED

Je ne sais pas exactement quelle est la sémantique de cette forme, mais il semble que cela pytest.mark.parametrizereconnaisse que bien que la test_tc1méthode ne prenne pas d'argument nommé tester_arg, l' testerappareil qu'elle utilise le fait, donc il transmet l'argument paramétré à travers l' testerappareil.

J'ai eu un problème similaire - j'ai un appareil appelé test_package, et je voulais plus tard pouvoir passer un argument optionnel à cet appareil lors de son exécution dans des tests spécifiques. Par exemple:

@pytest.fixture()
def test_package(request, version='1.0'):
    ...
    request.addfinalizer(fin)
    ...
    return package

(Peu importe à ces fins ce que fait l'appareil ou le type d'objet renvoyé package ).

Il serait alors souhaitable d'utiliser d'une manière ou d'une autre cet appareil dans une fonction de test de telle sorte que je puisse également spécifier le version argument de cet appareil à utiliser avec ce test. Ce n'est actuellement pas possible, mais pourrait constituer une fonctionnalité intéressante.

En attendant, il était assez facile de faire en sorte que mon appareil renvoie simplement une fonction qui effectue tout le travail effectué précédemment par l'appareil, mais me permet de spécifier l' versionargument:

@pytest.fixture()
def test_package(request):
    def make_test_package(version='1.0'):
        ...
        request.addfinalizer(fin)
        ...
        return test_package

    return make_test_package

Maintenant, je peux utiliser ceci dans ma fonction de test comme:

def test_install_package(test_package):
    package = test_package(version='1.1')
    ...
    assert ...

etc.

La solution tentée par l'OP allait dans la bonne direction, et comme le suggère la réponse de @ hpk42 , le MyTester.__init__pourrait simplement stocker une référence à la demande comme:

class MyTester(object):
    def __init__(self, request, arg=["var0", "var1"]):
        self.request = request
        self.arg = arg
        # self.use_arg_to_init_logging_part()

    def dothis(self):
        print "this"

    def dothat(self):
        print "that"

Ensuite, utilisez ceci pour implémenter l'appareil comme:

@pytest.fixture()
def tester(request):
    """ create tester object """
    # how to use the list below for arg?
    _tester = MyTester(request)
    return _tester

Si vous le souhaitez, la MyTesterclasse pourrait être un peu restructurée afin que son .argsattribut puisse être mis à jour après sa création, afin de modifier le comportement des tests individuels.

Ceci est en fait pris en charge nativement dans py.test via une paramétrisation indirecte .

Dans votre cas, vous auriez:

@pytest.fixture
def tester(request):
    """Create tester object"""
    return MyTester(request.param)


class TestIt:
    @pytest.mark.parametrize('tester', [['var1', 'var2']], indirect=True)
    def test_tc1(self, tester):
       tester.dothis()
       assert 1

Vous pouvez accéder au module / à la classe / à la fonction de demande à partir des fonctions de fixation (et donc à partir de votre classe Tester), voir interagir avec la demande de contexte de test à partir d'une fonction de fixation . Ainsi, vous pouvez déclarer certains paramètres sur une classe ou un module et l'appareil de test peut le récupérer.

Je n'ai trouvé aucun document, cependant, il semble fonctionner dans la dernière version de pytest.

@pytest.fixture
def tester(tester_arg):
    """Create tester object"""
    return MyTester(tester_arg)


class TestIt:
    @pytest.mark.parametrize('tester_arg', [['var1', 'var2']])
    def test_tc1(self, tester):
       tester.dothis()
       assert 1

Pour améliorer un peu la réponse d'imiric : une autre manière élégante de résoudre ce problème est de créer des "fixtures de paramètres". Personnellement, je le préfère à la indirectfonctionnalité de pytest. Cette fonctionnalité est disponible à partir de pytest_cases, et l'idée originale a été suggérée par Sup3rGeo .

import pytest
from pytest_cases import param_fixture

# create a single parameter fixture
var = param_fixture("var", [['var1', 'var2']], ids=str)

@pytest.fixture
def tester(var):
    """Create tester object"""
    return MyTester(var)

class TestIt:
    def test_tc1(self, tester):
       tester.dothis()
       assert 1

Notez que pytest-casesfournit également @pytest_fixture_plusque vous permettre d'utiliser les marques de paramétrisation sur vos appareils, et @cases_dataqui vous permettent à la source de vos paramètres de fonctions dans un module distinct. Voir doc pour plus de détails. Je suis l'auteur au fait;)

J'ai fait un décorateur amusant qui permet d'écrire des accessoires comme celui-ci:

@fixture_taking_arguments
def dog(request, /, name, age=69):
    return f"{name} the dog aged {age}"

Ici, à gauche de /vous avez d'autres appareils, et à droite vous avez des paramètres qui sont fournis en utilisant:

@dog.arguments("Buddy", age=7)
def test_with_dog(dog):
    assert dog == "Buddy the dog aged 7"

Cela fonctionne de la même manière que les arguments de fonction. Si vous ne fournissez pas l' ageargument, celui par défaut,, 69est utilisé à la place. si vous ne fournissez pas nameou omettez le dog.argumentsdécorateur, vous obtenez le régulier TypeError: dog() missing 1 required positional argument: 'name'. Si vous avez un autre appareil qui prend la disputename , il n'est pas en conflit avec celui-ci.

Les appareils Async sont également pris en charge.

De plus, cela vous donne un bon plan d'installation:

$ pytest test_dogs_and_owners.py --setup-plan

SETUP    F dog['Buddy', age=7]
...
SETUP    F dog['Champion']
SETUP    F owner (fixtures used: dog)['John Travolta']

Un exemple complet:

from plugin import fixture_taking_arguments

@fixture_taking_arguments
def dog(request, /, name, age=69):
    return f"{name} the dog aged {age}"


@fixture_taking_arguments
def owner(request, dog, /, name="John Doe"):
    yield f"{name}, owner of {dog}"


@dog.arguments("Buddy", age=7)
def test_with_dog(dog):
    assert dog == "Buddy the dog aged 7"


@dog.arguments("Champion")
class TestChampion:
    def test_with_dog(self, dog):
        assert dog == "Champion the dog aged 69"

    def test_with_default_owner(self, owner, dog):
        assert owner == "John Doe, owner of Champion the dog aged 69"
        assert dog == "Champion the dog aged 69"

    @owner.arguments("John Travolta")
    def test_with_named_owner(self, owner):
        assert owner == "John Travolta, owner of Champion the dog aged 69"

Le code pour le décorateur:

import pytest
from dataclasses import dataclass
from functools import wraps
from inspect import signature, Parameter, isgeneratorfunction, iscoroutinefunction, isasyncgenfunction
from itertools import zip_longest, chain


_NOTHING = object()


def _omittable_parentheses_decorator(decorator):
    @wraps(decorator)
    def wrapper(*args, **kwargs):
        if not kwargs and len(args) == 1 and callable(args[0]):
            return decorator()(args[0])
        else:
            return decorator(*args, **kwargs)
    return wrapper


@dataclass
class _ArgsKwargs:
    args: ...
    kwargs: ...

    def __repr__(self):
        return ", ".join(chain(
               (repr(v) for v in self.args), 
               (f"{k}={v!r}" for k, v in self.kwargs.items())))


def _flatten_arguments(sig, args, kwargs):
    assert len(sig.parameters) == len(args) + len(kwargs)
    for name, arg in zip_longest(sig.parameters, args, fillvalue=_NOTHING):
        yield arg if arg is not _NOTHING else kwargs[name]


def _get_actual_args_kwargs(sig, args, kwargs):
    request = kwargs["request"]
    try:
        request_args, request_kwargs = request.param.args, request.param.kwargs
    except AttributeError:
        request_args, request_kwargs = (), {}
    return tuple(_flatten_arguments(sig, args, kwargs)) + request_args, request_kwargs


@_omittable_parentheses_decorator
def fixture_taking_arguments(*pytest_fixture_args, **pytest_fixture_kwargs):
    def decorator(func):
        original_signature = signature(func)

        def new_parameters():
            for param in original_signature.parameters.values():
                if param.kind == Parameter.POSITIONAL_ONLY:
                    yield param.replace(kind=Parameter.POSITIONAL_OR_KEYWORD)

        new_signature = original_signature.replace(parameters=list(new_parameters()))

        if "request" not in new_signature.parameters:
            raise AttributeError("Target function must have positional-only argument `request`")

        is_async_generator = isasyncgenfunction(func)
        is_async = is_async_generator or iscoroutinefunction(func)
        is_generator = isgeneratorfunction(func)

        if is_async:
            @wraps(func)
            async def wrapper(*args, **kwargs):
                args, kwargs = _get_actual_args_kwargs(new_signature, args, kwargs)
                if is_async_generator:
                    async for result in func(*args, **kwargs):
                        yield result
                else:
                    yield await func(*args, **kwargs)
        else:
            @wraps(func)
            def wrapper(*args, **kwargs):
                args, kwargs = _get_actual_args_kwargs(new_signature, args, kwargs)
                if is_generator:
                    yield from func(*args, **kwargs)
                else:
                    yield func(*args, **kwargs)

        wrapper.__signature__ = new_signature
        fixture = pytest.fixture(*pytest_fixture_args, **pytest_fixture_kwargs)(wrapper)
        fixture_name = pytest_fixture_kwargs.get("name", fixture.__name__)

        def parametrizer(*args, **kwargs):
            return pytest.mark.parametrize(fixture_name, [_ArgsKwargs(args, kwargs)], indirect=True)

        fixture.arguments = parametrizer

        return fixture
    return decorator