Comenzando con Allure NUnit

Genera hermosos informes HTML usando Allure Report y tus pruebas de NUnit.

Ejemplo de Allure Report NUnit

INFO

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

Configuración

1. Prepara tu proyecto

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.
Asegúrate de tener una versión compatible de .NET.
Allure NUnit 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.NUnit en NuGet.
Agrega Allure.NUnit a las dependencias de tu proyecto usando 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:
plain
```
dotnet add ⟨PATH TO PROJECT⟩ package Allure.NUnit
```
Agrega el atributo [AllureNUnit] a todas las clases de prueba en tu proyecto. Por ejemplo:
csharp
```
using Allure.NUnit;
using NUnit.Framework;

[AllureNUnit]
class TestLabels
{
    [Test]
    public void TestCreateLabel()
    {
        // ...
    }
}
```
TIP
Si tienes una clase base común para todas tus pruebas, puedes simplemente agregar el atributo [AllureNUnit] a esa clase.

2. Ejecuta las pruebas

Ejecuta tus pruebas de NUnit de la misma manera en que las ejecutarías normalmente. Por ejemplo:

plain

dotnet test

Esto guardará los datos necesarios en allure-results o en otro directorio, según la configuración de 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 con 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 referencias o para compartirlo con 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 por ti mismo y no necesitas guardarlo.

Escribir pruebas

El adaptador Allure NUnit extiende las características estándar de informes de NUnit proporcionando capacidades adicionales para crear pruebas más informativas y estructuradas. Esta sección resalta las principales mejoras 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 mejorar la legibilidad y organización.
Distinción de estados de prueba: Distingue entre aseveraciones fallidas y excepciones no manejadas con estados fallidos y rotos.
División de pasos: Divide las pruebas en pasos de prueba más pequeños para una comprensión y mantenimiento más fáciles.
Fixtures de prueba: Incluye los métodos de configuración y desmontaje en el informe.
Pruebas parametrizadas: Describe claramente los parámetros de las pruebas parametrizadas para especificar diferentes escenarios.
Archivos 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 prueba para seleccionar qué pruebas ejecutar, lo que permite una ejecución flexible de pruebas.
Detalles del entorno: Incluye información detallada del entorno para acompañar el informe de pruebas.

En la mayoría de los casos, Allure NUnit proporciona dos formas diferentes de usar una función: la API de Atributos y la API en tiempo de ejecución.

API de Atributos: agrega un atributo de C# a un método de prueba o a una clase completa para agregar ciertos datos al resultado de la prueba. Al usar este enfoque, se garantiza que los datos se agreguen sin importar cómo se ejecute la prueba en sí.
API en tiempo de ejecución: usa las funciones de Allure para agregar ciertos datos al resultado de la prueba durante su ejecución. Este enfoque permite construir los datos de manera 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.

Attributes APIRuntime API

csharp

using Allure.Net.Commons;
using Allure.NUnit;
using Allure.NUnit.Attributes;
using NUnit.Framework;

[AllureNUnit]
class TestLabels
{
    [Test]
    [AllureSeverity(SeverityLevel.critical)]
    [AllureOwner("John Doe")]
    [AllureLink("Website", "https://dev.example.com/")]
    [AllureIssue("UI-123")]
    [AllureTms("TMS-456")]
    public void TestCreateLabel()
    {
        // ...
    }
}

csharp

using Allure.Net.Commons;
using Allure.NUnit;
using NUnit.Framework;

[AllureNUnit]
class TestLabels
{
    [Test]
    public void TestCreateLabel()
    {
        AllureApi.SetSeverity(SeverityLevel.critical);
        AllureApi.SetOwner("John Doe");
        AllureApi.AddLink("Website", "https://dev.example.com/");
        AllureApi.AddIssue("UI-123");
        AllureApi.AddTmsItem("TMS-456");
        // ...
    }
}

Organizar pruebas

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

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

Attributes APIRuntime API

