Referencia de Allure TestNG

Estas son las funciones que puedes utilizar para integrar tus pruebas de TestNG con Allure.

Allure TestNG ofrece 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 manera dinámica.

Metadatos

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

Título

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

Establece el título de la prueba.

Allure reconoce el argumento estándar testName de TestNG como el título de la prueba.

Si necesitas construir el título de la prueba dinámicamente, escribe una función lambda que lo haga y pásala al método updateTestCase() del objeto AllureLifecycle, consulta el ejemplo a continuación.

Annotations API

import org.testng.annotations.Test;

public class TestMyWebsite {

    @Test(testName = "Test Authentication")
    public void testAuthentication() {
        // ...
    }
}

Runtime API

import io.qameta.allure.Allure;
import org.testng.annotations.Test;

public class TestMyWebsite {

    @Test
    public void testAuthentication() {
        Allure.getLifecycle().updateTestCase(result -> {
            result.setName("Test Authentication");
        });
        // ...
    }
}

Description

• @Description(String value="", boolean useJavaDoc=false)
• Allure.description(String description)

Establece la descripción de la prueba.

Usa la anotación @Description() para establecer una descripción de manera estática o usa el método description() para establecerla dinámicamente en tiempo de ejecución.

Annotations API

import io.qameta.allure.Description;
import org.testng.annotations.Test;

public class TestMyWebsite {

    @Test
    @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.")
    public void testAuthentication() {
        // ...
    }
}

Runtime API

import io.qameta.allure.Allure;
import org.testng.annotations.Test;

public class TestMyWebsite {

    @Test
    public void testAuthentication() {
        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.");
        // ...
    }
}

Alternativamente, puedes dejar que Allure TestNG analice la descripción desde el comentario JavaDoc del método de prueba. Para ello, primero agrega un procesador de anotaciones especial a la configuración de Maven o Gradle de tu proyecto.

// En `build.gradle.kts` del proyecto:
val allureVersion = "2.24.0"

dependencies {
    // ...
    testAnnotationProcessor("io.qameta.allure:allure-descriptions-javadoc:$allureVersion")
}

Luego, usa la API de Anotaciones con el argumento useJavaDoc=true en los métodos de prueba para los cuales deseas analizar la descripción desde JavaDoc. Ten en cuenta que en un proyecto grande, procesar las anotaciones puede aumentar significativamente tanto el tiempo de compilación como el tamaño del archivo ejecutable de las pruebas.

Se permite el formato Markdown. Cualquier formato HTML, si está presente, será eliminado por motivos de seguridad.

import io.qameta.allure.Description;
import org.testng.annotations.Test;

public class TestMyWebsite {

    /**
     * This test attempts to log into the website using a login and a password. Fails if any error happens.
     * <p>
     * Note that this test does not test 2-Factor Authentication.
     */
    @Test
    @Description(useJavaDoc = true)
    public void testAuthentication() {
        // ...
    }
}

Owner (Allure TestOps)

• @Owner(String value="")

Establece el propietario de la prueba.

Annotations API

import io.qameta.allure.Owner;
import org.testng.annotations.Test;

public class TestMyWebsite {

    @Test
    @Owner("John Doe")
    public void testAuthentication() {
        // ...
    }
}

Runtime API

import io.qameta.allure.Allure;
import org.testng.annotations.Test;

public class TestMyWebsite {

    @Test
    public void testAuthentication() {
        Allure.label("owner", "John Doe");
        // ...
    }
}

Tag

Establece los tags de la prueba.

import io.qameta.allure.Allure;
import org.testng.annotations.Test;

public class TestMyWebsite {

    @Test
    public void testAuthentication() {
        Allure.label("tag", "NewUI");
        Allure.label("tag", "Essentials");
        Allure.label("tag", "Authentication");
        // ...
    }
}

Severity

• @Severity(SeverityLevel value)

Establece la severidad de la prueba.

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

Annotations API

import io.qameta.allure.Severity;
import org.testng.annotations.Test;

