pytest session scope fixtures – Tests Python – Formation Python, php, javascript et référencement web

Formation gratuite Python

Dans les écrous et les boulons des appareils pytest, j'ai remarqué que vous pouvez spécifier l'étendue de la session de sorte qu'un appareil ne s'exécute qu'une fois par session de test et qu'il soit disponible pour plusieurs fonctions, classes et modules de test.

Dans cet article, je vais vous montrer un exemple simple pour que vous puissiez le voir en action.

Voici le tableau du post précédent:

une fonction	Exécuter une fois par test
classe	Exécuter une fois par classe de tests
module	Exécuter une fois par module
session	Exécuter une fois par session

Un fichier séparé pour les fixtures, conftest.py

Avec les fonctions, les classes et les modules, il est tout à fait raisonnable que le code de la fixture soit dans le même fichier que les tests.
Mais maintenant, avec la session, cela n’a plus de sens.

Nous pouvons les mettre dans conftest.py. C'est un fichier nommé spécial que pytest recherche.
La documentation indique que c'est pour les plugins locaux, mais nous pouvons également l'utiliser pour les fixtures locales. Consultez le site pytest.org pour connaître l'emplacement et la portée de conftest.py.

Exemple simple de fixtures de portée de session

Je pense que le plus clair est de voir cela en action.

J'ai 4 fichiers:

conftest.py
- 2 rencontres
- my_own_session_run_at_beginning, un appareil automatique avec portée de session
- some_resource, un appareil normal non autouse avec une étendue de session
test_alpha.py
- 2 fonctions de test simples
- test_alpha_1, n'a pas de fixtures nommées
- test_alpha_2, a un appareil nommé, une_source
test_beta.py
- similaire à test_alpha.py, mais avec des tests unittest
test_gamma.py
- similaire à test_alpha.py, mais avec des tests de classe

conftest.py:




</p>
<p>importation pytest</p>
<p>@ pytest.fixture (scope = "session", autouse = True)<br />
def my_own_session_run_at_beginning (demande):<br />
    print (' nIn my_own_session_run_at_beginning ()')</p>
<p>    def my_own_session_run_at_end ():<br />
            print ('In my_own_session_run_at_end ()')<br />
    request.addfinalizer (my_own_session_run_at_end)</p>
<p>@ pytest.fixture (scope = "session")<br />
def some_resource (demande):<br />
    print (' nIn some_resource ()')</p>
<p>    def some_resource_fin ():<br />
            print (' nIn some_resource_fin ()')<br />
    request.addfinalizer (some_resource_fin)





1
2
3
4
5
6
7
8
9
dix
11
12
13
14
15
16
17
18




importation pytest

@pytest.fixation(portée="session", autouse=Vrai)
def my_own_session_run_at_beginning(demande):
    impression(' nIn my_own_session_run_at_beginning ()')

    def my_own_session_run_at_end():
            impression('In my_own_session_run_at_end ()')
    demande.additif final(my_own_session_run_at_end)

@pytest.fixation(portée="session")
def une_resource(demande):
    impression(' nDans some_resource ()')

    def une_source_fin():
            impression(' nIn some_resource_fin ()')
    demande.additif final(une_source_fin)






test_alpha.py: 



</p>
<p>def test_alpha_1 ():<br />
    print (' nIn test_alpha_1 ()')</p>
<p>def test_alpha_2 (some_resource):<br />
    print (' nIn test_alpha_2 ()')







def test_alpha_1():
    impression(' nIn test_alpha_1 ()')

def test_alpha_2(une_resource):
    impression(' nIn test_alpha_2 ()')






test_beta.py: 



</p>
<p>importer unittest<br />
importation pytest</p>
<p>classe BetaTest (unittest.TestCase):<br />
    def test_unit_beta_1 (auto):<br />
        print (' nIn test_unit_beta_1 ()')</p>
<p>    @ pytest.mark.usefixtures ('some_resource')<br />
    def test_unit_beta_2 (auto):<br />
        print (' nIn test_unit_beta_2 ()')







importation Test de l'unité
importation pytest

