comment partager une variable entre les modules pour tous les tests dans py.test

J'ai plusieurs tests de la py.test qui sont situés dans plusieurs classes dans plusieurs fichiers.

Quelle est la façon la plus simple de partager un gros dictionnaire - que je ne veux pas de doublons avec toutes les méthodes de chaque classe dans chaque fichier pour être utilisé par py.test?

En bref, j'ai besoin de faire une "variable globale" pour chaque test. En dehors de py.de test, je n'ai pas besoin de cette variable, donc je ne veux pas de l'enregistrer dans les fichiers en cours d'essai. J'ai fait de l'utilisation fréquente de py.test de luminaires, mais cela semble exagéré pour ce besoin. C'est peut-être le seul moyen?

source d'informationauteur Trevor | 2014-03-31

  1. 4

    Mise à jour: faites défiler vers le bas pour une meilleure approche.

    Hormis une meilleure pytest option spécifique proposé par @flub, vous pouvez créer une base TestCase classe, définir une variable de classe et sous-classe de la classe de base dans tous les tests que vous avez:

    import unittest


class BaseTestCase(unittest.TestCase):
    my_dict = {'hello': 'world'}


class TestCase1(BaseTestCase):
    def test_my_dict_key(self):
        self.assertTrue('hello' in self.my_dict)


class TestCase2(BaseTestCase):
    def test_my_dict_value(self):
        self.assertTrue('world' in self.my_dict.values())
  2. 18

    Vous parler de la évidents et moins magique option: à l'aide d'un appareil. Vous pouvez l'appliquer à l'ensemble des modules à l'aide de pytestmark = pytest.mark.usefixtures('big_dict') dans votre module, mais alors il ne sera pas dans votre espace de noms de sorte demandant explicitement, il pourrait être la meilleure.

    Sinon, vous pouvez affecter des choses dans le pytest espace de noms à l'aide du crochet:

    # conftest.py

def pytest_namespace():
    return {'my_big_dict': {'foo': 'bar'}}

    Et maintenant vous avez pytest.my_big_dict. Le luminaire est probablement encore plus agréable.

  3. 9

    Il ya des tonnes de choses que j'aime à propos de py.de test, mais une chose que je DÉTESTE absolument est mal comment il joue avec le code outils d'intelligence. Je suis en désaccord qu'un autouse luminaire déclarer une variable est le plus "clair" de la méthode dans ce cas, parce que non seulement il complètement déflecteur mon linter, mais aussi toute autre personne qui n'est pas familier avec py.test fonctionne. Il y a beaucoup de magie il y a, de l'omi.

    Si, une chose que vous pouvez faire ne pas faire de votre linter exploser et ne nécessite pas de cas de test standard est de créer un module appelé globals. À l'intérieur de ce module, stub les noms des choses que vous voulez global {} ou Aucun et importer le module global dans vos tests. Puis dans votre conftest.py fichier, utilisez la py.test de crochets pour définir (ou réinitialiser) votre variable globale(s) selon le cas. Ceci a l'avantage de vous donner le stub pour travailler avec lors de la construction de tests et de l'ensemble des données pour les tests lors de l'exécution.

    Par exemple, vous pouvez utiliser le pytest_configure() crochet pour définir votre dict droit lors de la py.le test démarre. Ou, si vous voulez vous assurer que les données était vierge entre chaque test, vous pouvez autouse un appareil à attribuer à votre variable globale de votre état connu avant chaque test.

    # globals.py
my_data = {}  # Create a stub for your variable


# test_module.py
import globals as gbl

def test_foo():
    assert gbl.my_data['foo'] == 'bar'  # The global is in the namespace when creating tests


# conftest.py
import globals as gbl
my_data = {'foo': 'bar'}  # Create the master copy in conftest

@pytest.fixture(autouse=True)
def populate_globals():
    gbl.my_data = my_data  # Assign the master value to the global before each test

    Un autre avantage de cette approche est que vous pouvez utiliser le type de l'affinage dans votre globals module pour vous donner la complétion de code sur les objets globaux dans votre test, qui n'est probablement pas nécessaire pour un dict, mais je trouve ça pratique quand je suis en utilisant un objet (comme webdriver). 🙂

  4. 7

    D'avoir un gros dictionnaire de variables globales que chaque test est probablement une mauvaise idée. Si possible, je vous suggère de refactoring vos tests pour éviter ce genre de chose.

    Cela dit, voici comment j'allais le faire: définir un autouse luminaire qui ajoute une référence au dictionnaire dans l'espace de noms global de chaque fonction.

    Voici un peu de code. Tout est dans le même fichier, mais vous pouvez déplacer l'appareil à conftest.py au plus haut niveau de vos tests.

    import pytest