import static io.qameta.allure.SeverityLevel.*;

public class TestMyWebsite {

    @Test
    @Severity(CRITICAL)
    public void testAuthentication() {
        // ...
    }
}

Runtime API

import io.qameta.allure.Allure;
import org.testng.annotations.Test;

public class TestMyWebsite {

    @Test
    public void testAuthentication() {
        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 para muchas 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. Ten cuidado de copiar @Retention, @Target y las demás anotaciones necesarias tal como se muestra en el ejemplo, de lo contrario tu anotación personalizada podría no funcionar correctamente.

Annotations API

import io.qameta.allure.LabelAnnotation;
import org.testng.annotations.Test;

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();
}

public class TestMyWebsite {

    @Test
    @MyLabel("custom label value")
    public void testAuthentication() {
        // ...
    }
}

Runtime API

import io.qameta.allure.Allure;
import org.testng.annotations.Test;

public class TestMyWebsite {

    @Test
    public void testAuthentication() {
        Allure.label("language", "java");
        Allure.label("framework", "testng");
        Allure.label("CustomLabelName", "custom label value");
        // ...
    }
}

Allure ID (Allure TestOps)

• @AllureId(String value)

Establece el ID de la prueba.

import io.qameta.allure.AllureId;
import org.testng.annotations.Test;

public class TestMyWebsite {

    @Test
    @AllureId("123")
    public void testAuthentication() {
        // ...
    }
}

Link

• @Link(String value="", name="", String url="", String type=CUSTOM_LINK_TYPE)
• @Links(Link[] value)
• @Issue(String value="")
• @Issues(Issue[] value)
• @TmsLink(String value="")
• @TmsLinks(TmsLink[] value)
• Allure.link(String url)
• Allure.link(String name, String url)
• Allure.link(String name, String type, String url)
• Allure.issue(String name, String url)
• Allure.tms(String name, String url)

Añade un enlace relacionado con la prueba.

Según el type (que puede ser cualquier cadena), Allure intentará cargar un patrón de enlace correspondiente para procesar la URL, tal como se define en 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 sin procesar en su lugar.

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

Annotations API

import io.qameta.allure.Issue;
import io.qameta.allure.Link;
import io.qameta.allure.TmsLink;
import org.testng.annotations.Test;

public class TestMyWebsite {

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

Runtime API

import io.qameta.allure.Allure;
import org.testng.annotations.Test;

public class TestMyWebsite {

    @Test
    public void testAuthentication() {
        Allure.link("Website", "https://dev.example.com/");
        Allure.issue("AUTH-123", "https://jira.example.org/browse/AUTH-123");
        Allure.tms("TMS-456", "https://tms.example.org/TMS-456");
        // ...
    }
}

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 épicas, características o historias de usuario a una prueba, como parte de la jerarquía basada en comportamiento de Allure.

Annotations API

import io.qameta.allure.Epic;
import io.qameta.allure.Feature;
import io.qameta.allure.Story;
import org.testng.annotations.Test;

public class TestMyWebsite {

    @Test
    @Epic("Web interface")
    @Feature("Essential features")
    @Story("Authentication")
    public void testAuthentication() {
        // ...
    }
}

Runtime API

import io.qameta.allure.Allure;
import org.testng.annotations.Test;

public class TestMyWebsite {

    @Test
    public void testAuthentication() {
        Allure.epic("Web interface");
        Allure.feature("Essential features");
        Allure.story("Authentication");
        // ...
    }
}

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 principal o sub-suite, usa label() con los nombres de etiqueta correspondientes.

Runtime API

import io.qameta.allure.Allure;
import org.testng.annotations.Test;

public class TestMyWebsite {

