Gao Fushuai en el mundo de las pruebas unitarias, marco Pytest (2) métodos previos y posteriores y mecanismo de fijación

Prefacio

En el artículo anterior, presentamos el uso básico de pytest. Este artículo está dedicado a explicar el procesamiento previo y posterior de la ejecución de casos de uso en pytest. El procesamiento previo y posterior de la ejecución de casos de uso en pytest se puede realizar a través de el dispositivo de prueba (fixtrue). La implementación también se puede lograr mediante métodos previos y posteriores de estilo xunit. A continuación, echemos un vistazo a cómo usarlo en detalle.

1. Métodos frontal y posterior de estilo xunit

1. Métodos previos y posteriores a casos de uso de funciones

Defina casos de uso en forma de funciones en el módulo. Puede usar setup_function y teadown_function para definir los métodos previos y posteriores de los casos de uso de funciones. Los casos de uso son los siguientes:

def setup_function(function):
    print("函数用例前置方法执行")

  
def teardown_function(function):
    print("函数用例后置方法执行")


def test_01():
    print('----用例方法01------')

resultado de la operación:

C:\testcases>pytest -s
========================= test session starts =========================
platform win32 -- Python 3.7.3, pytest-5.4.2, py-1.8.0, pluggy-0.13.0 
cachedir: .pytest_cache
rootdir: C:\testcases
plugins:  testreport-1.1.2
collected 1 item                                                      
test_demo.py
函数用例前置方法执行
----用例方法01------ .
函数用例后置方法执行
========================= 1 passed in 0.27s =========================

2. Métodos previos y posteriores a los casos de uso en clases de prueba

• Métodos previos y posteriores a nivel de clase
• Los métodos previos y posteriores setup_class y teadown_class en el nivel de clase de prueba en pytest se ejecutan antes de ejecutar los casos de uso en la clase de prueba y después de ejecutar todos los casos de uso en la clase de prueba. El uso específico es el siguiente:
• clase TestDome: def prueba_01(self): print('----Caso de prueba: prueba_01------') def prueba_02(self): print('----Caso de prueba: prueba_02----- -') @classmethod def setup_class(cls): print("Método previo a la clase de prueba---setup_class---") @classmethod def teardown_class(cls): print("Método posterior a la clase de prueba---teardown_class-- -")
• Métodos previos y posteriores a nivel de caso de uso
• Los métodos previos y posteriores setup_method y teadown_method en el nivel de caso de uso en la clase de prueba en pytest se ejecutan antes de que se ejecuten los casos de uso en la clase de prueba y después de que se ejecuten todos los casos de uso en la clase de prueba. El uso específico es como sigue:
• clase TestDome: def prueba_01(self): print('----Caso de prueba: prueba_01------') def prueba_02(self): print('----Caso de prueba: prueba_02----- -') @classmethod def setup_class(cls): print("Método previo a la clase de prueba---setup_class---") @classmethod def teardown_class(cls): print("Método posterior a la clase de prueba---teardown_class-- -") def setup_method(función): print("Caso de prueba pre-método---setup_method---") def teardown_method(función): print("Caso de prueba post-método---teardown_method---")

resultado de la operación:

C:\testcases>pytest -s
==================== test session starts ====================
platform win32 -- Python 3.7.3, pytest-5.4.2, py-1.8.0, pluggy-0.13.0
rootdir: C:\testcases
plugins:  testreport-1.1.2
collected 2 items                                                                                                                                 
test_demo.py 
测试类前置方法---setup_class---
测试用例前置方法---setup_method---
----测试用例：test_01------.
测试用例后置方法---teardown_method---
测试用例前置方法---setup_method---
----测试用例：test_02------.
测试用例后置方法---teardown_method---
测试类后置方法---teardown_class---

==================== 2 passed in 0.30s =======================

3. Métodos de preprocesamiento y posprocesamiento a nivel de módulo

También hay dos funciones en pytest, setup_module y teadown_module, que se utilizan para establecer métodos previos y posteriores a nivel de módulo, se definen en el módulo y se ejecutarán antes y después de que se ejecuten todos los casos de uso en todo el módulo. El uso específico es el siguiente:

class TestDome:

    def test_01(self):
        print('----测试用例：test_01------')


class TestDome2:

    def test_02(self):
        print('----测试用例：test_02------')
   
  
def setup_module(module):
    print("测试模块的前置方法---setup_module---")