csharp

using Allure.NUnit;
using Allure.NUnit.Attributes;
using NUnit.Framework;

[AllureNUnit]
[AllureEpic("Web interface")]
[AllureFeature("Essential features")]
class TestLabels
{
    [Test]
    [AllureStory("Labels")]
    public void TestCreateLabel()
    {
        // ...
    }
}

csharp

using Allure.Net.Commons;
using Allure.NUnit;
using NUnit.Framework;

[AllureNUnit]
class TestLabels
{
    [Test]
    public void TestCreateLabel()
    {
        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 el conjunto de pruebas:

Attributes APIRuntime API

csharp

using Allure.NUnit;
using Allure.NUnit.Attributes;
using NUnit.Framework;

[AllureNUnit]
[AllureParentSuite("Web interface")]
[AllureSuite("Essential features")]
class TestLabels
{
    [Test]
    [AllureSubSuite("Labels")]
    public void TestCreateLabel()
    {
        // ...
    }
}

csharp

using Allure.Net.Commons;
using Allure.NUnit;
using NUnit.Framework;

[AllureNUnit]
class TestLabels
{
    [Test]
    public void TestCreateLabel()
    {
        AllureApi.AddParentSuite("Web interface");
        AllureApi.AddSuite("Essential features");
        AllureApi.AddSubSuite("Labels");
        // ...
    }
}

La ubicación de una prueba en la jerarquía basada en el paquete está definida por los nombres completamente calificados de las clases en las que se declaran, con los prefijos comunes mostrados como paquetes principales.

Distinguir entre los estados de la prueba

Una prueba puede ser interrumpida por diversas razones. Allure NUnit refleja eso asignando un estado de prueba apropiado:

Fallida para una aserción fallida, por ejemplo, Assert.That,
Omitida para suposiciones fallidas, por ejemplo, Assume.That,
Rota para excepciones no manejadas.

Ten en cuenta que si la prueba usa técnicas como Assert.Multiple, no necesariamente se detendrá después del primer fallo de Assert.That. Esto significa que puede terminar con una lista de múltiples aserciones fallidas. Para tal prueba, Allure NUnit aún asignará el estado Fallida si las aserciones fallidas son la única razón por la que la prueba no tuvo éxito, pero asignará Rota si finalmente se detuvo debido a una excepción no manejada.

Si deseas que tu prueba con excepciones no manejadas sea Fallida en lugar de Rota, hay múltiples enfoques para lograrlo. Por ejemplo, en un Assert.That, asegúrate de que la evaluación del primer argumento (por ejemplo, acceder a un elemento de una lista) no pueda causar una excepción. Si es necesario, mueve alguna lógica a una restricción personalizada para evitar aserciones repetitivas en tu código.

Alternativamente, considera envolver el código que puede generar una excepción en una construcción que se encargue de las excepciones. Puede ser una aserción o suposición con la restricción Throws.Nothing o simplemente un bloque try..catch.

Failed (with Throws.Nothing)Failed (with try..catch)Broken test

csharp

using System;
using Allure.NUnit;
using NUnit.Framework;

[AllureNUnit]
public class TestThrowsNothing
{
    [Test]
    public void ThisTestWillBeFailed()
    {
        string value = GetValueOrFail();
        Assert.That(value, Is.EqualTo("foo"));
    }

    static string GetValueOrFail()
    {
        string value = default;
        Assert.That(() => { value = GetValue(); }, Throws.Nothing);
        return value;
    }

    static string GetValue()
    {
        throw new Exception();
    }
}

csharp

using System;
using Allure.NUnit;
using NUnit.Framework;

[AllureNUnit]
public class TestTryCatch
{
    [Test]
    public void ThisTestWillBeFailed()
    {
        string value = GetValueOrFail();
        Assert.That(value, Is.EqualTo("foo"));
    }

    static string GetValueOrFail()
    {
        string value = default;

        try
        {
            value = GetValue();
        }
        catch (Exception e)
        {
            Assert.Fail(e.Message);
        }

        return value;
    }

    static string GetValue()
    {
        throw new Exception();
    }
}

csharp

using System;
using Allure.NUnit;
using NUnit.Framework;

[AllureNUnit]
public class TestBroken
{
    [Test]
    public void ThisTestWillBeBroken()
    {
        string value = GetValue();
        Assert.That(value, Is.EqualTo("foo"));
    }

    static string GetValue()
    {
        throw new Exception();
    }
}

INFO

Cuando se lanza una excepción desde dentro de un paso, el estado del paso se selecciona de acuerdo con la configuración de allure.failExceptions.

Dividir una prueba en pasos

Allure NUnit proporciona tres formas de crear pasos y sub-pasos: "pasos basados en atributos", "pasos lambda" y "pasos sin operación", consulta la referencia.

Attribute-based stepsLambda steps and no-op steps

csharp

using System;
using Allure.Net.Commons;
using Allure.NUnit;
using Allure.NUnit.Attributes;
using NUnit.Framework;

[AllureNUnit]
class TestLabels
{
    [Test]
    public void TestCreateLabel()
    {
        TestDomain("https://domain1.example.com/");
        TestDomain("https://domain2.example.com/");
    }

    [AllureStep("Test {url}")]
    private void TestDomain([Name("Webpage URL")] string url)
    {
        AllureLifecycle.Instance.UpdateStep(stepResult =>
            stepResult.parameters.Add(
                new Parameter
                {
                    name = "Started at", value = DateTime.Now.ToString()
                }
            )
        );
        OpenBrowser();
        GoToWebpage(url);
        CloseBrowser();
    }

    [AllureStep("Open web browser")]
    private void OpenBrowser()
    {
        // ...
    }

    [AllureStep("Visit {url}")]
    private void GoToWebpage([Skip] string url)
    {
        // ...
    }

    [AllureStep("Close web browser")]
    private void CloseBrowser()
    {
        // ...
    }
}

csharp

using Allure.Net.Commons;
using Allure.NUnit;
using NUnit.Framework;

[AllureNUnit]
class TestMyWebsite
{
    [Test]
    public void TestVisitPages()
    {
        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 los fixtures de prueba

De forma predeterminada, un informe de prueba no incluye información sobre los fixtures en las clases de prueba de NUnit. Para incluirlo, agrega las anotaciones [AllureBefore] y [AllureAfter] a los métodos de fixture.

Los métodos se mostrarán como un tipo especial de pasos.

Attributes APIAttributes API + Runtime API

csharp

using Allure.NUnit;
using Allure.NUnit.Attributes;
using NUnit.Framework;

[AllureNUnit]
public class TestLabels
{

    [OneTimeSetUp]
    [AllureBefore("Start the test server")]
    public void StartServer()
    {
        // ...
    }

    [SetUp]
    [AllureBefore("Open the browser")]
    public void StartBrowser()
    {
        // ...
    }

    [Test]
    public void TestCreateLabel()
    {
        // ...
    }

    [TearDown]
    [AllureAfter("Close the browser")]
    public void CloseBrowser()
    {
        // ...
    }

    [OneTimeTearDown]
    [AllureAfter("Shutdown the test server")]
    public void StopServer()
    {
        // ...
    }
}

csharp

using Allure.Net.Commons;
using Allure.NUnit;
using Allure.NUnit.Attributes;
using NUnit.Framework;

[AllureNUnit]
public class TestFixtures
{
    [OneTimeSetUp]
    [AllureBefore]
    public void StartServer()
    {
        AllureApi.SetFixtureName("Start the test server");
        // ...
    }

    [SetUp]
    [AllureBefore]
    public void StartBrowser()
    {
        AllureApi.SetFixtureName("Open the browser");
        // ...
    }

    [Test]
    public void Test_SetUp()
    {
        // ...
    }

    [TearDown]
    [AllureAfter]
    public void CloseBrowser()
    {
        AllureApi.SetFixtureName("Close the browser");
        // ...
    }

    [OneTimeTearDown]
    [AllureAfter]
    public void StopServer()
    {
        AllureApi.SetFixtureName("Shutdown the test server");
        // ...
    }
}

Describir pruebas parametrizadas

Cuando uses el patrón de pruebas parametrizadas, utiliza los atributos de NUnit o la función AddTestParameter(), consulta la referencia.

Attributes APIRuntime API

csharp

using Allure.NUnit;
using NUnit.Framework;

[AllureNUnit]
class TestLabels
{
    [TestCase("johndoe", "qwerty")]
    [TestCase("[email protected]", "qwerty")]
    public void TestAuthentication(string login, string password)
    {
        // ...
    }
}

csharp

using Allure.Net.Commons;
using Allure.NUnit;
using NUnit.Framework;

[AllureNUnit]
class TestAuthenticaton
{
    [Test]
    public void TestAuthenticationWithUsername()
    {
        AllureApi.AddTestParameter("login", "johndoe");
        AllureApi.AddTestParameter("password", "qwerty", ParameterMode.Masked);
        // ...
    }

    [Test]
    public void TestAuthenticationWithEmail()
    {
        AllureApi.AddTestParameter("login", "[email protected]");
        AllureApi.AddTestParameter("password", "qwerty", ParameterMode.Masked);
        // ...
    }
}

Adjuntar capturas de pantalla y otros archivos

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

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

csharp

using System.IO;
using System.Text;
using Allure.Net.Commons;
using Allure.NUnit;
using NUnit.Framework;

[AllureNUnit]
class TestLabels
{
    [Test]
    public void TestCreateLabel()
    {
        // ...
        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, NUnit solo ejecutará las pruebas listadas en este archivo.

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

MacOS/LinuxWindows

bash

export ALLURE_TESTPLAN_PATH=testplan.json
dotnet test

powershell

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

Información del entorno

Para la página principal del informe, puedes recopilar varios detalles 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 algunos entornos.

Allure Report Environments Widget

Para proporcionar información sobre el 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.

Comenzando con Allure NUnit

Configuración

1. Prepara tu proyecto

2. Ejecuta las pruebas

3. Genera un informe

Escribir pruebas

Especificar descripción, enlaces y otros metadatos

Organizar pruebas

Distinguir entre los estados de la prueba

Dividir una prueba en pasos

Describir los fixtures de prueba

Describir pruebas parametrizadas

Adjuntar capturas de pantalla y otros archivos

Seleccionar pruebas mediante un archivo de plan de pruebas

Información del entorno

Powered by

Únete a nuestro boletín

Allure TestOps

Compañía

Comenzando con Allure NUnit ​

Configuración ​

1. Prepara tu proyecto ​

2. Ejecuta las pruebas ​

3. Genera un informe ​

Escribir pruebas ​

Especificar descripción, enlaces y otros metadatos ​

Organizar pruebas ​

Distinguir entre los estados de la prueba ​

Dividir una prueba en pasos ​

Describir los fixtures de prueba ​

Describir pruebas parametrizadas ​

Adjuntar capturas de pantalla y otros archivos ​

Seleccionar pruebas mediante un archivo de plan de pruebas ​

Información del entorno ​

Powered by

Únete a nuestro boletín

Allure TestOps

Compañía

Comenzando con Allure NUnit

Configuración

1. Prepara tu proyecto

2. Ejecuta las pruebas

3. Genera un informe

Escribir pruebas

Especificar descripción, enlaces y otros metadatos

Organizar pruebas

Distinguir entre los estados de la prueba

Dividir una prueba en pasos

Describir los fixtures de prueba

Describir pruebas parametrizadas

Adjuntar capturas de pantalla y otros archivos

Seleccionar pruebas mediante un archivo de plan de pruebas

Información del entorno