    @Test
    public void testAuthentication() {
        Allure.label("parentSuite" "Tests for web interface");
        Allure.suite("Tests for essential features");
        Allure.label("subSuite", "Tests for authentication");
        // ...
    }
}

Pasos de prueba

• @Step(String value="")
• Allure.step(String name)
• Allure.step(String name, Status status)
• Allure.step(String name, ThrowableRunnableVoid runnable)
• Allure.step(String name, ThrowableRunnable<T> runnable)
• Allure.step(ThrowableContextRunnableVoid<StepContext> runnable)
• Allure.step(String name, ThrowableContextRunnableVoid<StepContext> runnable)
• Allure.step(String name, ThrowableContextRunnable<T, StepContext> runnable)
• Allure.step(ThrowableContextRunnable<T, StepContext> runnable)

Define un paso de prueba con el name dado.

Existen tres formas de definir un paso.

• “Un paso anotado”: define un método que contenga un paso de prueba y decóralo con @Step().
• “Un paso lambda”: escribe un paso de prueba en una función lambda y pásalo a Allure.step().
• “Un paso sin operación (no-op)”: simplemente pasa un name y un status opcional a Allure.step() para añadir inmediatamente una entrada correspondiente a los resultados como un sub-paso del paso actual.

Cuando implementes una función para un paso lambda, puede aceptar sin argumentos o un solo argumento de la clase StepContext. Este objeto proporciona los siguientes métodos:

• name() — sobrecarga el nombre del paso durante su ejecución.
• parameter() — indica los parámetros arbitrarios utilizados para el paso. Las firmas disponibles de este método son las mismas que para la implementación a nivel de prueba, consulta Pruebas parametrizadas.

Annotated steps

import io.qameta.allure.Step;
import org.testng.annotations.Test;

public class TestMyWebsite {

    @Test
    public void testAuthentication() {
        step1();
        step2();
    }

    @Step("Step 1")
    public void step1() {
        subStep1();
        subStep2();
    }

    @Step("Sub-step 1")
    public void subStep1() {
        // ...
    }

    @Step("Sub-step 2")
    public void subStep2() {
        // ...
    }

    @Step("Step 2")
    public void step2() {
        // ...
    }
}

Lambda steps and no-op steps

import io.qameta.allure.Allure;
import org.testng.annotations.Test;

public class TestMyWebsite {

    @Test
    public void testAuthentication() {

        Allure.step("Step 1", step -> {

            // ...
            Allure.step("Sub-step 1");

            // ...
            Allure.step("Sub-step 2");
        });

        Allure.step("Step 2", step -> {
            // ...
        });
    }
}

Pruebas parametrizadas

• @TestInstanceParameter(String value="")
• 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)

TestNG proporciona múltiples enfoques para implementar el patrón de pruebas parametrizadas. Dependiendo del enfoque que uses, es posible que necesites o no modificar tu código para agregar la lista de parámetros al informe de la prueba.

Parámetros del método de prueba vía XML

Con este enfoque, TestNG utiliza el mismo método de prueba para múltiples pruebas, cada una definida por una etiqueta <test> en el archivo XML. Los nombres y valores de los parámetros se especifican en las etiquetas <parameter> y se asignan al argumento del método usando la anotación @Parameters.

1. En una clase de prueba, define un método de prueba con uno o más argumentos. Encima de la firma del método, agrega la anotación @Parameters y pásale un array de nombres.

   Los nombres pasados a @Parameters se utilizarán tanto para asignar los valores desde el archivo XML como para mostrar los parámetros en el informe de la prueba. Estos nombres pueden diferir de los nombres reales de los argumentos del método.

2. En el archivo XML que uses para ejecutar las pruebas de TestNG, agrega una o más etiquetas <test> con la misma implementación de prueba en <class>, pero con diferentes conjuntos de valores en las etiquetas <parameter>.

import org.testng.annotations.Parameters;
import org.testng.annotations.Test;

public class TestMyWebsite {