def teardown_module(module):
    print("测试模块的前置方法---teardown_module---")

resultado de la operación:

C:\testcases>pytest -s
====================== test session starts ====================== 
platform win32 -- Python 3.7.3, pytest-5.4.2, py-1.8.0, pluggy-0.13.0
rootdir: C:\testcases
plugins:testreport-1.1.2
collected 2 items                                                                   
test_demo.py 测试模块的前置方法---setup_module---
----测试用例：test_01------
.----测试用例：test_02------
.测试模块的前置方法---teardown_module---
====================== 2 passed in 0.27s ====================== 

2. Mecanismo de fijación

Anteriormente presentamos los métodos frontal y posterior de estilo xunit en pytest. A continuación, echemos un vistazo al uso del mecanismo de fijación más potente (dispositivo de prueba) en pytest.

1. Niveles y definiciones de dispositivos de prueba.

Los dispositivos de prueba deben definirse utilizando el decorador pytest.fixture. Los dispositivos de prueba en pytest tienen los siguientes niveles: nivel de caso de uso, nivel de clase de prueba, nivel de módulo, nivel de paquete y nivel de sesión. A continuación, echemos un vistazo a la sintaxis de definición de dispositivos.

La definición del dispositivo puede especificar el nivel del dispositivo a través del alcance del parámetro. Si no se especifica el nivel del dispositivo, el valor predeterminado del alcance es función (nivel de caso de uso)

Nivel de caso de uso: alcance = función

Nivel de clase de prueba: alcance = clase

Nivel de módulo: alcance = módulo

Nivel de paquete: alcance = paquete

Nivel de sesión: alcance = sesión

@pytest.fixture(scope='指定夹具的级别')
def work():
    # 前置执行脚本
    yield 
    # 后置执行脚本

El dispositivo de prueba es esencialmente una función generadora. Cuando la función generadora usa next para iterar, devolverá datos cuando se ejecute para producir, pausará la ejecución y esperará la siguiente iteración antes de continuar con la ejecución. El dispositivo pytest es el mecanismo del generador utilizado ., ejecute el código previo y posterior por separado en el dispositivo de prueba a través de rendimiento.

Nota: El dispositivo solo se puede utilizar dentro del alcance del dispositivo definido. Si el dispositivo está definido en una clase, solo puede ser utilizado por casos de prueba dentro de esa clase. Pero si el dispositivo está definido en el alcance global del módulo, entonces cada caso de prueba en ese módulo, incluso si está definido en una clase, puede usarlo.

Ahora que sabemos cómo definir un dispositivo, veamos cómo usarlo.

2. Uso de accesorios

Una vez definidos los dispositivos de prueba, la función de prueba especifica los dispositivos que se ejecutarán antes de ejecutar el caso de prueba declarándolos como parámetros.

Cuando pytest comienza a ejecutar una prueba, observa los parámetros formales definidos por la función de prueba y luego busca un dispositivo de prueba con el mismo nombre que esos parámetros. Una vez que pytest los encuentra, ejecuta los dispositivos, recibe sus retornos (si los hay) y los pasa como argumentos a la función de prueba.

Nota: Cuando usamos el dispositivo, si se ejecuta el script previo del dispositivo y hay datos para pasar al caso de uso, los datos que deben pasarse se pueden escribir después del rendimiento. En el caso de uso o método de Usando el dispositivo, puede pasar los parámetros formales definidos para obtener los datos devueltos por rendimiento (los casos de uso se presentan en el Capítulo 2.3).

2.1 Usar accesorios en casos de uso

Ya sea un caso de prueba definido en forma de función o un caso de uso definido en forma de método en una clase de prueba, es lo mismo cuando se usa: simplemente defina un parámetro formal con el mismo nombre que el dispositivo que se va a utilizar. usado.

import pytest

# 定义一个用例级别的夹具
@pytest.fixture
def my_fixture():
    print('------my_fixture---用例前置执行脚本--------')
    yield
    print('------my_fixture---用例后置执行脚本--------')

# 函数用例 指定测试夹具
def test_func__01(my_fixture):
    print("测试用例----test_func__01----")


class TestDome:
    # 函数用例 指定测试夹具
    def test_02(self, my_fixture):
        print('----测试用例：test_02------')
  
     # 函数用例 指定测试夹具
    def test_03(self):
        print('----测试用例：test_03------')

resultado de la operación

