Referencia de Allure Pytest
Estas son las funciones que puedes usar para integrar tus pruebas de pytest con Allure.
Allure Pytest ofrece más de una forma de utilizar algunas características. En la mayoría de los casos, una forma implica usar un decorador en la función de prueba, mientras que la otra implica una llamada a un método dentro del cuerpo de la función de prueba. Este último estilo se llama “dinámico” y permite construir valores de manera dinámica.
Metadatos
Asigna la descripción, enlaces y otros metadatos de una prueba.
Algunos campos de metadatos se pueden usar para seleccionar qué prueba ejecutar, consulta Especificar descripción, enlaces y otros metadatos y Opciones que afectan la selección de pruebas.
Title
@allure.title(test_title: str)allure.dynamic.title(test_title: str)
Establece el título de la prueba.
La variante de decorador de la función también se puede usar para describir fixtures de pytest.
import allure
import pytest
@allure.title("Test Authentication")
def test_authentication():
...import allure
import pytest
@pytest.fixture()
@allure.title("Prepare for the test")
def my_fixture():
...
def test_with_my_fixture(my_fixture):
...import allure
import pytest
def test_authentication():
allure.dynamic.title("Test Authentication")
...Si la función de prueba tiene parámetros (consulta Pruebas parametrizadas a continuación), puedes incluir los valores de los parámetros en el título a través de campos de reemplazo. Un campo de reemplazo es un nombre de parámetro delimitado por llaves {}, tal como lo soporta el método estándar str.format(). Además de los parámetros en sí, se soporta un campo especial {param_id} para insertar el ID del conjunto de parámetros (consulta la documentación de pytest).
Nota que los campos de reemplazo solo son soportados en la variante de decorador de la función title().
import allure
import pytest
@pytest.mark.parametrize("login", ["johndoe", "[email protected]"])
@allure.title("Test Authentication (as {login})")
def test_authentication(login):
...import allure
import pytest
@pytest.mark.parametrize("login", ["johndoe", "[email protected]"],
ids=["using-username", "using-email"])
@allure.title("Test Authentication ({param_id})")
def test_authentication(login):
...Description
@allure.description(test_description: str)allure.dynamic.description(test_description: str)
Establece la descripción de la prueba. Si no se proporciona, Allure usará la cadena de documentación de la función de prueba.
Se permite el formato Markdown. Cualquier formato HTML, si está presente, será eliminado por razones de seguridad.
import allure
@allure.description("""
This test attempts to log into the website using a login and a password. Fails if any error happens.
Note that this test does not test 2-Factor Authentication.
""")
def test_authentication():
...import allure
def test_authentication():
allure.dynamic.description("""
This test attempts to log into the website using a login and a password. Fails if any error happens.
Note that this test does not test 2-Factor Authentication.
""")
...def test_authentication():
"""
This test attempts to log into the website using a login and a password. Fails if any error happens.
Note that this test does not test 2-Factor Authentication.
"""
...Tag
@allure.tag(*tags: str)allure.dynamic.tag(*tags: str)
Establece las etiquetas de la prueba.
Ambas variantes de la función pueden aceptar tantas etiquetas como sea necesario al mismo tiempo, por ejemplo:
import allure
@allure.tag("NewUI", "Essentials", "Authentication")
def test_authentication():
...import allure
def test_authentication():
allure.dynamic.tag("NewUI", "Essentials", "Authentication")
...Severity
@allure.severity(severity_level: str)allure.dynamic.severity(severity_level: str)
Establece la severidad de la prueba.
Los valores permitidos son: “trivial”, “minor”, “normal”, “critical”, and “blocker”.
import allure
from allure_commons.types import Severity
@allure.severity(Severity.CRITICAL)
def test_authentication():
...import allure
from allure_commons.types import Severity
def test_authentication():
allure.dynamic.severity(Severity.CRITICAL)
...Label
@allure.label(label_type: str, *labels: str)allure.dynamic.label(label_type: str, *labels: str)
Establece una etiqueta arbitraria para la prueba. Esta es la implementación subyacente de muchas otras funciones de Allure.
El primer argumento de la función es el nombre de la etiqueta. Puede ser una constante de la clase LabelType o cualquier otro string.
El segundo y todos los argumentos restantes son los valores que se agregarán. Para cada uno de los valores, la función añadirá una etiqueta con el nombre y valor dados. Un ejemplo de función que pasa múltiples valores a label() al mismo tiempo es tag().
import allure
from allure_commons.types import LabelType
@allure.label(LabelType.LANGUAGE, "python")
@allure.label(LabelType.FRAMEWORK, "pytest")
def test_authentication():
...import allure
from allure_commons.types import LabelType
def test_authentication():
allure.dynamic.label(LabelType.LANGUAGE, "python")
allure.dynamic.label(LabelType.FRAMEWORK, "pytest")
...Allure ID (Allure TestOps)
@allure.id(id: str)allure.dynamic.id(id: str)
Establece el ID de la prueba.
import allure
@allure.id("123")
def test_authentication():
...Link
@allure.link(url: str, link_type: str = LinkType.LINK, name: str = None)@allure.issue(url: str, name: str = None)@allure.testcase(url: str, name: str = None)allure.dynamic.link(url: str, link_type: str = LinkType.LINK, name: str = None)allure.dynamic.issue(url: str, name: str = None)allure.dynamic.testcase(url: str, name: str = None)
Agrega un enlace relacionado con la prueba.
Basado en el link_type (que puede ser cualquier string), Allure intentará cargar un patrón de enlace correspondiente para procesar la url, según lo definido por la opción de configuración --allure-link-pattern. Si no se encuentra un patrón para el tipo dado, la URL se deja sin modificar.
El name se usará como el texto del enlace. Si se omite, se utilizará la URL no procesada en su lugar.
Por conveniencia, Allure proporciona funciones y métodos abreviados con tipos de enlace preseleccionados issue y tms.
import allure
@allure.link("https://dev.example.com/", name="Website")
@allure.issue("AUTH-123")
@allure.testcase("TMS-456")
def test_authentication():
...import allure
def pr(pr_id):
return allure.link(pr_id, name="PR {}".format(pr_id), link_type="pr")
@pr(123)
def test_authentication():
...import allure
def test_authentication():
allure.dynamic.link("https://dev.example.com/", name="Website")
allure.dynamic.issue("AUTH-123")
allure.dynamic.testcase("TMS-456")
...Jerarquía basada en el comportamiento
@allure.epic(*epics: str)@allure.feature(*features: str)@allure.story(*stories: str)allure.dynamic.epic(*epics: str)allure.dynamic.feature(*features: str)allure.dynamic.story(*stories: str)
Asigna nombres de épicas, características o historias de usuario para una prueba, como parte de la jerarquía basada en el comportamiento de Allure.
Cada función admite la configuración de uno o más valores a la vez.
import allure
@allure.epic("Web interface")
@allure.feature("Essential features")
@allure.story("Authentication")
def test_authentication():
...import allure
def test_authentication():
allure.dynamic.epic("Web interface")
allure.dynamic.feature("Essential features")
allure.dynamic.story("Authentication")
...Jerarquía basada en la suite
@allure.parent_suite(parent_suite_name)@allure.suite(suite_name)@allure.sub_suite(sub_suite_name)allure.dynamic.parent_suite(parent_suite_name)allure.dynamic.suite(suite_name)allure.dynamic.sub_suite(sub_suite_name)
Asigna nombres de suite principal, suite o sub-suite para una prueba, como parte de la jerarquía basada en suites de Allure.
Por defecto, Allure Pytest establece la suite principal y la suite según el módulo que contiene la prueba. Por ejemplo, una prueba en un módulo llamado tests.web.essentials.auth se asignará a la suite principal tests.web.essentials y a la suite auth.
import allure
@allure.parent_suite("Tests for web interface")
@allure.suite("Tests for essential features")
@allure.sub_suite("Tests for authentication")
def test_authentication():
...import allure
def test_authentication():
allure.dynamic.parent_suite("Tests for web interface")
allure.dynamic.suite("Tests for essential features")
allure.dynamic.sub_suite("Tests for authentication")
...Pasos de prueba
@allure.step(title: str)with allure.step(title: str)
Define un paso de prueba con el título dado.
Existen dos formas de definir un paso.
Pasos decorados
Define una función o un método que contenga un paso de prueba y decóralo con
@allure.step().Si acepta argumentos, puedes incluir sus valores en el título del paso mediante campos de reemplazo. Un campo de reemplazo es un nombre de parámetro delimitado por llaves
{}, tal como lo soporta el método estándarstr.format().Pasos de contexto
Escribe un paso de prueba en su lugar, pero usa la declaración
with allure.step()para crear su contexto.
import allure
def test_example():
step1()
for val in ["val1", "val2", "val3"]:
step2(val)
@allure.step("Step 1")
def step1():
...
@allure.step("Step 2 (with value {val})")
def step2(val):
...import allure
def test_example():
with allure.step("Step 1"):
...
for val in ["val1", "val2", "val3"]:
with allure.step(f"Step 2 (with value {val})"):
...Pruebas parametrizadas
allure.dynamic.parameter(name, value, excluded=None, mode=None)
Especifica un name y un value de un parámetro que se utilizó durante esta prueba.
Esto puede usarse para agregar parámetros incluso a aquellas funciones que no usan las funcionalidades de parametrización de pytest. En el segundo ejemplo a continuación, no hay parámetros de prueba según pytest, sin embargo, el informe de la prueba mostrará el parámetro “login”.
También puedes sobrescribir los valores de visualización de los parámetros existentes. En el tercer ejemplo a continuación, el informe de la prueba usará el valor corto para el parámetro en lugar de la ruta completa. Ten en cuenta que cambiar el valor de visualización no afecta el identificador único para el historial de las pruebas.
Los parámetros pueden ser usados en el título de la prueba, consulta Título.
Si el argumento excluded se establece en True, Allure no utilizará el parámetro al comparar el resultado actual de la prueba con el anterior en el historial. Este argumento solo lo utiliza Allure TestOps.
El argumento mode afecta cómo se mostrará el parámetro en el informe. Las opciones disponibles están definidas en la enumeración allure.parameter_mode:
allure.parameter_mode.DEFAULT(igual a no especificar ningún modo) — el parámetro y su valor se mostrarán en una tabla junto con otros parámetros.allure.parameter_mode.MASKED— el parámetro se mostrará en la tabla, pero su valor estará oculto. Usa este modo para contraseñas, tokens y otros parámetros sensibles.allure.parameter_mode.HIDDEN— el parámetro y su valor no se mostrarán en el informe de la prueba. Sin embargo, ten en cuenta que aún es posible extraer el valor del directorioallure_resultssi lo publicas.
from os.path import basename, expanduser
import allure
import pytest
@pytest.mark.parametrize("login", [
"johndoe",
"[email protected]",
])
def test_authentication(login):
...
def test_authentication_with_empty_login():
allure.dynamic.parameter("login", "(empty)")
...
@pytest.mark.parametrize("ssh_key", [
expanduser("~/.ssh/id_rsa1"),
expanduser("~/.ssh/id_rsa2"),
expanduser("~/.ssh/id_rsa3"),
])
def test_authentication_with_ssh_key(ssh_key):
allure.dynamic.parameter("ssh_key", basename(ssh_key))
...Adjuntos
Funciones para agregar adjuntos a los resultados de las pruebas.
Adjuntar contenido desde variables
allure.attach(body, name=None, attachment_type="text/plain", extension="attach")
Agrega body como un adjunto al resultado de la prueba bajo el nombre dado (por defecto, se usa una cadena pseudo-aleatoria única). El body debe ser de tipo bytes o str.
INFO
Puedes usar datos producidos por cualquier función, no necesariamente leídos de un archivo real. Para adjuntar contenidos de archivos existentes, usa attach.file() en su lugar.
Para asegurar que el navegador web del lector muestre los adjuntos correctamente, se recomienda especificar el tipo de cada adjunto. Existen dos formas de hacerlo:
Pasa el tipo de medio del contenido como
attachment_typey, opcionalmente, una extensión de nombre de archivo comoextension. Por ejemplo:pythonallure.attach( '{"value":100}', attachment_type="application/json", extension="json" )Algunos tipos de medios populares son
image/pngeimage/jpegpara capturas de pantalla y otras imágenes,application/jsonpara datos JSON, ytext/plainpara archivos de texto. El tipo de medio afecta cómo se mostrará los datos en el informe de la prueba, mientras que la extensión del nombre de archivo se añade al nombre del archivo cuando el usuario desea guardarlo.Pasa un valor de la clase
allure.attachment_typecomoattachment_type. Por ejemplo:pythonallure.attach( '{"value":100}', attachment_type=allure.attachment_type.JSON )Esto establecerá automáticamente el tipo de medio y la extensión de archivo adecuada.
El siguiente ejemplo es de una prueba que usa el complemento playwright-pytest para cargar una página y obtener su captura de pantalla como bytes. Luego, la captura de pantalla se adjunta al resultado de la prueba como full-page.png.
import allure
def test_attach(page):
page.goto("https://example.com/")
png_bytes = page.screenshot()
allure.attach(
png_bytes,
name="full-page",
attachment_type=allure.attachment_type.PNG
)Leer adjuntos desde archivos
allure.attach.file(source, name=None, attachment_type=None, extension=None)
Es lo mismo que attach(), pero el contenido se carga desde el archivo source existente.
import allure
from pathlib import Path
def test_attach_file(page):
page.goto("https://example.com/")
png_bytes = page.screenshot()
Path("full-page.png").write_bytes(png_bytes)
allure.attach.file(
"full-page.png",
name="full-page",
attachment_type=allure.attachment_type.PNG
)