Referencia de Allure Spock

Estas son las funciones que puedes usar para integrar tus pruebas de Spock con Allure.

Allure Spock proporciona más de una forma de usar algunas características. En la mayoría de los casos, una forma implica usar una anotación en el método de prueba, mientras que la otra implica una llamada a un método dentro del cuerpo del método de prueba. Este último estilo se llama “dinámico” y permite construir valores de forma dinámica.

Metadatos

Título

Allure.getLifecycle().updateTestCase(Consumer<TestResult> update)

Establece el título de la prueba.

groovy

import io.qameta.allure.Allure
import spock.lang.Specification

class TestMyWebsite extends Specification {

    def "Test Authentication"() {
        Allure.getLifecycle().updateTestCase { result ->
            result.setName("Test Authentication!")
        }
        // ...
    }
}

Description

@Description(String value)
Allure.description(String description)

Establece la descripción de la prueba. Se permite el formato Markdown. Cualquier formato HTML presente será eliminado por motivos de seguridad.

Annotations APIRuntime API

groovy

import io.qameta.allure.Description
import spock.lang.Specification

class TestMyWebsite extends Specification {

    @Description("This test attempts to log into the website using a login and a password. Fails if any error happens.\n\nNote that this test does not test 2-Factor Authentication.")
    def "Test Authentication"() {
        // ...
    }
}

groovy

import io.qameta.allure.Allure
import spock.lang.Specification

class TestMyWebsite extends Specification {

    def "Test Authentication"() {
        Allure.description("This test attempts to log into the website using a login and a password. Fails if any error happens.\n\nNote that this test does not test 2-Factor Authentication.")
        // ...
    }
}

Owner

@Owner(String value)

Establece el propietario de la prueba.

Allure Spock no proporciona un método específico para establecer dinámicamente el propietario, pero puedes usar Allure.label() con el nombre de etiqueta correspondiente.

Annotations APIRuntime API

groovy

import io.qameta.allure.Owner
import spock.lang.Specification

class TestMyWebsite extends Specification {

    @Owner("John Doe")
    def "Test Authentication"() {
        // ...
    }
}

groovy

import io.qameta.allure.Allure
import spock.lang.Specification

class TestMyWebsite extends Specification {

    def "Test Authentication"() {
        Allure.label("owner", "John Doe")
        // ...
    }
}

Tag

Establece los tags de la prueba.

Puedes usar la anotación @Tag de Spock o llamar al método label() para actualizar los valores de forma dinámica.

Annotations APIRuntime API

groovy

import spock.lang.Specification
import spock.lang.Tag

class TestMyWebsite extends Specification {

    @Tag("auth")
    @Tag("security")
    def "Test Authentication"() {
        // ...
    }
}

groovy

import io.qameta.allure.Allure
import spock.lang.Specification

class TestMyWebsite extends Specification {

    def "Test Authentication"() {
        Allure.label("tag", "auth")
        Allure.label("tag", "security")
        // ...
    }
}

Severity

Establece la severidad de la prueba.

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

Allure Spock no proporciona un método específico para establecer dinámicamente el nivel de gravedad, pero puedes usar Allure.label() con el nombre de etiqueta correspondiente.

groovy

import io.qameta.allure.Allure
import spock.lang.Specification

class TestMyWebsite extends Specification {

    def "Test Authentication"() {
        Allure.label("severity", "critical")
        // ...
    }
}

Label

@LabelAnnotation(String name, String value=DEFAULT_VALUE)
Allure.label(String name, String value)

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

Para establecer una etiqueta de forma dinámica, simplemente llama a la función label() con un nombre y un valor para la etiqueta. Puedes hacerlo varias veces para crear un array de valores bajo ese nombre.

Otra forma de establecer una etiqueta es crear una clase personalizada usando @LabelAnnotation y anotar las pruebas con la nueva anotación. Consulta el ejemplo a continuación. Asegúrate de copiar @Retention, @Target y las demás anotaciones necesarias como se muestra en el ejemplo; de lo contrario, tu anotación personalizada puede no funcionar correctamente.

Annotations APIRuntime API

groovy

import io.qameta.allure.LabelAnnotation
import spock.lang.Specification

import java.lang.annotation.Documented
import java.lang.annotation.ElementType
import java.lang.annotation.Inherited
import java.lang.annotation.Retention
import java.lang.annotation.RetentionPolicy
import java.lang.annotation.Target

@Documented
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target([ElementType.METHOD, ElementType.TYPE])
@LabelAnnotation(name = "CustomLabelName")
@interface MyLabel {
    String value();
}

class TestMyWebsite extends Specification {

    @MyLabel("custom label value")
    def "Test Authentication"() {
        // ...
    }
}

groovy

import io.qameta.allure.Allure
import spock.lang.Specification

class TestMyWebsite extends Specification {

    def "Test Authentication"() {
        Allure.label("language", "groovy")
        Allure.label("framework", "spock")
        // ...
    }
}

ID

@AllureId(String value)

Establece el ID de la prueba.

Allure Spock no proporciona un método específico para establecer dinámicamente el ID, pero puedes usar Allure.label() con el nombre de etiqueta correspondiente.

