Empezando con Allure SpecFlow

Genera hermosos informes HTML utilizando Allure Report y tus pruebas de SpecFlow.

INFO

Consulta el proyecto de ejemplo en github.com/allure-examples/allure-specflow para ver Allure SpecFlow en acción.

Configuración

1. Prepara tu proyecto

1. Instala la herramienta de línea de comandos Allure Report, si aún no está instalada en tu sistema operativo. Ten en cuenta que Allure Report requiere Java, consulta las instrucciones de instalación.

2. Asegúrate de tener una versión compatible de .NET.

   Allure SpecFlow requiere un marco que implemente .NET Standard versión 2.0. Puedes encontrar la lista completa de marcos compatibles en la página de Allure.SpecFlow en NuGet.

3. Agrega Allure.SpecFlow a las dependencias de tu proyecto utilizando tu IDE o la línea de comandos.

   Por ejemplo, así es como se puede agregar la dependencia a un proyecto con la CLI de dotnet:

   dotnet add ⟨PATH TO PROJECT⟩ package Allure.SpecFlow

4. En el archivo specflow.json, agrega Allure.SpecFlowPlugin como un ensamblado de pasos.

   {
     "stepAssemblies": [{ "assembly": "Allure.SpecFlowPlugin" }]
   }

   Make sure that specflow.json is copied to the output directory. You can do it in your IDE or manually in your *.csproj file by setting the item group's CopyToOutputDirectory to either Always or PreserveNewest.

   <Project Sdk="Microsoft.NET.Sdk">
       <!-- ... -->
       <ItemGroup>
         <None Update="specflow.json">
           <CopyToOutputDirectory>Always</CopyToOutputDirectory>
         </None>
       </ItemGroup>
   </Project>

2. Ejecuta las pruebas

Ejecuta tus pruebas de SpecFlow de la misma manera que lo harías normalmente. Por ejemplo:

dotnet test

Esto guardará los datos necesarios en allure-results u otro directorio, según la opción de configuración allure.directory. Si el directorio ya existe, los nuevos archivos se agregarán a los existentes, de modo que un informe futuro se basará en todos ellos.

3. Genera un informe

Finalmente, convierte los resultados de las pruebas en un informe HTML. Esto se puede hacer mediante uno de dos comandos:

• allure generate procesa los resultados de las pruebas y guarda un informe HTML en el directorio allure-report. Para ver el informe, usa el comando allure open.

  Usa este comando si necesitas guardar el informe para futuras consultas o para compartirlo con tus colegas.

• allure serve crea el mismo informe que allure generate, pero lo coloca en un directorio temporal y comienza un servidor web local configurado para mostrar el contenido de este directorio. Luego, el comando abre automáticamente la página principal del informe en un navegador web.

  Usa este comando si necesitas ver el informe para ti mismo y no necesitas guardarlo.

Escribir pruebas

El adaptador Allure SpecFlow extiende las características estándar de informes de SpecFlow al proporcionar capacidades adicionales para crear pruebas más informativas y estructuradas. Esta sección destaca las mejoras clave que se pueden utilizar:

• Anotación de metadatos: Mejora los informes de pruebas con descripciones, enlaces y otros metadatos.
• Organización de pruebas: Estructura tus pruebas en jerarquías claras para una mejor legibilidad y organización.
• División de pasos: Desglosa las pruebas en pasos de prueba más pequeños para una comprensión y mantenimiento más fáciles.
• Pruebas parametrizadas: Describe claramente los parámetros para las pruebas parametrizadas para especificar diferentes escenarios.
• Adjuntos: Captura automáticamente capturas de pantalla y otros archivos durante la ejecución de las pruebas.
• Selección de pruebas: Usa un archivo de plan de pruebas para seleccionar qué pruebas ejecutar, lo que permite una ejecución flexible de las pruebas.
• Detalles del entorno: Incluye información detallada del entorno para acompañar el informe de la prueba.

