Referencia de Allure Behave

Estos son los atributos y métodos que puedes usar para integrar tus pruebas de behave con Allure Report.

En la mayoría de los casos, necesitas indicar a Allure Behave que una cierta propiedad debe ser asignada al resultado de la prueba. La mayoría de las propiedades se pueden asignar mediante etiquetas Gherkin o mediante la API de ejecución.

• Etiquetas Gherkin: usa etiquetas Gherkin para asignar varios datos a un Scenario en particular o a una Feature completa.

  La mayoría de las etiquetas requieren valores. Puedes usar un colon o un signo igual para separar el valor del nombre, por ejemplo, @allure.label.epic:WebInterface es idéntico a @allure.label.epic=WebInterface. Ten en cuenta que debido a una limitación en la sintaxis de Gherkin, el valor no puede contener espacios.

  Al usar este enfoque, se garantiza que los datos se agregarán al resultado de la prueba independientemente de cómo se ejecute la prueba.

• API de ejecución: usa las funciones de Allure para agregar datos al resultado de la prueba durante la ejecución de sus pasos. Este enfoque permite construir los datos dinámicamente.

  Ten en cuenta que se recomienda llamar a las funciones de Allure lo más cerca posible al inicio de la prueba. De esta manera, los datos se agregarán incluso si la prueba falla temprano.

Metadatos

Asigna descripción, enlaces y otros metadatos a la prueba.

Description

• allure.dynamic.description(test_description: str)

Establece la descripción de la prueba.

Allure Behave usa la descripción de un escenario del archivo Gherkin, si está presente. Como alternativa, usa la API de ejecución para establecer la descripción dinámicamente.

Se permite el formato Markdown. Cualquier formato HTML, si está presente, se eliminará por razones de seguridad.

Gherkin description

Feature: Labels

  Scenario: Create new label for authorized user
  This test attempts to create a label with specified title

    When I open labels page
    And I create label with title "hello"
    Then I should see label with title "hello"

Runtime API

import allure
from behave import then

@then("I open labels page")
def step_impl(context):
    allure.dynamic.description("This test attempts to create a label with specified title")
    ...

Owner

Establece el propietario de la prueba.

Gherkin tags

@allure.label.owner:JohnDoe
Feature: Labels

  Scenario: Create new label for authorized user
    When I open labels page
    And I create label with title "hello"
    Then I should see label with title "hello"

Tag

Establece los tags de la prueba.

Cualquier tag Gherkin se agrega automáticamente a la lista de etiquetas de la prueba, a menos que coincida con uno de los patrones conocidos para otros tags.

Gherkin tags

@UI @Labels
Feature: Labels

  Scenario: Create new label for authorized user
    When I open labels page
    And I create label with title "hello"
    Then I should see label with title "hello"

Severity

Establece la severidad de la prueba.

Los valores permitidos son: “trivial”, “minor”, “normal”, “critical”, y “blocker”.

Gherkin tags

Feature: Labels

  @critical
  Scenario: Create new label for authorized user
    When I open labels page
    And I create label with title "hello"
    Then I should see label with title "hello"

Label

Establece una etiqueta arbitraria para la prueba. Esta es la implementación subyacente para muchas de las otras funciones de Allure.

Gherkin tags

@allure.label.layer:web
@allure.label.owner:eroshenkoam
@allure.label.page:/{org}/{repo}/labels
@allure.label.jira:AE-2
Feature: Labels

  Scenario: Create new label for authorized user
    When I open labels page
    And I create label with title "hello"
    Then I should see label with title "hello"

ID de Allure (Allure TestOps)

Establece el ID de la prueba.

Gherkin tags

Feature: Labels

  @allure.label.allure_id:123
  Scenario: Create new label for authorized user
    When I open labels page
    And I create label with title "hello"
    Then I should see label with title "hello"

Link

• 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)

Añadir un enlace relacionado con la prueba.

• En un archivo Gherkin, utiliza las etiquetas @allure.⟨TIPO⟩:⟨URL⟩ o @allure.⟨TIPO⟩.⟨NOMBRE⟩:⟨URL⟩. Si la ⟨URL⟩ no comienza con “http” o “https”, se procesará según las opciones de configuración link_pattern y issue_pattern. La URL resultante se usará tanto como el objetivo del enlace como el nombre del enlace, a menos que se proporcione un ⟨NOMBRE⟩ personalizado.

• En la API en tiempo de ejecución, utiliza la función allure.dynamic.link() con un argumento opcional link_type o sus versiones abreviadas para los tipos de enlace issue y tms.

Gherkin tags

@allure.link.MyWebsite:https://dev.example.com/
@allure.issue.UI-123:https://issues.example.com/UI-123
@allure.tms.TMS-456:https://tms.example.com/TMS-456
Feature: Labels

  Scenario: Create new label for authorized user
    When I open labels page
    And I create label with title "hello"
    Then I should see label with title "hello"

Runtime API

import allure
from behave import then

@then("I open labels page")
def step_impl(context):
    allure.dynamic.link("https://dev.example.com/", name="Website")
    allure.dynamic.issue("https://issues.example.com/UI-123", name="UI-123")
    allure.dynamic.testcase("https://tms.example.com/TMS-456", name="TMS-456")
    ...

Jerarquía basada en el comportamiento