C:\testcases>pytest -s
======================== test session starts ========================
platform win32 -- Python 3.7.3, pytest-5.4.2, py-1.8.0, pluggy-0.13.0
rootdir: C:\testcases
plugins: testreport-1.1.2
collected 2 items  
test_demo.py 
------my_fixture---前置执行脚本--------
测试用例----test_func__01----.
------my_fixture---后置执行脚本--------
------my_fixture---前置执行脚本--------
----测试用例：test_02------.
------my_fixture---后置执行脚本--------
----测试用例：test_03------
======================== 2 passed in 0.27s ========================

Los dos casos de uso anteriores test_func__01 y test_02 especificaron dispositivos de prueba cuando se definieron, mientras que test_03 no especificó el dispositivo para su ejecución. Cuando se ejecutó el caso de uso, la biblioteca vio el caso de uso con el dispositivo especificado y ejecutó el dispositivo correspondiente.

2.2 Especificar accesorios para clases y módulos de prueba

Arriba especificamos el dispositivo de prueba para un solo caso de prueba agregando parámetros formales al método de caso de uso. Si hay muchos casos de prueba en una clase de prueba o muchos casos de uso en un módulo, se debe especificar el mismo dispositivo de prueba. Si queremos, podemos especificar el dispositivo de prueba para la clase de prueba o el módulo de prueba a través de usefixtures.

Especificar accesorios para todos los casos de prueba en la clase de prueba.

# TestDome这个测试类的所有测试用例均执行my_fixture这个夹具
@pytest.mark.usefixtures('my_fixture这个夹具')
class TestDome:
    # 函数用例 指定测试夹具
    def test_02(self):
        print('----测试用例：test_01------')

    # 函数用例 指定测试夹具
    def test_03(self):
        print('----测试用例：test_02------')

Utilice pytestmark para especificar accesorios para todas las ejecuciones de casos de prueba del módulo en el nivel del módulo de prueba

# test_demo.py

# 当前模块中所有的用例，均执行my_fixture这个测试夹具
pytestmark = pytest.mark.usefixtures('my_fixture')

# 函数用例 指定测试夹具
def test_func__01(my_fixture):
    print("测试用例————test_func__01——————")

  
class TestDome:
    # 函数用例 指定测试夹具
    def test_02(self):
        print('----测试用例：test_01------')

    # 函数用例 指定测试夹具
    def test_03(self):
        print('----测试用例：test_02------')

2.3 Referenciar el aparato en el aparato

Una de las mayores ventajas de pytest es su sistema de fijación extremadamente flexible. A través de dispositivos de prueba, podemos dividir dependencias frontales y traseras extremadamente complejas en dispositivos de prueba de función única más simples y organizar los entornos de dependencia complejos requeridos por diferentes casos de uso haciendo referencia a otros dispositivos en los dispositivos. A continuación, usaremos un caso para demostrar cómo usarlo.

import pytest
# 用户注册的夹具
@pytest.fixture
def register_user():
    print('---用户注册的夹具前置执行----')
    # ...注册代码省略，注册的用户信息如下
    user_info = {'user': 'lemonban', 'pwd': '123456'}
    yield user_info
    print('---用户注册的夹具后置执行----')


# 用户登录的夹具,通过定义形参来使用register_user这个夹具
@pytest.fixture
def user_login(register_user):
    print('---用户登录的夹具前置执行----')
    # 获取register_user结局前置脚本执行完，yeild传递出来的数据
    user_info = register_user
    # ...登录代码省略，下面为登录得到的token
    token = 'sdjasjdask'
    yield token
    print('---用户登录的夹具后置执行----')

# 函数用例 指定使用测试夹具user_login
def test_func__01(user_login):
    token = user_login
    print("测试用例夹具user_login传递过来的token:",token)
    print("测试用例---test_func__01---")

resultado de la operación

C:\testcases>pytest -s
======================== test session starts ========================
platform win32 -- Python 3.7.3, pytest-5.4.2, py-1.8.0, pluggy-0.13.0
rootdir: C:\testcases
plugins: testreport-1.1.2
collected 1 item  
test_demo.py 
---用户注册的夹具前置执行----
夹具register_user传递过来的用户信息: {'user': 'lemonban', 'pwd': '123456'}
---用户登录的夹具前置执行----
测试用例夹具user_login传递过来的token: sdjasjdask
测试用例---test_func__01---.
---用户登录的夹具后置执行----
---用户注册的夹具后置执行----

2.4 Uso automático de accesorios

