Referencia de Allure JBehave
Estas son las funciones que puedes usar para integrar tus pruebas de JBehave con Allure.
Metadatos
Asigna la descripción, enlaces y otros metadatos de una prueba.
Title
Allure.getLifecycle().updateTestCase(Consumer<TestResult> update)
Establece el título de la prueba.
import io.qameta.allure.Allure;
import org.jbehave.core.annotations.Then;
public class JBehaveSteps {
@When("I open labels page")
public void openLabelsPage() {
Allure.getLifecycle().updateTestCase(result ->
result.setName("Some modified scenario name"));
// ...
}
}Description
Allure.description(String description)
Establece la descripción de la prueba.
Puedes comenzar un archivo de historia con una descripción o llamar a los métodos para actualizar los valores dinámicamente.
Se permite el formato Markdown. Cualquier formato HTML, si está presente, será eliminado por motivos de seguridad.
This test attempts to create a label with specified title
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"import io.qameta.allure.Allure;
import org.jbehave.core.annotations.Then;
public class JBehaveSteps {
@When("I open labels page")
public void openLabelsPage() {
Allure.description("This test attempts to create a label with specified title");
// ...
}
}Owner
Establece el propietario de la prueba.
import io.qameta.allure.Allure;
import org.jbehave.core.annotations.Then;
public class JBehaveSteps {
@When("I open labels page")
public void openLabelsPage() {
Allure.label("owner", "John Doe");
// ...
}
}Tag
Establece los tags de la prueba.
import io.qameta.allure.Allure;
import org.jbehave.core.annotations.Then;
public class JBehaveSteps {
@When("I open labels page")
public void openLabelsPage() {
Allure.label("tag", "ui");
Allure.label("tag", "labels");
// ...
}
}Severity
Establece la severidad de la prueba.
Los valores permitidos son: “trivial”, “minor”, “normal”, “critical”, y “blocker”.
import io.qameta.allure.Allure;
import org.jbehave.core.annotations.Then;
public class JBehaveSteps {
@When("I open labels page")
public void openLabelsPage() {
Allure.label("severity", "critical");
// ...
}
}Label
Allure.label(String name, String value)
Las etiquetas de Allure son pares clave-valor utilizados para agregar información adicional sobre tus pruebas. Se pueden considerar como una forma de categorizar, organizar y buscar casos de prueba dentro de tus informes de Allure. Las etiquetas se pueden utilizar para especificar cosas como el ID del caso de prueba, la gravedad de la prueba, la característica que se está probando o la historia relacionada con la prueba. Esta información adicional ayuda a crear informes más detallados y estructurados.
import io.qameta.allure.Allure;
import org.jbehave.core.annotations.Then;
public class JBehaveSteps {
@When("I open labels page")
public void openLabelsPage() {
Allure.label("layer", "web");
Allure.label("owner", "eroshenkoam");
Allure.label("page", "/{org}/{repo}/labels");
Allure.label("severity", "critical");
Allure.label("jira", "AE-2");
// ...
}
}Allure ID (Allure TestOps)
Establece el ID de la prueba.
import io.qameta.allure.Allure;
import org.jbehave.core.annotations.Then;
public class JBehaveSteps {
@When("I open labels page")
public void openLabelsPage() {
Allure.label("ALLURE_ID", "123");
// ...
}
}Link
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.
El nombre se usará como el texto del enlace. Si se omite, se utilizará la URL completa en su lugar.
El tipo afecta el ícono que se muestra junto al enlace en el informe de prueba. Para mayor comodidad, Allure proporciona dos funciones abreviadas con tipos de enlace preseleccionados: issue y tms.
import io.qameta.allure.Allure;
import org.jbehave.core.annotations.Then;
public class JBehaveSteps {
@When("I open labels page")
public void openLabelsPage() {
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");
// ...
}
}Jerarquía basada en comportamiento
Siendo un marco orientado a BDD, JBehave organiza las pruebas según los archivos de historias. En el informe de prueba, Allure JBehave muestra esta jerarquía en la pestaña Behaviors. Los nombres de los grupos corresponden a los nombres de los archivos. No se necesita configuración especial.
Jerarquía basada en suite
Allure.suite(String value)
Asigna el nombre de la suite, como parte de la jerarquía basada en suite de Allure.
import io.qameta.allure.Allure;
import org.jbehave.core.annotations.Then;
public class JBehaveSteps {
@When("I open labels page")
public void openLabelsPage() {
Allure.label("parentSuite", "Tests for web interface");
Allure.suite("Tests for essential features");
Allure.label("subSuite", "Tests for labels");
// ...
}
}Pasos de prueba
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 sub-paso de prueba con el name dado.
Hay tres formas de definir un sub-paso.
- Un sub-paso anotado: define un método que contenga un paso de prueba y decóralo con
@Step(). - Un sub-paso lambda: escribe un sub-paso de prueba en una función lambda y pásalo a
Allure.step(). - Un sub-paso no operativo (no-op): simplemente pasa un
nombrey unstatusopcional aAllure.step()para agregar inmediatamente una entrada correspondiente a los resultados como un sub-paso del paso actual.
Cuando implementas una función para un sub-paso lambda, puede aceptar o bien ningún argumento o un único argumento de la clase StepContext. Este objeto proporciona los siguientes métodos:
name()— sobrescribe el nombre del sub-paso durante su ejecución.parameter()— indica parámetros arbitrarios usados para el sub-paso. Las firmas disponibles de este método son las mismas que para la implementación a nivel global de prueba, consulta Pruebas parametrizadas.
import io.qameta.allure.Step;
import org.jbehave.core.annotations.Then;
public class JBehaveSteps {
@When("I open labels page")
public void openLabelsPage() {
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() {
// ...
}
}import io.qameta.allure.Allure;
import org.jbehave.core.annotations.Then;
public class JBehaveSteps {
@When("I open labels page")
public void openLabelsPage() {
Allure.step("Step 1", (step) -> {
// ...
Allure.step("Sub-step 1");
// ...
Allure.step("Sub-step 2");
});
Allure.step("Step 2", (step) -> {
// ...
});
}
}Pruebas parametrizadas
Allure JBehave admite dos formas de implementar el patrón de pruebas parametrizadas:
Escenarios parametrizados
En los archivos de historias de JBehave, un escenario parametrizado (a veces llamado un esquema de escenario o una plantilla de escenario) implementa el patrón de pruebas parametrizadas. Un escenario parametrizado debe contener una tabla Examples, de la cual JBehave carga conjuntos de parámetros, fila por fila. Cada conjunto de parámetros se coloca en las declaraciones de pasos de acuerdo con los marcadores de posición, generando así una nueva iteración del escenario basada en la fila. Los datos pueden capturarse utilizando la sintaxis de inyección de parámetros y pasarse como argumentos separados al código Java.
Allure JBehave reconoce automáticamente este patrón. No se requiere configuración adicional.
El ejemplo a continuación muestra un archivo de historia y un archivo de implementación en Java 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.
Scenario: 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 |import io.qameta.allure.Allure;
import org.jbehave.core.annotations.Then;
import org.jbehave.core.annotations.When;
public class JBehaveSteps {
@When("I go to the registration form")
public void goToRegistrationForm() {
// ...
}
@When("I enter my details: $login, $password, $name, $birthday")
public void enterMyDetails() {
// ...
}
@Then("the profile should be created")
public void profileShouldBeCreated() {
// ...
}
}Parámetros en tiempo de ejecución
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. Consulta Pruebas parametrizadas para más detalles.
WARNING
Allure JBehave identifica las pruebas únicamente en función de sus nombres y parámetros pasados desde el archivo de historia. Si tienes múltiples pruebas que solo se diferencian en parámetros dinámicos (es decir, las llamadas a Allure.parameter()), se tratarán como una sola prueba a efectos 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 uno 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 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 prueba. Sin embargo, es posible extraer el valor desde el directorioallure_resultssi lo publicas.
Scenario: Registration
When I go to the registration form
And I enter my details
Then the profile should be createdimport io.qameta.allure.Allure;
import org.jbehave.core.annotations.Then;
import org.jbehave.core.annotations.When;
public class JBehaveSteps {
@When("I go to the registration form")
public void goToRegistrationForm() {
// ...
}
@When("I enter my details")
public void enterMyDetails() {
Allure.parameter("login", "johndoe");
Allure.parameter("password", "qwerty");
Allure.parameter("name", "John Doe");
Allure.parameter("birthday", "1970-01-01");
// ...
}
@Then("the profile should be created")
public void profileShouldBeCreated() {
// ...
}
}Adjuntos
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 de un archivo real.
Para asegurarte de que el navegador web del lector muestre los adjuntos correctamente, se recomienda especificar el tipo de cada adjunto. Para ello, pasa el tipo de contenido como type y, opcionalmente, una extensión de archivo como fileExtension. El tipo de contenido afecta cómo se mostrará la información en el informe de prueba, mientras que la extensión del archivo se agrega al nombre del archivo cuando el usuario desea guardarlo.
import io.qameta.allure.Allure;
import org.jbehave.core.annotations.Then;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
public class JBehaveSteps {
@When("I open labels page")
public void openLabelsPage() throws IOException {
// ...
Allure.attachment("data.txt", "This is the file content.");
Allure.attachment("img.png", Files.newInputStream(Paths.get("/path/img.png")));
}
}INFO
Adicionalmente, Allure ofrece una manera de generar hilos que agregarán adjuntos a los resultados de prueba de manera asíncrona sin bloquear el ejecutor de pruebas. Aunque no se recomienda para la mayoría de los casos, este enfoque puede mejorar pruebas que, de otro modo, tendrían que esperar el procesamiento de 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.