La relación entre las variables de entorno, accesorios y casos de uso del marco de prueba automatizado de pytest tep

 tep es una herramienta de prueba que integra paquetes de terceros basados ​​en el marco de prueba de pytest, proporciona andamiaje de proyectos y ayuda a realizar rápidamente la implementación de proyectos automatizados mediante la escritura de código de Python.

En el proyecto tep, los casos de prueba automatizados se colocan testsen el directorio, y cada .pyarchivo es independiente entre sí sin dependencias. Un archivo es un caso de prueba, separados entre sí.

Aunque los casos de uso también pueden referirse entre sí, a menos que sea absolutamente necesario, generalmente no se recomienda hacerlo, ya que conducirá a todo el cuerpo y será difícil de mantener más adelante.

La escritura del código del caso de uso se escribe de arriba a abajo, que es lo mismo que el método de escritura convencional de pytest/unittest/script No habrá costos de aprendizaje y, en general, no habrá problemas. Los problemas con el costo pueden ser las variables de entorno y los accesorios, porque tep está encapsulado y proporciona un método compartido de inyección de dependencia, y el accesorio es un punto de conocimiento que es difícil de entender para pytest, por lo que es necesario hablar sobre las variables de entorno y los accesorios de tep a través de este artículo 、 La relación entre los tres casos de uso ayuda a comprender, de modo que el proyecto de automatización de pytest se puede realizar de manera más flexible y sin problemas con la ayuda de tep.

Si no usa variables de entorno y accesorios

Si no usa variables de entorno y accesorios, ¡es totalmente posible! Por ejemplo, cree un nuevo script testsen login_test.py:

from tep.client import request

def test():
    response = request("post",
            url="https://qa.com/api/users/login",
            headers={"Content-Type": "application/json"},
            json={
                "username": "admin",
                "password": "123456",
            }
        )
    assert response.status_code < 400

La interfaz de solicitud https://qa.com/api/users/loginafirma que el código de estado de respuesta es inferior a 400. Aquí viene el problema: urlsolucionado, ¿qué debo hacer si necesito cambiar entre dos entornos qay ?release

parametrizar

Ya sea que esté realizando pruebas automatizadas o pruebas de rendimiento, entrará en contacto con la palabra parametrización. Se refiere a definir los datos fijos (codificados) en el código como variables, de modo que los datos sean diferentes cada vez que se ejecuten y los datos fijos se conviertan en datos dinámicos. Las fuentes de datos dinámicos son variables, bases de datos , archivos externos, etc. El tipo de datos dinámicos es generalmente una cadena constante o una función, como el asistente de funciones de JMeter, o la inyección de dependencia, como el accesorio de pytest.

Accesorios inyectados de dependencia

"La inyección de dependencia es una forma técnica de Inversión de Control (IoC, Inversion of Control)", esta frase proviene de Wikipedia, no sé lo que significa, haz un dibujo para expresarlo simplemente:

Significa que si le das clientuno injector, clientpuedes usarlo sin hacer nada service.

El accesorio de pytest implementa la inyección de dependencia, lo que nos permite introducir accesorios para agregar algunas cosas adicionales sin modificar el código de prueba.

Por urlejemplo, el nombre de dominio debe parametrizarse y el nombre de dominio es diferente en diferentes entornos, por lo que tep lo convierte en un accesorio y lo introduce a través de parámetros de función:

from tep.client import request
from tep.fixture import *

def test(url):  # 引入fixture
    response = request("post",
            url=url("/api/users/login"),
            headers={"Content-Type": "application/json"},
            json={
                "username": "admin",
                "password": "123456",
            }
        )
    assert response.status_code < 400

tep.fixture.urlSe define de la siguiente manera:

@pytest.fixture(scope="session")
def url(env_vars):
    def domain_and_uri(uri):
        if not uri.startswith("/"):
            uri = "/" + uri
        return env_vars.domain + uri

    return domain_and_uri

Si lo entiendes de un vistazo, enhorabuena, si te confundes de un vistazo, no importa. Me tomaré el tiempo de explicarlo claramente, ¡es muy importante!

Tratar los accesorios como variables

Aunque por definición, un fixture es defuna función definida con palabras clave, puede entenderse como una variable. Por ejemplo:

import pytest


@pytest.fixture
def name():
    return "dongfanger"

El uso de la función general es agregar paréntesis al nombre de la función y pasarlo name()para obtenerlo "dongfanger". El accesorio es diferente, la definición anterior se puede entender como:

name = "dongfanger"

Asigne "dongfanger"el valor a name, nombre del dispositivo = valor devuelto. nameConsíguelo a través de variables "dongfanger".

Como es una variable, puede asignar cualquier valor, str, function, class, objectcualquiera. Por ejemplo, defina una función dentro del dispositivo:

import pytest


@pytest.fixture
def who():
    def get_name():
        return "dongfanger"
    return get_name

Se entiende como asignar el nombre de la función get_namea la variable nombre del aparato:

who = get_name

get_nameEs un nombre de función, debe agregar paréntesis get_name()para obtenerlo "dongfanger". whoTambién debes pasar who()para conseguirlo "dongfanger". A ver tep.fixture.urlsi está más claro:

@pytest.fixture(scope="session")
def url(env_vars):
    def domain_and_uri(uri):
        if not uri.startswith("/"):
            uri = "/" + uri
        return env_vars.domain + uri

    return domain_and_uri

Se entiende como asignar el nombre de la función domain_and_uria la variable nombre del aparato:

url = domain_and_uri

Al usarlo, url("/api")obtenga el resultado empalmado del nombre de dominio y uri.

La línea 2 def url(env_vars):también tiene un parámetro env_varsy la explicación continúa.

El parámetro fixture es otro fixture

Los parámetros del aparato solo pueden ser otros aparatos. Por ejemplo:

import pytest


@pytest.fixture
def chinese_name():
    return "东方er"


@pytest.fixture
def english_name(chinese_name):
    return "dongfanger"

Llame english_name, pytest primero ejecutará otros dispositivos en los parámetros chinese_namey luego se ejecutará a sí mismo english_name.

Si tep.fixture.urllo miras en dos pasos, te quedará muy claro. El primer paso:

@pytest.fixture(scope="session")
def url(env_vars):
    func = None
    return func

Segundo paso:

@pytest.fixture(scope="session")
def url(env_vars):
    func = None
    
    
    def domain_and_uri(uri):
        if not uri.startswith("/"):
            uri = "/" + uri
        return env_vars.domain + uri

    
    func = domain_and_uri
    return func

Variable ambiental

tep.fixture.urlEl parámetro es otra env_varsvariable de entorno de dispositivo, que se define de la siguiente manera:

from tep.fixture import *


@pytest.fixture(scope="session")
def env_vars(config):
    class Clazz(TepVars):
        env = config["env"]

        """Variables define start"""
        # Environment and variables
        mapping = {
            "qa": {
                "domain": "https://qa.com",
            },
            "release": {
                "domain": "https://release.com",
            }
            # Add your environment and variables
        }
        # Define properties for auto display
        domain = mapping[env]["domain"]
        """Variables define end"""

    return Clazz()

Solo mira el comentario del medio """Variables define start"""a """Variables define end"""la parte. urlEl nombre de dominio parametrizado está aquí, y mappingel diccionario establece el mapeo entre el entorno y las variables, y obtiene diferentes valores de variables según diferentes claves de entorno.

configEl papel de fixture es leer conf.yamlla configuración en el archivo.

Hay muchas formas de parametrizar. JMeter proporciona 4 tipos de formas de parametrización. El accesorio de tep env_varsse basa en las variables definidas por el usuario de JMeter:

env_vars.put()y env_vars.get()tomado de JMeter BeanShell vars.put()y vars.get().

Ejemplo: probar varias URL

Al final de la charla, se formó una idea. A través de ejemplos prácticos, vea cómo se utilizan las variables de entorno, los accesorios y los casos de uso para profundizar la impresión. Si qael entorno tiene dos sitios web, el lado de la escuela y el lado de la institución, se deben usar ambos scripts.

La primera modificación env_vars, editar fixture_env_vars.py:

        """Variables define start"""
        # Environment and variables
        mapping = {
            "qa": {
                "domain": "https://qa.com",
                "domain_school": "https://school.qa.com",  # 新增
                "domain_org": "https://org.qa.com"  # 新增
            },
            "release": {
                "domain": "https://release.com",
                "domain_school": "https://school.release.com"  # 新增
                "domain_org": "https://org.release.com"  # 新增
            }
            # Add your environment and variables
        }
        # Define properties for auto display
        domain = mapping[env]["domain"]
        domain_school = mapping[env]["domain_school"]  # 新增
        domain_org = mapping[env]["domain_org"]  # 新增
        """Variables define end"""

Se agregaron 6 líneas de código, definiendo env_vars.domain_schooly env_vars.domain_org.

El segundo paso es definir aparatos y crear otros nuevos fixture_url.py:

@pytest.fixture(scope="session")
def url_school(env_vars):
    def domain_and_uri(uri):
        if not uri.startswith("/"):
            uri = "/" + uri
        return env_vars.domain_school + uri

    return domain_and_uri
    

@pytest.fixture(scope="session")
def url_org(env_vars):
    def domain_and_uri(uri):
        if not uri.startswith("/"):
            uri = "/" + uri
        return env_vars.domain_org + uri

    return domain_and_uri

Consulte tep.fixture.url, modifique env_vars.domainy env_vars.domain_school, env_vars.domain_orgagregue 2 nuevos accesorios url_schooly url_org.

Yendo un paso más allá, tal vez definiendo accesorios login_schooly login_orgopciones flexibles.

resumen

Este artículo explica paso a paso la relación entre las variables de entorno tep, fixtures y casos de uso, enfocándose en tep.fixture.urlla explicación, mientras la entiendas, la relación general es muy clara. La razón para usar accesorios es que muchas personas colaboran y comparten. Necesitamos usar funciones escritas por otros y reutilizar valores devueltos. Algunos estudiantes están acostumbrados a definir parámetros de funciones. Está bien si los parámetros no cambian. Todos los casos de uso informarán errores. Los accesorios limitan esto muy bien. No puede pasar parámetros de forma predeterminada. Aunque los parámetros se pueden pasar definiendo funciones internas, no se recomienda hacerlo. Prefiero agregar código redundante y definir múltiples El accesorio también es mejor que el acoplamiento de código. La segunda razón es importel problema. Pytest buscará automáticamente conftest.pyel dispositivo en él, y tep buscará automáticamente fixturesel dispositivo y lo importará conftest.py. Se puede usar sin necesidad import, reduciendo importel código y evitando el problema de la importación circular. que puede ocurrir.

Los amigos que están estudiando para el examen pueden hacer clic en la tarjeta pequeña a continuación