En el escenario real, probamos la función de registro simple, que requiere un nombre de usuario y contraseña. El nombre de usuario/contraseña puede tener algunas reglas, lo que requiere una variedad de reglas de datos diferentes para verificar la función de registro. Por supuesto, podemos escribir varios casos, las solicitudes son las mismas pero los datos de la solicitud son diferentes. Pero hay un problema con esto: provocará una gran cantidad de código duplicado y no es fácil de gestionar. Entonces, ¿cómo solucionarlo con elegancia? Por supuesto que es parametrización, entonces, ¿cómo realiza pytest la parametrización? Explora junto con preguntas.
Introducción a la parametrización de pytest
Las pruebas parametrizadas se refieren a ejecutar múltiples pruebas pasando diferentes parámetros en el caso de prueba para verificar las diferentes entradas y salidas de la función o método bajo prueba.
La parametrización de Pytest nos permite expandir fácilmente los casos de prueba, reducir el código redundante y mejorar la eficiencia de las pruebas.
Cómo utilizar la parametrización de pytest
El método de uso sigue siendo muy sencillo. Veamos primero un caso, tal vez lo entiendas de un vistazo.
@pytest.mark.parametrize("input, expected", [
(2, 4),
(3, 9),
(4, 16)
])
def test_square(input, expected):
assert input**2 == expected
El código anterior define un caso de prueba llamado test_square, que se parametriza utilizando el decorador @pytest.mark.parametrize. La lista de parámetros parametrizados contiene múltiples conjuntos de entradas y salidas deseadas, separadas por comas entre cada conjunto de parámetros.
A continuación ejecutamos la prueba y vemos los resultados:
Ejecute la prueba ejecutando el siguiente comando en la línea de comando:
============================= test session starts ==============================
collecting ... collected 3 items
test_demo.py::test_square[2-4]
test_demo.py::test_square[3-9]
test_demo.py::test_square[4-16]
============================== 3 passed in 0.13s ===============================
Escenarios de aplicación
El método de uso es como el caso anterior, es muy simple, centrémonos en el escenario de la aplicación.
Aplicación paramétrica única
Escenarios de uso comunes: solo cambia un dato en el método de prueba, es decir, se pasan varios conjuntos de datos de prueba a través de un parámetro. Durante la ejecución, cada conjunto de datos se ejecuta una vez.
Por ejemplo, si nos registramos para obtener un código de verificación, actualmente hay varios números de teléfono móvil que deben registrarse:
import pytest
@pytest.mark.parametrize("mobile", [
16300000000,
16300000001,
16300000002
])
def test_register(mobile):
print(f"当前注册手机号为：{mobile}")
Los resultados de la ejecución son los siguientes:
PASSED [ 33%]当前注册手机号为：16300000000
PASSED [ 66%]当前注册手机号为：16300000001
PASSED [100%]当前注册手机号为：16300000002
Se puede ver que un caso de prueba se ejecutará varias veces si tiene varios datos.
Aplicación multiparamétrica
Los datos de entrada para la prueba pueden ser una expresión y los parámetros de entrada pueden ser múltiples. Se pueden organizar varios datos en tuplas.
Por ejemplo, si probamos la función de cálculo, podemos escribirla así:
import pytest
@pytest.mark.parametrize("input, expected", [
(2+2, 4),
(10-1, 9),
(4**2, 16)
])
def test_square(input, expected):
print(input)
assert input == expected
Este código realiza diferentes operaciones de cálculo sobre los valores de entrada y verifica que los resultados sean los esperados.
múltiples parametrizaciones
Se puede marcar un caso de uso utilizando múltiples @pytest.mark.parametrizes. Por ejemplo:
import pytest
@pytest.mark.parametrize('input', [1, 2, 3])
@pytest.mark.parametrize("output, expected", [
(4, 5),
(6, 7)
])
def test_square(input, output, expected):
print(f"input:{input},output:{output},expected:{expected}")
result = input + output
assert result == expected
Usamos dos niveles de decoradores anidados @pytest.mark.parametrize. El decorador parametrizado externo especifica el rango de valores del parámetro de entrada como [1, 2, 3], y el decorador parametrizado interno especifica cada conjunto de valores para los parámetros de salida y esperados.
La combinación de parametrización y fijación.
Los dispositivos también se pueden parametrizar. Se presentan en detalle en el artículo anterior. No los presentaré en este artículo. Los estudiantes que no sepan cómo hacer esto pueden leer este artículo.
pytestmark implementa la parametrización
pytestmark se puede utilizar para aplicar decoradores a nivel de módulo de prueba o nivel de clase. Al usar pytestmark, podemos aplicar la parametrización de manera uniforme para múltiples funciones de prueba en el módulo de prueba.
Veamos el caso:
import pytest
pytestmark = pytest.mark.parametrize('input', [1, 2, 3])
def test_square(input):
result = input ** 2
assert result == 4
En este código, usamos el decorador pytest.mark.parametrize en la variable pytestmark a nivel de módulo y configuramos el parámetro de entrada en un valor parametrizado de [1, 2, 3].
Esto significa que para cada función de prueba en el módulo de prueba, se aplica la parametrización y la prueba se ejecuta para cada valor en [1, 2, 3]. En la función de prueba test_square, usamos directamente la entrada como parámetro para acceder al valor parametrizado, calcular el cuadrado de la entrada y afirmar que el resultado es 4.
Al usar pytestmark, podemos aplicar fácilmente la parametrización en todo el módulo de prueba sin repetir el mismo decorador en cada función de prueba. Este enfoque es particularmente útil cuando es necesario aplicar la misma parametrización de manera uniforme a múltiples funciones de prueba.
Es importante tener en cuenta que cuando se usa pytestmark, aplicará la parametrización a todas las funciones de prueba en todo el módulo. Si solo desea aplicar parametrización a una función de prueba específica, puede aplicar el decorador directamente a esa función sin usar la variable pytestmark.
Profundizando en la parametrización
Primero echemos un vistazo al código fuente: /_pytest/python.py
def parametrize(
self,
argnames: Union[str, Sequence[str]],
argvalues: Iterable[Union[ParameterSet, Sequence[object], object]],
indirect: Union[bool, Sequence[str]] = False,
ids: Optional[
Union[Iterable[Optional[object]], Callable[[Any], Optional[object]]]
] = None,
scope: "Optional[_ScopeName]" = None,
*,
_param_mark: Optional[Mark] = None,
) -> None:
argnames: nombre del parámetro, que puede ser una cadena o una lista de cadenas, que representa los nombres de los parámetros en la función de prueba. Si hay varios parámetros, se pueden especificar varios nombres mediante una lista.
argvalues: valores de parámetros, que pueden ser un objeto iterable, donde cada elemento representa un conjunto de valores de parámetros. Cada conjunto de valores de parámetros puede ser una tupla, una lista o un único objeto.
indirecto: si se debe utilizar el parámetro como parámetro indirecto de la función bajo prueba. Si se establece en Verdadero o especifica ciertos nombres de parámetros, cuando se ejecuta la función de prueba, los parámetros se pasan como valores de retorno de otras funciones de dispositivo en lugar de directamente como valores de parámetros.
ids: el identificador del caso de prueba, utilizado para distinguir mejor diferentes casos de prueba parametrizados en el informe de prueba. Puede especificar un iterable o una función para generar la identidad.
alcance: el alcance del parámetro, que se utiliza al compartir parámetros entre múltiples funciones de prueba. Se puede configurar como "función" (predeterminado), "clase", "módulo" o "sesión".
_param_mark: parámetro interno, utilizado para especificar la marca del parámetro. Generalmente no es necesario prestar atención.
Se pueden agregar múltiples conjuntos diferentes de parametrizaciones a la función de prueba llamando a la función pytest.parametrize varias veces, y cada llamada aplica la parametrización además de la parametrización agregada previamente.
Tenga en cuenta que la función pytest.parametrize se parametriza durante la fase de recopilación de casos de prueba, en lugar de generar parámetros dinámicamente cada vez que se ejecuta un caso de prueba.
Utilice la función de enlace pytest_generate_tests combinada con parametrizar para generar casos de prueba dinámicamente.
pytest.param
Como marco de prueba potente y fácil de usar, Pytest proporciona el decorador @pytest.mark.parametrize para admitir pruebas parametrizadas. La función pytest.param es una herramienta para mejorar aún más las pruebas parametrizadas, lo que nos permite definir y controlar casos de prueba parametrizados de una manera más flexible.
Identificación paramétrica
En las pruebas paramétricas, cada caso de prueba puede contener múltiples conjuntos de parámetros y puede producir una gran cantidad de resultados de prueba. En este punto, para comprender y depurar mejor los resultados de la prueba, tiene sentido asignar un identificador fácil de entender a cada caso de prueba parametrizado. El parámetro id de la función pytest.param puede hacer esto.
Por ejemplo, en una prueba de multiplicación, podemos definir un caso de prueba parametrizado de la siguiente manera:
import pytest
@pytest.mark.parametrize("input, expected", [
pytest.param(2, 4, id="case1"),
pytest.param(3, 9, id="case2"),
pytest.param(5, 25, id="case3")
])
def test_multiply(input, expected):
assert input * input == expected
Al usar pytest.param para cada caso de prueba parametrizado, podemos especificar un identificador para cada caso de prueba, lo que facilita su lectura y comprensión. Cuando se complete la ejecución de la prueba, la identificación en el informe de la prueba nos ayudará a localizar mejor el problema.
Opciones personalizadas
Además de la identificación de parámetros, la función pytest.param también puede aceptar parámetros adicionales, como el parámetro marks, que se utiliza para aplicar marcadores personalizados para casos de prueba individuales. Al utilizar el parámetro de marcas, podemos agregar de manera flexible varias opciones de personalización en pruebas parametrizadas.
Por ejemplo, suponiendo que tenemos un caso de prueba parametrizado que debe omitirse, podemos definirlo así:
import pytest
@pytest.mark.parametrize("input, expected", [
pytest.param(2, 4, marks=pytest.mark.skip),
pytest.param(3, 9, marks=pytest.mark.skip),
pytest.param(5, 25)
])
def test_multiply(input, expected):
assert input * input == expected
En el ejemplo anterior, utilizamos la marca pytest.mark.skip para omitir los dos primeros casos de prueba. De esta manera, podemos aplicar diferentes marcas a diferentes casos de prueba parametrizados, como pytest.mark.skip, pytest.mark.xfail, etc., para lograr un control de prueba más flexible.
por fin
A través de la introducción de este artículo, hemos aprendido sobre el concepto, el uso y la demostración de casos de parametrización de pytest. La parametrización de Pytest puede simplificar enormemente la escritura de casos de prueba y mejorar la reutilización y mantenibilidad del código. En las pruebas de software reales, el uso razonable de la parametrización de pytest nos ayudará a realizar pruebas de manera más eficiente y a encontrar problemas potenciales más rápido. Además, también presentamos el uso avanzado de parametrizar, que se puede combinar con la función de enlace pytest_generate_tests para implementar escenarios complejos. Finalmente, presentamos una función muy útil, pytest.param, que proporciona más opciones de personalización y control para pruebas parametrizadas. Por lo tanto, al escribir pruebas parametrizadas, es posible que desee considerar el uso de pytest.param para mejorar la calidad y eficiencia de las pruebas.
Finalmente: se ha compilado y subido el video tutorial completo de prueba de software a continuación. Los amigos que lo necesiten pueden obtenerlo ellos mismos.【保证100%免费】
Documento de entrevista de prueba de software
Debemos estudiar para encontrar un trabajo bien remunerado. Las siguientes preguntas de la entrevista provienen de los últimos materiales de entrevista de empresas de Internet de primer nivel como Alibaba, Tencent, Byte, etc., y algunos jefes de Byte han dado respuestas autorizadas. Después de terminar esto set Creo que todos pueden encontrar un trabajo satisfactorio según la información de la entrevista.