En la mayoría de los casos, necesitas indicar a Allure SpecFlow que una cierta propiedad debe asignarse al resultado de la prueba. La mayoría de las propiedades pueden asignarse mediante etiquetas Gherkin o mediante la API en tiempo de ejecución.

• Etiquetas Gherkin: usa etiquetas Gherkin para asignar varios datos a un Escenario particular o a toda una Característica. De forma predeterminada, todas las etiquetas Gherkin se convertirán en etiquetas de prueba, pero puedes configurar la conversión a varios otros metadatos mediante expresiones regulares en el archivo de configuración.

  Ten en cuenta que debido a una limitación en la sintaxis de Gherkin, una etiqueta no puede contener espacios.

• API en tiempo 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 de forma dinámica.

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

Especificar descripción, enlaces y otros metadatos

Hay muchos metadatos que puedes agregar a cada prueba para que aparezca en el informe. Consulta la referencia para más detalles.

Gherkin tags

Feature: Labels

  @critical
  @allure.label.owner:JohnDoe
  @link:https://dev.example.com/
  @issue:AUTH-123
  @tms:TMS-456
  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

using Allure.Net.Commons;
using TechTalk.SpecFlow;

[Binding]
public class Steps
{
    [When("I open labels page")]
    public void TestLabels()
    {
        AllureApi.SetDescription("This test attempts to create a label with specified title");
        AllureApi.SetSeverity(SeverityLevel.critical);
        AllureApi.SetOwner("John Doe");
        AllureApi.AddLink("Website", "https://dev.example.com/");
        AllureApi.AddIssue("AUTH-123");
        AllureApi.AddTmsItem("TMS-456");
        // ...
    }
}

Organizar pruebas

Como se describe en Mejorar la navegación en tu informe de pruebas, Allure admite múltiples formas de organizar las pruebas en estructuras jerárquicas. Allure SpecFlow proporciona la API para asignar los campos relevantes a las pruebas ya sea agregando atributos o "dinámicamente" (lo mismo que para los campos de metadatos).

Para especificar la ubicación de una prueba en la jerarquía basada en el comportamiento:

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"

Runtime API

using Allure.Net.Commons;
using TechTalk.SpecFlow;

[Binding]
public class Steps
{
    [When("I open labels page")]
    public void TestLabels()
    {
        AllureApi.AddEpic("Web interface");
        AllureApi.AddFeature("Essential features");
        AllureApi.AddStory("Labels");
        // ...
    }
}

Para especificar la ubicación de una prueba en la jerarquía basada en suites:

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"

Runtime API

using Allure.Net.Commons;
using TechTalk.SpecFlow;

[Binding]
public class Steps
{
    [When("I open labels page")]
    public void TestLabels()
    {
        AllureApi.AddParentSuite("Web interface");
        AllureApi.AddSuite("Essential features");
        AllureApi.AddSubSuite("Labels");
        // ...
    }
}

Para especificar la ubicación de una prueba en la jerarquía basada en paquetes:

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"

Runtime API

using Allure.Net.Commons;
using TechTalk.SpecFlow;

[Binding]
public class Steps
{
    [When("I open labels page")]
    public void TestLabels()
    {
        AllureApi.AddLabel(Label.Package("org.example"));
        AllureApi.AddLabel(Label.TestClass("TestMyWebsite"));
        AllureApi.AddLabel(Label.TestMethod("TestLabels()"));
        // ...
    }
}

Dividir una prueba en pasos

Allure SpecFlow proporciona dos formas de crear pasos y sub-pasos: “pasos lambda” y “pasos no operativos”, consulta la referencia.

using Allure.Net.Commons;
using TechTalk.SpecFlow;

[Binding]
public class Steps
{
    [Then("visit pages")]
    public void ThenVisitPages()
    {
        string[] urls =
        {
            "https://domain1.example.com/",
            "https://domain2.example.com/"
        };

        foreach (string url in urls)
        {
            AllureApi.Step($"Test {url}", () =>
            {
                AllureLifecycle.Instance.UpdateStep(stepResult =>
                {
                    stepResult.parameters.Add(
                        new Parameter { name = "Webpage URL", value = url }
                    );
                });

                AllureApi.Step("Opening web browser...");
                // ...

                AllureApi.Step($"Visiting {url}...");
                // ...

                AllureApi.Step("Closing web browser...");
                // ...
            });
        }
    }
}