Asigna nombres de épicos, funcionalidades o historias de usuario a una prueba, como parte de la jerarquía basada en el comportamiento de Allure.

Cada función soporta asignar uno o más valores a la vez.

Gherkin tags

@allure.label.epic:WebInterface
Feature: Labels

  @allure.label.story:CreateLabels
  Scenario: Create new label for authorized user
    When I open labels page
    And I create label with title "hello"
    Then I should see label with title "hello"

Jerarquía basada en la suite

Asigna los nombres de suite principal, suite o sub-suite a una prueba, como parte de la jerarquía basada en la suite de Allure.

Gherkin tags

@allure.label.parentSuite:WebInterface
@allure.label.suite:EssentialFeatures
@allure.label.subSuite:Labels
Feature: Labels

  Scenario: Create new label for authorized user
    When I open labels page
    And I create label with title "hello"
    Then I should see label with title "hello"

Jerarquía basada en el paquete

Asigna los nombres del paquete, clase de prueba y método de prueba, como parte de la jerarquía basada en el paquete de Allure.

Gherkin tags

@allure.label.package:org.example
@allure.label.testClass:TestMyWebsite
@allure.label.testMethod:TestLabels()
Feature: Labels

  Scenario: Create new label for authorized user
    When I open labels page
    And I create label with title "hello"
    Then I should see label with title "hello"

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ándar str.format().

• Pasos en contexto

  Escribe un paso de prueba en el lugar, pero utiliza la declaración with allure.step() para crear su contexto.

Decorated steps

import allure
from behave import then

@then("I open labels page")
def step_impl(context):
    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):
    ...

Context steps

import allure
from behave import then

@then("I open labels page")
def step_impl(context):
    with allure.step("Step 1"):
        ...

    for val in ["val1", "val2", "val3"]:
        with allure.step(f"Step 2 (with value {val})"):
            ...

Pruebas parametrizadas

En Gherkin, un Scenario Outline (o una Plantilla de Escenario) implementa el patrón de pruebas parametrizadas. Un esquema de escenario debe contener una tabla de Examples, de la cual behave carga conjuntos de parámetros, uno por uno. Cada conjunto de parámetros se coloca en las declaraciones de pasos según los marcadores de posición, generando así un nuevo escenario basado en la fila. Luego, Behave ejecuta cada uno de ellos de forma independiente, como si fuera un Scenario separado. Los datos pueden ser capturados por behave y pasados como argumentos separados al código Python.

Allure Behave reconoce automáticamente este patrón. No se requiere configuración adicional.

El siguiente ejemplo muestra un archivo Gherkin y un archivo de implementación en Python de una prueba. En este ejemplo, los cuatro parámetros para el paso “I enter my details...” se mostrarán en ambas instancias del escenario en el informe de prueba.

Feature: User management

  Scenario Outline: Registration
    When I go to the registration form
    And I enter my details: <login>, <password>, <name>, <birthday>
    Then the profile should be created

    Examples:
      | login   | password | name     | birthday   |
      | johndoe | qwerty   | John Doe | 1970-01-01 |
      | janedoe | 123456   | Jane Doe | 1111-11-11 |

from behave import then, when

@when('I go to the registration form')
def step_impl(context):
    ...

@when('I enter my details: {login}, {password}, {name}, {birthday}')
def step_impl(context, login, password, name, birthday):
    ...

@then('the profile should be created')
def step_impl(context):
    ...

Archivos adjuntos

Funciones para agregar archivos adjuntos a los resultados de las pruebas.

Adjuntar contenido desde variables

• allure.attach(body, name=None, attachment_type="text/plain", extension="attach")

Agrega el body como un archivo adjunto al resultado de la prueba bajo el nombre dado (name) (por defecto, será 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 desde un archivo real. Para adjuntar contenidos de archivos existentes, usa attach.file().

Para asegurar que el navegador web del lector muestre los archivos adjuntos correctamente, se recomienda especificar el tipo de cada archivo adjunto. Hay dos maneras de hacerlo:

• Pasa el tipo de medio del contenido como attachment_type y, opcionalmente, una extensión de archivo como extension. Por ejemplo:

  allure.attach('{"value":100}', attachment_type="application/json", extension="json")

  Algunos tipos de medios populares son image/png y image/jpeg para capturas de pantalla y otras imágenes, application/json para datos JSON, y text/plain para archivos de texto. El tipo de medio afecta cómo se mostrará los datos en el informe de prueba, mientras que la extensión del archivo se agrega al nombre del archivo cuando el usuario desea guardar el archivo.

• Pasa un valor de la clase allure.attachment_type como attachment_type. Por ejemplo:

  allure.attach('{"value":100}', attachment_type=allure.attachment_type.JSON)

  Esto establecerá automáticamente el tipo de medio y la extensión de archivo adecuada.

import allure
from behave import then

@then("I open labels page")
def step_impl(context):
    ...
    with open('/path/to/image.png', 'rb') as png_file:
        png_bytes = png_file.read()
    allure.attach(png_bytes, name="img", attachment_type=allure.attachment_type.PNG)

Leer archivos 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 behave import then

@then("I open labels page")
def step_impl(context):
    ...
    allure.attach.file(
        '/path/img.png',
        name="img",
        attachment_type=allure.attachment_type.PNG
    )