    @Test
    @Parameters({"Login", "Password"})
    public void testAuthentication(String login, String password) {
        // ...
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">

<suite name="Test my website">

    <test name="Test authentication with login">
        <parameter name="Login" value="johndoe"/>
        <parameter name="Password" value="qwerty"/>
        <classes>
            <class name="com.example.TestMyWebsite"/>
        </classes>
    </test>

    <test name="Test authentication with email">
        <parameter name="Login" value="[email protected]"/>
        <parameter name="Password" value="qwerty"/>
        <classes>
            <class name="com.example.TestMyWebsite"/>
        </classes>
    </test>

</suite>

Parámetros de la instancia de prueba vía XML

Con este enfoque, TestNG instancia una clase de prueba múltiples veces, cada una definida por una etiqueta <test> en el archivo XML. Los nombres y valores de los parámetros se especifican en las etiquetas <parameter> y se asignan al constructor usando la anotación @Parameters.

1. En una clase de prueba, define un constructor con uno o más argumentos. Encima de la firma del constructor, agrega la anotación @Parameters y pásale un array de nombres.

   Los nombres pasados a @Parameters se utilizarán tanto para asignar los valores desde el archivo XML como para mostrar los parámetros en el informe de la prueba. Estos nombres pueden diferir de los nombres reales de los argumentos del constructor.

2. Define uno o más métodos de prueba en la clase.

   En el informe de la prueba, los parámetros definidos para el constructor se mostrarán para cada uno de los métodos de prueba. Si un método de prueba tiene su propia anotación @Parameters (como en el enfoque de “Parámetros del método de prueba vía XML”), sus parámetros se añadirán a la lista para este método en particular.

3. En el archivo XML que uses para ejecutar las pruebas de TestNG, agrega una o más etiquetas <test> con la misma implementación de prueba en <class>, pero con diferentes conjuntos de valores en las etiquetas <parameter>.

import org.testng.annotations.Parameters;
import org.testng.annotations.Test;

public class TestMyWebsite {

    private String login;
    private String password;

    @Parameters({"Login", "Password"})
    public TestMyWebsite(String login, String password) {
        this.login = login;
        this.password = password;
    }

    @Test
    public void testAuthentication() {
        // ...
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">

<suite name="parametrized">

    <test name="Test authentication with login">
        <parameter name="Login" value="johndoe"/>
        <parameter name="Password" value="qwerty"/>
        <classes>
            <class name="org.example.TestMyWebsite"/>
        </classes>
    </test>

    <test name="Test authentication with email">
        <parameter name="Login" value="[email protected]"/>
        <parameter name="Password" value="qwerty"/>
        <classes>
            <class name="org.example.TestMyWebsite"/>
        </classes>
    </test>

</suite>

Parámetros del método de prueba vía DataProvider

Este enfoque no implica modificaciones en los archivos XML y, en su lugar, obtiene tanto los nombres como los valores de los parámetros desde un método especial “proveedor de datos”.

1. En la clase de prueba, define un proveedor de datos: un método estático que retorna un array o arrays de valores, es decir, un Object[][]. Anótalo con @DataProvider.

2. Define un método de prueba que acepte argumentos. Especifica el nombre del proveedor de datos en el argumento dataProvider para la anotación @Test. TestNG ejecutará esta prueba múltiples veces, cada vez con un nuevo conjunto de valores del proveedor de datos.

   Allure TestNG reconocerá los parámetros y los mostrará en el informe de la prueba para cada método de prueba de la clase.

3. Opcionalmente, personaliza los nombres de los parámetros mediante una anotación @Parameter.

import org.testng.annotations.DataProvider;
import org.testng.annotations.Parameters;
import org.testng.annotations.Test;

public class TestMyWebsite {

    @DataProvider
    public static Object[][] authenticationData() {
        return new Object[][]{
                {"johndoe", "qwerty"},
                {"[email protected]", "qwerty"},
        };
    }

    @Test(dataProvider = "authenticationData")
    @Parameters({"Login", "Password"})  // optional
    public void testAuthentication(String login, String password) {
        // ...
    }
}

Parámetros de la instancia de prueba vía DataProvider

Con este enfoque, TestNG instancia una clase de prueba múltiples veces, cada una con un nuevo conjunto de valores proporcionados por un método especial “proveedor de datos”.

1. En la clase de prueba, define un proveedor de datos: un método estático que retorna un array o arrays de valores, es decir, un Object[][]. Anótalo con @DataProvider.

2. Define los campos para almacenar los valores de los parámetros. Añade la anotación @TestInstanceParameter a cada uno de ellos, con un argumento opcional especificando el nombre que se mostrará del parámetro para el informe de la prueba.

3. Define un constructor que acepte argumentos. Encima de la firma del constructor, agrega la anotación @Factory y especifica el nombre del proveedor de datos en su argumento dataProvider.

4. Define uno o más métodos de prueba en la clase.

   En el informe de la prueba, los parámetros definidos mediante @TestInstanceParameter se mostrarán para cada uno de los métodos de prueba. Si un método de prueba tiene su propia anotación @Parameters (como en el enfoque de “Parámetros del método de prueba vía XML”), sus parámetros se añadirán a la lista para este método en particular.

import io.qameta.allure.testng.TestInstanceParameter;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Factory;
import org.testng.annotations.Test;

public class TestMyWebsite {

    @TestInstanceParameter("Login")
    private String login;

    @TestInstanceParameter("Password")
    private String passwordForTests;

    @DataProvider
    public static Object[][] authenticationData() {
        return new Object[][]{
                {"johndoe", "qwerty"},
                {"[email protected]", "qwerty"},
        };
    }

    @Factory(dataProvider = "authenticationData")
    public TestMyWebsite(String login, String password) {
        this.login = login;
        this.passwordForTests = password;
    }

    @Test
    public void testAuthentication() {
        // ...
    }
}

API de ejecución

Además, el método Allure.parameter() se puede usar en cualquier momento para agregar los parámetros incluso a aquellas pruebas que no utilizan los enfoques de pruebas parametrizadas de TestNG.

WARNING

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.

import io.qameta.allure.Allure;
import org.testng.annotations.Test;

public class TestMyWebsite {

    @Test
    public void testAuthenticationWithUsername() {
        Allure.parameter("login", "johndoe");
        Allure.parameter("password", "qwerty");
        // ...
    }

    @Test
    public void testAuthenticationWithEmail() {
        Allure.parameter("login", "[email protected]");
        Allure.parameter("password", "qwerty");
        // ...
    }
}

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 nombre dado (por defecto, un string pseudo-aleatorio único).

TIP

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

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

Para crear un adjunto usando la API de ejecución, simplemente llama a addAttachment() o attachment() en cualquier punto 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 lo usará sin modificaciones.
• Si el tipo de datos es String, Allure lo 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 asegurar que el navegador web del lector mostrará 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 nombre 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 del nombre de archivo se añade al nombre del archivo cuando el usuario quiere guardar el archivo.

Annotations API

import io.qameta.allure.Attachment;
import org.testng.annotations.Test;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class TestMyWebsite {

    @Test
    public void testAuthentication() throws IOException {
        // ...
        attachDataTXT();
        attachScreenshotPNG();
    }

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

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

Runtime API

import io.qameta.allure.Allure;
import org.testng.annotations.Test;

import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Paths;

public class TestMyWebsite {

    @Test
    public void testAuthentication() throws IOException {
        // ...
        Allure.attachment("data.txt", "This is the file content.");
        try (InputStream is = Files.newInputStream(Paths.get("/path/img.png"))) {
            Allure.attachment("image.png", is);
        }
    }
}

INFO

Además, Allure proporciona una forma de generar hilos que añadirán adjuntos a los resultados de la prueba de manera asíncrona sin bloquear el corredor 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 a procesar archivos muy grandes, como videos de más de 1 GB. Consulta el código fuente de Allure.addByteAttachmentAsync() y Allure.addStreamAttachmentAsync() para obtener más información.

Historial de resultados

Flaky

• @Flaky

Indica que la prueba se sabe que es inestable y puede no tener éxito en todas las ocasiones. Consulta Pruebas inestables.