Describir pruebas parametrizadas

Un informe de prueba de Allure puede reflejar múltiples formas en las que puedes pasar datos desde tu archivo Gherkin a tu código de implementación en C#, a saber:

• esquemas de escenarios,
• tablas de datos verticales,
• tablas de datos horizontales,
• parámetros en tiempo de ejecución.

El siguiente ejemplo muestra un archivo de configuración, un archivo Gherkin y un archivo de implementación en C# de una prueba. En este ejemplo, los cuatro parámetros para el paso “Ingreso mis datos” se mostrarán en el informe de la prueba.

{
  "specflow": {
    "stepArguments": {
      "convertToParameters": true,
      "paramNameRegex": "^Parameter$",
      "paramValueRegex": "^Value$"
    }
  }
}

Feature: User management

  Scenario: Registration
    When I go to the registration form
    And I enter my details
      | Parameter | Value      |
      | login     | johndoe    |
      | password  | qwerty     |
      | name      | John Doe   |
      | birthday  | 1970-01-01 |
    Then the profile should be created

using TechTalk.SpecFlow;

[Binding]
public class Steps
{
    [When("I go to the registration form")]
    public void WhenIGoToTheRegistrationForm()
    {
        // ...
    }

    [When("I enter my details")]
    public void WhenIEnterMyDetails(Table table)
    {
        // ...
    }

    [Then("the profile should be created")]
    public void ThenTheProfileShouldBeCreated()
    {
        // ...
    }
}

Adjuntar capturas de pantalla y otros archivos

Puedes adjuntar cualquier tipo de archivo a tu informe de Allure. Por ejemplo, una forma popular de hacer que un informe sea más fácil de entender es adjuntar una captura de pantalla de la interfaz de usuario en un determinado punto.

Allure SpecFlow proporciona varias formas de crear un adjunto, tanto desde archivos existentes como generados dinámicamente, consulta la referencia.

using System.IO;
using System.Text;
using Allure.Net.Commons;
using TechTalk.SpecFlow;

[Binding]
public class Steps
{
    [When("I open labels page")]
    public void TestLabels()
    {
        AllureApi.AddAttachment(
            "data.txt",
            "text/plain",
            Encoding.UTF8.GetBytes("This is the file content.")
        );
        AllureApi.AddAttachment(
            "image1.png",
            "image/png",
            File.ReadAllBytes("/path/to/image1.png")
        );
        AllureApi.AddAttachment(
            "image2.png",
            "image/png",
            "/path/to/image2.png"
        );
    }
}

Seleccionar pruebas mediante un archivo de plan de pruebas

Si la variable de entorno ALLURE_TESTPLAN_PATH está definida y apunta a un archivo existente, SpecFlow solo ejecutará las pruebas listadas en este archivo.

Aquí tienes un ejemplo de ejecución de pruebas según un archivo llamado testplan.json:

MacOS/Linux

export ALLURE_TESTPLAN_PATH=testplan.json
dotnet test

Windows

$Env:ALLURE_TESTPLAN_PATH = "testplan.json"
dotnet test

Información del entorno

Para la página principal del informe, puedes recopilar diversos datos sobre el entorno en el que se ejecutaron las pruebas.

Por ejemplo, es una buena idea usar esto para recordar la versión del sistema operativo y la versión de .NET. Esto puede ayudar al lector futuro a investigar errores que solo se reproducen en ciertos entornos.

Para proporcionar información del entorno, coloca un archivo llamado environment.properties en el directorio allure-results después de ejecutar las pruebas. Consulta el ejemplo en Archivo de entorno.

Ten en cuenta que esta función debe usarse para propiedades que no cambian para todas las pruebas en el informe. Si tienes propiedades que pueden ser diferentes para diferentes pruebas, considera usar Pruebas parametrizadas.