classe Test beta(Test de l'unité.Cas de test):
    def test_unit_beta_1(soi):
        impression(' nIn test_unit_beta_1 ()')

    @pytest.marque.utilités('une_resource')    
    def test_unit_beta_2(soi):
        impression(' nIn test_unit_beta_2 ()')






test_gamma.py: 



</p>
<p>classe TestGamma:<br />
    def test_gamma_1 (auto):<br />
        print (' nIn test_gamma_1 ()')</p>
<p>    def test_gamma_2 (self, some_resource):<br />
        print (' nIn test_gamma_2 ()')







classe TestGamma:
    def test_gamma_1(soi):
        impression(' nIn test_gamma_1 ()')

    def test_gamma_2(soi, une_resource):
        impression(' nIn test_gamma_2 ()')






Sortie
Courir avec pytest -s -v 


</p>
<p>============================== La session de test commence ================= ============<br />
plateforme darwin – Python 2.7.5 – py-1.4.20 – pytest-2.5.2 – / usr / bin / python<br />
collectionner … collecté 6 articles</p>
<p>test_alpha.py:1: test_alpha_1<br />
Dans my_own_session_run_at_beginning ()</p>
<p>Dans test_alpha_1 ()<br />
PASSÉ<br />
test_alpha.py:4: test_alpha_2<br />
Dans some_resource ()</p>
<p>Dans test_alpha_2 ()<br />
PASSÉ<br />
test_beta.py:5: BetaTest.test_unit_beta_1<br />
Dans test_unit_beta_1 ()<br />
PASSÉ<br />
test_beta.py:8: BetaTest.test_unit_beta_2<br />
Dans test_unit_beta_2 ()<br />
PASSÉ<br />
test_gamma.py:2: TestGamma.test_gamma_1<br />
Dans test_gamma_1 ()<br />
PASSÉ<br />
test_gamma.py:5: TestGamma.test_gamma_2<br />
Dans test_gamma_2 ()<br />
PASSÉ<br />
Dans some_resource_fin ()<br />
Dans my_own_session_run_at_end ()<br />
=========================== 6 passés en 0.04 secondes ================= =========<br />






1
2
3
4
5
6
7
8
9
dix
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31




============================= tester session départs ==============================
Plate-forme Darwin – Python 2.7.5 – py–1.4.20 – pytest–2.5.2 – /usr/poubelle/python
la collecte ... collecté 6 articles

test_alpha.py:1: test_alpha_1 
Dans my_own_session_run_at_beginning()

Dans test_alpha_1()
PASSÉ
test_alpha.py:4: test_alpha_2 
Dans une_resource()

Dans test_alpha_2()
PASSÉ
test_beta.py:5: Test beta.test_unit_beta_1 
Dans test_unit_beta_1()
PASSÉ
test_beta.py:8: Test beta.test_unit_beta_2 
Dans test_unit_beta_2()
PASSÉ
test_gamma.py:2: TestGamma.test_gamma_1 
Dans test_gamma_1()
PASSÉ
test_gamma.py:5: TestGamma.test_gamma_2 
Dans test_gamma_2()
PASSÉ
Dans une_source_fin()
Dans my_own_session_run_at_end()
=========================== 6 passé dans 0,04 secondes ===========================







Fonction de mixage, portée du module et de la session
Disons que j’ai:

une fixture de portée de fonction 'resource_c'
qui utilise un fixture de module 'fixture_b'
qui utilise un fixture de session 'fixture_a'

Tout cela fonctionne bien.
Également dans cet exemple, j’ai ajouté quelques appareils autouse juste pour le plaisir.
conftest.py: 



</p>
<p>importation de pytest</p>
<p>@ pytest.fixture (scope = "session")<br />
def resource_a (demande):<br />
    print ('Dans ressource_a ()')</p>
<p>    def resource_a_fin ():<br />
            print (' nIn resource_a_fin ()')<br />
    request.addfinalizer (resource_a_fin)</p>
<p>@ pytest.fixture (scope = "module")<br />
def resource_b (request, resource_a):<br />
    print ('Dans resource_b ()')</p>
<p>    def resource_b_fin ():<br />
            print (' nIn resource_b_fin ()')<br />
    request.addfinalizer (resource_b_fin)</p>
<p>@ pytest.fixture (scope = "function")<br />
def resource_c (request, resource_b):<br />
    print ('Dans resource_c ()')</p>
<p>    def resource_c_fin ():<br />
            print (' nIn resource_c_fin ()')<br />
    request.addfinalizer (resource_c_fin)</p>
<p># ce ne sont que quelques diviseurs amusants pour rendre la sortie jolie<br />
# Complètement inutile, je jouais avec des appareils d'autouse<br />
@ pytest.fixture (scope = "function", autouse = True)<br />
def divider_function (demande):<br />
    print (' n — function% s () start —'% request.function .__ name__)<br />
    def fin ():<br />
            print ('— function% s () done —'% request.function .__ name__)<br />
    request.addfinalizer (fin)</p>
<p>@ pytest.fixture (scope = "module", autouse = True)<br />
def divider_module (demande):<br />
    print (' n ——- module% s start ———'% request.module .__ name__)<br />
    def fin ():<br />
            print ('——- module% s terminé ———'% request.module .__ name__)<br />
    request.addfinalizer (fin)</p>
<p>@ pytest.fixture (scope = "session", autouse = True)<br />
def divider_session (demande):<br />
    print (' n ———– début de la session —————')<br />
    def fin ():<br />
            print ('———– session terminée —————')<br />
    request.addfinalizer (fin)





1
2
3
4
5
6
7
8
9
dix
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49




importation pytest

@pytest.fixation(portée="session")
def ressource_a(demande):
    impression('Dans resource_a ()')

    def resource_a_fin():
            impression(' nIn resource_a_fin ()')
    demande.additif final(resource_a_fin)

@pytest.fixation(portée="module")
def ressource_b(demande, ressource_a):
    impression('Dans resource_b ()')

    def resource_b_fin():
            impression(' nIn resource_b_fin ()')
    demande.additif final(resource_b_fin)

@pytest.fixation(portée="une fonction")
def ressource_c(demande, ressource_b):
    impression('Dans resource_c ()')

    def resource_c_fin():
            impression(' nIn resource_c_fin ()')
    demande.additif final(resource_c_fin)

# ce ne sont que quelques diviseurs amusants pour rendre la sortie jolie
# Complètement inutile, je jouais avec des appareils d'autouse
@pytest.fixation(portée="une fonction", autouse=Vrai)
def fonction de diviseur(demande):
    impression(' n — function% s () start —' % demande.une fonction.__prénom__)
    def ailette():
            impression('— function% s () done —' % demande.une fonction.__prénom__)
    demande.additif final(ailette)

@pytest.fixation(portée="module", autouse=Vrai)
def divider_module(demande):
    impression(' n ——- module% s start ———' % demande.module.__prénom__)
    def ailette():
            impression('——- module% s terminé ———' % demande.module.__prénom__)
    demande.additif final(ailette)

@pytest.fixation(portée="session", autouse=Vrai)
def divider_session(demande):
    impression(' n ———– début de la session —————')
    def ailette():
            impression('———– session terminée —————')
    demande.additif final(ailette)






test_one_two.py: 



</p>
<p>def test_one (resource_c):<br />
    print ('Dans test_one ()')</p>
<p>def test_two (resource_c):<br />
    print (' nIn test_two ()')







def test_one(ressource_c):
    impression('Dans test_one ()')

def test_two(ressource_c):
    impression(' nIn test_two ()')






test_three_four.py: 



</p>
<p>def test_three (resource_c):<br />
    print (' nIn test_three ()')</p>
<p>def test_four (resource_c):<br />
    print (' nIn test_four ()')







def test_trois(ressource_c):
    impression(' nIn test_three ()')

def test_four(ressource_c):
    impression(' nIn test_four ()')






Cela me semble raisonnable.
Que penses-tu qu'il va se passer?
sortie: 



</p>
<p>$ py.test -s -v<br />
==================================== La session de test commence =========== ==========================<br />
plateforme darwin – Python 2.7.5 – py-1.4.20 – pytest-2.5.2 – / usr / bin / python<br />
collectionné 4 articles</p>
<p>test_one_two.py:1: test_one<br />
———– début de session —————</p>
<p>    ——- module test_one_two start ———</p>
<p>        — fonction test_one () démarrer —<br />
Dans resource_a ()<br />
Dans resource_b ()<br />
Dans resource_c ()<br />
Dans test_one ()<br />
PASSÉ<br />
Dans resource_c_fin ()<br />
        — fonction test_one () fait —</p>
<p>test_one_two.py:4: test_two<br />
        — fonction test_two () démarre —<br />
Dans resource_c ()</p>
<p>Dans test_two ()<br />
PASSÉ<br />
Dans resource_c_fin ()<br />
        — fonction test_two () fait —</p>
<p>Dans resource_b_fin ()<br />
    ——- module test_one_two done ———</p>
<p>test_three_four.py:1: test_three<br />
    ——- module test_three_four start ———</p>
<p>        — fonction test_three () démarre —<br />
Dans resource_b ()<br />
Dans resource_c ()</p>
<p>Dans test_three ()<br />
PASSÉ<br />
Dans resource_c_fin ()<br />
        — fonction test_three () fait —</p>
<p>test_three_four.py:4: test_four<br />
        — fonction test_four () démarre —<br />
Dans resource_c ()</p>
<p>Dans test_four ()<br />
PASSÉ<br />
Dans resource_c_fin ()<br />
        — fonction test_four () fait —</p>
<p>Dans resource_b_fin ()<br />
    ——- module test_three_four done ———</p>
<p>Dans resource_a_fin ()<br />
———– session terminée —————</p>
<p>================================= 4 passés en 0.02 secondes ============ =======================





1
2
3
4
5
6
7
8
9
dix
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60




$ py.tester –s –v
==================================== tester session départs ====================================
Plate-forme Darwin – Python 2.7.5 – py–1.4.20 – pytest–2.5.2 – /usr/poubelle/python
collecté 4 articles 

test_one_two.py:1: test_one 
–––––– session début ––––––––

    –––– module test_one_two début –––––

        –– une fonction test_one() début ––
Dans ressource_a()
Dans ressource_b()
Dans ressource_c()
Dans test_one()
PASSÉ
Dans resource_c_fin()
        –– une fonction test_one() terminé ––

test_one_two.py:4: test_two 
        –– une fonction test_two() début ––
Dans ressource_c()

Dans test_two()
PASSÉ
Dans resource_c_fin()
        –– une fonction test_two() terminé ––

Dans resource_b_fin()
    –––– module test_one_two terminé –––––

test_three_four.py:1: test_trois 
    –––– module test_three_four début –––––

        –– une fonction test_trois() début ––
Dans ressource_b()
Dans ressource_c()

Dans test_trois()
PASSÉ
Dans resource_c_fin()
        –– une fonction test_trois() terminé ––

test_three_four.py:4: test_four 
        –– une fonction test_four() début ––
Dans ressource_c()

Dans test_four()
PASSÉ
Dans resource_c_fin()
        –– une fonction test_four() terminé ––

Dans resource_b_fin()
    –––– module test_three_four terminé –––––

Dans resource_a_fin()
–––––– session terminé ––––––––

================================= 4 passé dans 0,02 secondes ==================================






ATTENTION: vous devez utiliser de plus en plus large
Si vous faites cela dans le mauvais ordre, les choses vont mal.
Échangeons la portée sur quelques articles.
conftest.py: 



</p>
<p>…<br />
@ pytest.fixture (scope = "module") # session -> module<br />
def resource_a (demande):<br />
    print ('Dans ressource_a ()')</p>
<p>    def resource_a_fin ():<br />
            print (' nIn resource_a_fin ()')<br />
    request.addfinalizer (resource_a_fin)</p>
<p>@ pytest.fixture (scope = "session") # module -> session<br />
def resource_b (request, resource_a):<br />
…







...
@pytest.fixation(portée="module")   # session -> module
def ressource_a(demande):
    impression('Dans resource_a ()')

    def resource_a_fin():
            impression(' nIn resource_a_fin ()')
    demande.additif final(resource_a_fin)

@pytest.fixation(portée="session")   # module -> session
def ressource_b(demande, ressource_a):
...






Nous aurons un avertissement comme celui-ci (ou plusieurs): 



</p>
<p>E ScopeMismatchError: Vous avez essayé d'accéder au 'module' Scoped fixture 'resource_a'<br />
… avec un objet de requête "session", des usines impliquées<br />
E conftest.py:18: def ressource_c (demande, ressource_b)<br />
E conftest.py:10: def resource_b (request, resource_a)<br />
E conftest.py:2: def resource_a (demande)







E           ScopeMismatchError: Vous a tenté à accès le 'module' portée fixation 'ressource_a' 
... avec une 'session' portée demande objet, impliqué des usines
E           conftest.py:18:  def ressource_c(demande, ressource_b)
E           conftest.py:dix:  def ressource_b(demande, ressource_a)
E           conftest.py:2:  def ressource_a(demande)






Alors. Ne fais pas ça.
Avertissement s'applique aux appareils encastrés
Pytest comprend certains appareils intégrés. Je crois que tous sont fonctionnels.
Cela signifie que vous ne pouvez pas les utiliser à partir de fonctions autres que des appareils fonctionnels.
Prenant plus loin
Le code que j'ai montré est pour une exécution simple au début et à la fin des fixtures.
Cependant, vous pouvez faire plus avec les fixtures de session.
Le site pytest.org a un exemple intéressant: un appareil de session qui peut examiner tous les tests collectés.
Pour quoi utilisez-vous les fixtures de session?
J'aimerais entendre des exemples et des cas d'utilisation pour les montages de session.
S'il vous plaît laissez un commentaire ou laissez-moi savoir @brianokken    de comment vous les utilisez.



[ad_2]

Partager :
Cliquez pour partager sur Twitter(ouvre dans une nouvelle fenêtre)
Cliquez pour partager sur Facebook(ouvre dans une nouvelle fenêtre)