Al definir el dispositivo de prueba, podemos agregar el parámetro autouse=True al decorador del dispositivo para convertirlo en un dispositivo ejecutado automáticamente. Los casos específicos son los siguientes:

import pytest


@pytest.fixture(autouse=True)
def my_fixture():
    print('------my_fixture---前置执行脚本--------')
    yield
    print('------my_fixture---后置执行脚本--------')


class TestDome:
    # 函数用例 指定测试夹具
    def test_02(self):
        print('----测试用例：test_01------')

    # 函数用例 指定测试夹具
    def test_03(self):
        print('----测试用例：test_02------')


class TestDome2:
    # 函数用例 指定测试夹具
    def test_03(self):
        print('----测试用例：test_03------')

Resultados de:

C:\testcases>pytest -s
======================== test session starts ========================
platform win32 -- Python 3.7.3, pytest-5.4.2, py-1.8.0, pluggy-0.13.0
rootdir: C:\testcases
plugins: testreport-1.1.2
collected 3 items    
test_demo.py
------my_fixture---前置执行脚本--------
----测试用例：test_01------.
------my_fixture---后置执行脚本--------
------my_fixture---前置执行脚本--------
----测试用例：test_02------.
------my_fixture---后置执行脚本--------
------my_fixture---前置执行脚本--------
----测试用例：test_03------.
------my_fixture---后置执行脚本--------
======================== 3 passed in 0.29s ========================

De los resultados de ejecución anteriores, podemos ver que el dispositivo de prueba my_fixture se ejecuta automáticamente antes de ejecutar cada caso de uso.

3、conftest.py

En la prueba de un proyecto, en la mayoría de los casos habrá varias clases, módulos o paquetes que utilizan el mismo dispositivo de prueba. En este caso, si definimos el dispositivo de prueba en un determinado módulo, no se puede compartir. En este caso, podemos colocar los dispositivos de prueba que deben compartirse en un archivo conftest.py separado, de modo que se puedan compartir múltiples dispositivos de prueba. compartido módulos de prueba compartidos

ps: cuando pytest ejecuta una prueba, si hay conftest.py en el proyecto, entonces pytest cargará automáticamente el contenido del módulo conftest.py. Puede usar conftest para ver el módulo de complemento que pytest cargará automáticamente. Los tutoriales posteriores involucrarán conftest. Definir la función de gancho de pytest en .py.

A continuación, veamos un caso en el que conftest.py define un dispositivo de prueba.

Defina el dispositivo de prueba my_fixture en conftest.py

# conftest.py

import pytest

@pytest.fixture
def my_fixture():
    print('------my_fixture---前置执行脚本--------')
    yield
    print('------my_fixture---后置执行脚本--------')

El caso de prueba en test_demo1.py usa el dispositivo definido en conftest.py

# test_demo1.py
class TestDome:
    # 函数用例 指定测试夹具
    def test_02(self,my_fixture):
        print('----测试用例：test_01------')

    # 函数用例 指定测试夹具
    def test_03(self,my_fixture):
        print('----测试用例：test_02------')

El caso de prueba en test_demo2.py usa el dispositivo definido en conftest.py

# test_demo2.py
class TestDome2:
    # 函数用例 指定测试夹具
    def test_03(self,my_fixture):
        print('----测试用例：test_03------')

Resultados de:

C:\testcases>pytest -s
======================== test session starts ========================
platform win32 -- Python 3.7.3, pytest-5.4.2, py-1.8.0, pluggy-0.13.0
rootdir: C:\testcases
plugins: testreport-1.1.2
collected 3 items
test_demo.py 
------my_fixture---前置执行脚本--------
----测试用例：test_01------.
------my_fixture---后置执行脚本--------
------my_fixture---前置执行脚本--------
----测试用例：test_02------.
------my_fixture---后置执行脚本--------
test_demo2.py 
------my_fixture---前置执行脚本--------
----测试用例：test_03------.
------my_fixture---后置执行脚本--------
======================== 3 passed in 0.29s ========================

En el caso anterior, podemos encontrar que los casos de prueba en est_demo.py y est_demo2.py pueden usar con éxito los casos de prueba en conftest.py.

El próximo artículo le explicará el marcado de casos de uso y la ejecución de pruebas.
A continuación se muestran algunos de los materiales que utilicé mientras estudiaba. Los amigos que lo necesiten pueden dejar un mensaje en el área de comentarios.