my_big_global = {'key': 'value'}

@pytest.fixture(autouse=True)
def myglobal(request):
    request.function.func_globals['foo'] = my_big_global

def test_foo():
    assert foo['key'] == 'value'

def test_bar():
    assert foo['key'] == 'bar'

    Voici la sortie de lorsque j'exécute ce code:

    $ py.test test_global.py -vv
======================================= test session starts =======================================
platform darwin -- Python 2.7.5 -- py-1.4.20 -- pytest-2.5.2 -- env/bin/python
collected 2 items

test_global.py:9: test_foo PASSED
test_global.py:12: test_bar FAILED

============================================ FAILURES =============================================
____________________________________________ test_bar _____________________________________________

    def test_bar():
>       assert foo['key'] == 'bar'
E       assert 'value' == 'bar'
E         - value
E         + bar

test_global.py:13: AssertionError
=============================== 1 failed, 1 passed in 0.01 seconds ===============================

    Notez que vous ne pouvez pas utiliser une session dans l'étendue du luminaire, car alors vous n'avez pas accès à chaque fonction de l'objet. De ce fait, je suis en train de faire assurez-vous de définir mon grand mondial dictionnaire une fois et utiliser des références à -- si j'ai défini le dictionnaire que l'instruction d'affectation, une nouvelle copie sera faite à chaque fois.

    En conclusion, de faire quelque chose comme ceci est probablement une mauvaise idée. Bonne chance 🙂

  5. 0

    Vous pouvez ajouter votre variable globale comme une option à l'intérieur de la pytest_addoption crochet.
    Il est possible de le faire de façon explicite avec addoption ou de l'utilisation set_defaults méthode si vous voulez que votre attribut être déterminée sans une inspection de la ligne de commande, docs

    Lorsque l'option a été défini, vous pouvez le coller à l'intérieur de n'importe quelle fixation avec request.config.getoption et ensuite de le passer le test explicitement ou avec autouse.
    Alternativement, vous pouvez passer votre option dans presque n'importe quel crochet à l'intérieur de la config objet.

    #conftest.py
def pytest_addoption(parser):    
    parser.addoption("--my_global_var", default="foo")
    parser.set_defaults(my_hidden_var="bar")

@pytest.fixture()
def my_hidden_var(request):
    return request.config.getoption("my_hidden_var")

#test.py
def test_my_hidden_var(my_hidden_var):
    assert my_hidden_var == "bar"
  6. 0

    Je suis surpris pas de réponse mentionné la mise en cache pas: depuis la version 2.8, pytest a un puissant mécanisme de cache.

    Exemple d'utilisation

    @pytest.fixture(autouse=True)
def init_cache(request):
    data = request.config.cache.get('my_data', None)
    data = {'spam': 'eggs'}
    request.config.cache.set('my_data', data)

    Accéder aux données dict dans les tests via builtin request appareil:

    def test_spam(request):
    data = request.cache.get('my_data')
    assert data['spam'] == 'eggs'

    Le partage des données entre les séries de tests

    La chose cool à propos de request.cache est qu'il est conservé sur le disque, de sorte qu'il peut même être partagé entre les séries de tests. C'est pratique lorsque vous exécutez des tests distribués (pytest-xdist) ou ont une longue génération de données qui ne changent pas une fois généré:

    @pytest.fixture(autouse=True)
def generate_data(request):
    data = request.config.cache.get('my_data', None)
    if data is None:
        data = long_running_generation_function()
        request.config.cache.set('my_data', data)

    Maintenant les tests n'aurez pas besoin de recalculer la valeur sur les différentes séries de tests, à moins de vider le cache sur disque de manière explicite. Prendre un coup d'oeil ce qui est actuellement dans le cache:

    $ pytest --cache-show
...
my_data contains:
  {'spam': 'eggs'}

    Relancer les tests avec le --cache-clear drapeau de supprimer le cache et forcer les données à être recalculé. Ou tout simplement supprimer le .pytest_cache dans le répertoire racine du projet dir.

    Où aller à partir d'ici

    La section dans pytest docs: Cache: travailler avec la croix-testrun état.