Annotations API

groovy

import io.qameta.allure.AllureId
import spock.lang.Specification

class TestMyWebsite extends Specification {

    @AllureId("123")
    def "Test Authentication"() {
        // ...
    }
}

Link

@Link(String value="", name="", String url="", String type=CUSTOM_LINK_TYPE)
@Links(Link[] value)
Allure.link(String url)
Allure.link(String name, String url)
Allure.link(String name, String type, String url)

Agrega un enlace relacionado con la prueba.

En función del type (que puede ser cualquier cadena), 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 utilizará como el texto del enlace. Si se omite, se usará la URL sin procesar en su lugar.

Para mayor comodidad, Allure proporciona dos funciones abreviadas con tipos de enlace preseleccionados: issue y tms.

Annotations APIRuntime API

groovy

import io.qameta.allure.Issue
import io.qameta.allure.Link
import io.qameta.allure.TmsLink
import spock.lang.Specification

class TestMyWebsite extends Specification {

    @Link(name = "Website", url = "https://dev.example.com/")
    @Issue("AUTH-123")
    @TmsLink("TMS-456")
    def "Test Authentication"() {
        // ...
    }
}

groovy

import io.qameta.allure.Allure
import spock.lang.Specification

class TestMyWebsite extends Specification {

    def "Test Authentication"() {
        Allure.link("Website", "https://dev.example.com/")
        Allure.issue("AUTH-123", "https://example.com/issues/AUTH-123")
        Allure.tms("TMS-456", "https://example.com/tms/TMS-456")
        // ...
    }
}

Issue

@Issue(String value="")
@Issues(Issue[] value)
Allure.issue(String name, String url)

Agrega un enlace a un problema en un rastreador de errores relacionado con la prueba.

Esto es una abreviatura para @Link() con el argumento type="issue".

TMS

@TmsLink(String value="")
@TmsLinks(TmsLink[] value)
Allure.tms(String name, String url)

Agrega un enlace a un problema en un sistema de gestión de pruebas (TMS) relacionado con la prueba.

Esto es una abreviatura para @Link() con el argumento type="tms".

Jerarquía basada en el comportamiento

@Epic(String value="")
@Epics(Epic[] value)
@Feature(String value="")
@Features(Feature[] value)
@Story(String value="")
@Stories(Story[] value)
Allure.epic(String value)
Allure.feature(String value)
Allure.story(String value)

Asigna nombres de epics, features o user stories a una prueba, como parte de la jerarquía basada en comportamiento de Allure.

Jerarquía basada en la suite

Allure.suite(String value)

Asigna el nombre de la suite, como parte de la jerarquía basada en suites de Allure.

Para asignar nombres de suite padre o sub-suite, usa label() con los nombres de etiqueta correspondientes.

Pasos de prueba

@Step(String value="")
Allure.step(String name)
Allure.step(String name, Status status)

Define un paso de prueba con el name dado.

Hay dos formas de definir un paso:

“Un paso anotado”: define un método que contiene un paso de prueba y decóralo con @Step().
“Un paso no-op”: simplemente pasa un name y un status opcional a Allure.step() para agregar inmediatamente una entrada correspondiente a los resultados como un sub-paso del paso actual.

Annotated stepsNo-op steps

groovy

import io.qameta.allure.Step
import spock.lang.Specification

class TestMyWebsite extends Specification {

    def "Test Authentication"() {
        // ...
        steps.step1()
        steps.step2()
    }

    private class steps {

        @Step("Step 1")
        static def step1() {
            // ...
        }

        @Step("Step 2")
        static def step2() {
            // ...
        }
    }
}

groovy

import io.qameta.allure.Allure
import spock.lang.Specification

class TestMyWebsite extends Specification {

    def "Test Authentication"() {
        Allure.step("Step 1")
        // ...
        Allure.step("Step 2")
        // ...
    }
}

Pruebas parametrizadas

Allure.parameter(String name, T value)
Allure.parameter(String name, T value, Boolean excluded)
Allure.parameter(String name, T value, Parameter.Mode mode)
Allure.parameter(String name, T value, Boolean excluded, Parameter.Mode mode)

Especifica un name y un value de un parámetro que se utilizó durante esta prueba. Esto puede ser útil para agregar parámetros incluso a funciones que no utilizan el decorador @ParameterizedTest(). Consulta Pruebas parametrizadas para más detalles.

Ten en cuenta que en la mayoría de los casos no es necesario usar este método, ya que Allure Spock detecta automáticamente los parámetros especificados a través de las tablas de datos de Spock.

WARNING

Allure Spock identifica las pruebas solo basándose en sus nombres y tablas de datos. Si tienes múltiples pruebas que solo difieren en parámetros dinámicos (es decir, las llamadas a Allure.parameter()), se tratarán como una sola prueba para los propósitos de Historial y reintentos.

Si el argumento excluded se establece en true, Allure no usará el parámetro al comparar el resultado actual de la prueba con el anterior en el historial. Este argumento solo es utilizado por 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 Parameter.Mode:

Parameter.Mode.DEFAULT (igual que no especificar ningún modo): el parámetro y su valor se mostrarán en una tabla junto con otros parámetros.
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.
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 directorio allure_results si lo publicas.

groovy

import io.qameta.allure.Allure
import spock.lang.Specification

class TestMyWebsite extends Specification {

    def "Test Authentication"() {
        // ...
        where:
        login                 | _
        "johndoe"             | _
        "[email protected]" | _
    }

    def "Test Authentication With Empty Login"() {
        Allure.parameter("login", "")
        // ...
    }
}

Archivos adjuntos

@Attachment(String value="", String type="", String fileExtension="")
Allure.addAttachment(String name, String content)
Allure.addAttachment(String name, String type, String content)
Allure.addAttachment(String name, String type, String content, String fileExtension)
Allure.addAttachment(String name, InputStream content)
Allure.addAttachment(String name, String type, InputStream content, String fileExtension)
Allure.attachment(String name, String content)
Allure.attachment(String name, InputStream content)

Agrega content como un adjunto al resultado de la prueba bajo el name dado (por defecto, un string pseudoaleatorio único).

TIP

Puedes usar datos producidos por cualquier función, no necesariamente leídos desde un archivo real.

Para crear un adjunto utilizando la API de Anotaciones, define un método que devuelva algunos datos y anótalo con @Attachment. Llama al método en cualquier punto durante tu prueba.

Para crear un adjunto utilizando la API en tiempo de ejecución, simplemente llama a addAttachment() o attachment() en cualquier momento durante tu prueba. Pasa los datos como el argumento content.

Los datos se procesarán de la siguiente manera:

Si el tipo de datos es byte[], Allure los usará sin modificaciones.
Si el tipo de datos es String, Allure los convertirá a byte[].
Si los datos son de cualquier otro tipo, Allure llamará al método toString() y luego convertirá el string a byte[].

Para garantizar que el navegador del lector muestre los adjuntos correctamente, se recomienda especificar el tipo de cada adjunto. Para hacerlo, pasa el tipo de medio del contenido como type y, opcionalmente, una extensión de archivo como fileExtension. El tipo de medio afecta cómo se mostrarán los datos en el informe de la prueba, mientras que la extensión de archivo se agrega al nombre del archivo cuando el usuario quiere guardarlo.

Annotations APIRuntime API

groovy

import io.qameta.allure.Attachment
import spock.lang.Specification

import java.nio.file.Files
import java.nio.file.Paths

class TestMyWebsite extends Specification {

    def "Test Authentication"() {
        // ...
        attachDataTXT()
        attachScreenshotPNG()
    }

    @Attachment(value = "data", type = "text/plain", fileExtension = ".txt")
    private String attachDataTXT() {
        return "This is the file content."
    }

    @Attachment(value = "screenshot", type = "image/png", fileExtension = ".png")
    private byte[] attachScreenshotPNG() throws IOException {
        return Files.readAllBytes(Paths.get("/path/to/image.png"))
    }
}

groovy

import io.qameta.allure.Allure
import spock.lang.Specification

class TestMyWebsite extends Specification {

    def "Test Authentication"() {
        Allure.attachment("data.txt", "This is the file content.")
        new File("/path/to/image.png").withInputStream { is ->
            Allure.addAttachment("image.png", is)
        }
        expect: true
    }
}

INFO

Además, Allure proporciona una forma de generar hilos que agregarán adjuntos a los resultados de la prueba de manera asincrónica sin bloquear el ejecutor de pruebas. Aunque no se recomienda para la mayoría de los casos, este enfoque puede mejorar las pruebas que de otro modo tendrían que esperar el procesamiento de archivos muy grandes, como videos mayores de 1 GB. Consulta el código fuente de Allure.addByteAttachmentAsync() y Allure.addStreamAttachmentAsync() para aprender más.

Historial de resultados

Flaky

@Flaky

Indica que la prueba se sabe que es inestable y puede no tener éxito cada vez. Consulta Pruebas inestables.

Referencia de Allure Spock

Metadatos

Título

Description

Owner

Tag

Severity

Label

ID

Link

Issue

TMS

Jerarquía basada en el comportamiento

Jerarquía basada en la suite

Pasos de prueba

Pruebas parametrizadas

Archivos adjuntos

Historial de resultados

Flaky

Powered by

Únete a nuestro boletín

Allure TestOps

Compañía

Referencia de Allure Spock ​

Metadatos ​

Título ​

Description ​

Owner ​

Tag ​

Severity ​

Label ​

ID ​

Link ​

Issue ​

TMS ​

Jerarquía basada en el comportamiento ​

Jerarquía basada en la suite ​

Pasos de prueba ​

Pruebas parametrizadas ​

Archivos adjuntos ​

Historial de resultados ​

Flaky ​

Powered by

Únete a nuestro boletín

Allure TestOps

Compañía

Referencia de Allure Spock

Metadatos

Título

Description

Owner

Tag

Severity

Label

ID

Link

Issue

TMS

Jerarquía basada en el comportamiento

Jerarquía basada en la suite

Pasos de prueba

Pruebas parametrizadas

Archivos adjuntos

Historial de resultados

Flaky