Skip to content
Allure report logoAllure Report
Main Navigation MódulosDocumentaciónStart

Español

English

Español

English

Appearance

Sidebar Navigation

Introducción

Instalación y Actualización

Instalación para Windows

Instalación para macOS

Instalación para Linux

Instalación para Node.js

Actualización

Primeros pasos

Cómo ver un informe

Mejorar la legibilidad de informes

Mejorar la navegación en informe

Funcionalidades

Pasos de prueba

Adjuntos

Estados de prueba

Ordenar y filtrar

Categorías de defectos

Análisis visual

Análisis de estabilidad de prueba

Historial y reintentos

Cronología

Exportar a CSV

Exportar métricas

Guías

Parametrización JUnit 5

JUnit 5 & Selenide: capturas de pantalla y adjuntos

JUnit 5 & Selenium: capturas de pantalla y adjuntos

Configurar JUnit 5 con GitHub Actions

Parametrización en Pytest

Pytest & Selenium: capturas de pantalla y adjuntos

Pytest & Playwright: capturas de pantalla y adjuntos

Pytest & Playwright: videos

Parametrización en Playwright

Cómo funciona

Visión general

Archivo de resultados de prueba

Archivo de contenedor

Archivo de categorías

Archivo de entorno

Archivo de ejecutor

Archivos de historial

Integraciones

Azure DevOps

Bamboo

GitHub Actions

Jenkins

IDEs de JetBrains

TeamCity

Visual Studio Code

Frameworks

Behat

Empezando

Configuración

Referencia

Behave

Empezando

Configuración

Referencia

Codeception

Empezando

Configuración

Referencia

CodeceptJS

Empezando

Configuración

Referencia

Cucumber.js

Empezando

Configuración

Referencia

Cucumber-JVM

Empezando

Configuración

Referencia

Cucumber.rb

Empezando

Configuración

Referencia

Cypress

Empezando

Configuración

Referencia

Jasmine

Empezando

Configuración

Referencia

JBehave

Empezando

Configuración

Referencia

Jest

Empezando

Configuración

Referencia

JUnit 4

Empezando

Configuración

Referencia

JUnit 5

Empezando

Configuración

Referencia

Mocha

Empezando

Configuración

Referencia

Newman

Empezando

Configuración

Referencia

NUnit

Empezando

Configuración

Referencia

PHPUnit

Empezando

Configuración

Referencia

Playwright

Empezando

Configuración

Referencia

pytest

Empezando

Configuración

Referencia

Pytest-BDD

Empezando

Configuración

Referencia

Reqnroll

Empezando

Configuración

Referencia

REST Assured

Empezando

Configuración

Robot Framework

Empezando

Configuración

Referencia

RSpec

Empezando

Configuración

Referencia

SpecFlow

Empezando

Configuración

Referencia

Spock

Empezando

Configuración

Referencia

TestNG

Empezando

Configuración

Referencia

Vitest

Empezando

Configuración

Referencia

WebdriverIO

Empezando

Configuración

Referencia

xUnit.net

Empezando

Configuración

Referencia

On this page

Referencia de Allure PHPUnit ​

Estos son los atributos y métodos que puedes usar para integrar tus pruebas de PHPUnit con Allure Report.

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

  • API de Atributos: añade un atributo PHP a un método de prueba o a toda la clase para agregar ciertos datos al resultado de la prueba. Al usar este enfoque, los datos se añadirán independientemente de cómo se ejecute la prueba.

  • API de Ejecución: usa las funciones de Allure para añadir ciertos datos al resultado de la prueba durante su ejecución. Este enfoque permite construir los datos dinámicamente.

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

Metadatos ​

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

Title ​

  • #[DisplayName(string $value)]
  • Allure::displayName(string $name)

Establece el título de la prueba.

php
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Attribute\DisplayName;

final class TestMyWebsite extends TestCase
{
    #[DisplayName('Test Labels')]
    public function testLabels()
    {
        // ...
    }
}
php
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Allure;

final class TestMyWebsite extends TestCase
{
    public function testLabels()
    {
        Allure::displayName('Test Labels');
        // ...
    }
}

Description ​

  • #[Description(string $value)]
  • Allure::description(string $description)

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

php
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Attribute\Description;

final class TestMyWebsite extends TestCase
{
    #[Description('This test attempts to create a label with specified title.')]
    public function testLabels()
    {
        // ...
    }
}
php
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Allure;

final class TestMyWebsite extends TestCase
{
    public function testLabels()
    {
        Allure::description('This test attempts to create a label with specified title.');
        // ...
    }
}

Owner ​

  • #[Owner(string $value)]
  • Allure::owner(string $value)

Establece el propietario de la prueba.

php
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Attribute\Owner;

final class TestMyWebsite extends TestCase
{
    #[Owner('John Doe')]
    public function testLabels()
    {
        // ...
    }
}
php
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Allure;

final class TestMyWebsite extends TestCase
{
    public function testLabels()
    {
        Allure::owner('John Doe');
        // ...
    }
}

Tag ​

  • #[Tag(string $value)]
  • Allure::tag(string $value)

Establece los tags de la prueba.

php
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Attribute\Tag;

final class TestMyWebsite extends TestCase
{
    #[Tag('UI'), Tag('Labels')]
    public function testLabels()
    {
        // ...
    }
}
php
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Allure;

final class TestMyWebsite extends TestCase
{
    public function testLabels()
    {
        Allure::tag('UI');
        Allure::tag('Labels');
        // ...
    }
}

Severity ​

  • #[Severity(string $value)]
  • Allure::severity(Severity $value)

Establece la severidad de la prueba.

Para la API de Atributos, usa las constantes de la clase Severity. Para la API de Ejecución, usa los métodos estáticos de la clase Severity para construir los valores.

php
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Attribute\Severity;

final class TestMyWebsite extends TestCase
{
    #[Severity(Severity::CRITICAL)]
    public function testLabels()
    {
        // ...
    }
}
php
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Allure;
use Qameta\Allure\Model\Severity;

final class TestMyWebsite extends TestCase
{
    public function testLabels()
    {
        Allure::severity(Severity::critical());
        // ...
    }
}

Label ​

  • #[Label(string $name, ?string $value = null)]
  • Allure::label(string $name, string $value)

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

También puedes extender la API de Atributos definiendo tu propio atributo que funcione como un #[Label] con un $name predefinido.

php
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Attribute\Label;

final class TestMyWebsite extends TestCase
{
    #[Label('MyCustomLabel', 'value')]
    public function testLabels()
    {
        // ...
    }
}
php
use Attribute;
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Attribute\AbstractLabel;

#[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_METHOD | Attribute::IS_REPEATABLE)]
final class MyCustomLabel extends AbstractLabel
{
    public function __construct(string $value)
    {
        parent::__construct('MyCustomLabel', $value);
    }
}

final class TestMyWebsite extends TestCase
{
    #[MyCustomLabel('value')]
    public function testLabels()
    {
        // ...
    }
}
php
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Allure;

final class TestMyWebsite extends TestCase
{
    public function testLabels()
    {
        Allure::label('MyCustomLabel', 'value');
        // ...
    }
}

ID ​

  • #[AllureId(string $value)]

Establece el ID de la prueba.

php
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Attribute\AllureId;

final class TestMyWebsite extends TestCase
{
    #[AllureId('123')]
    public function testLabels()
    {
        // ...
    }
}

Link ​

  • #[Link(?string $name = null, ?string $url = null, string $type = Link::CUSTOM)]
  • #[Issue(?string $name = null, ?string $url = null)]
  • #[TmsLink(?string $name = null, ?string $url = null)]
  • Allure::link(string $url, ?string $name = null, ?LinkType $type = null)
  • Allure::issue(string $name, ?string $url = null)
  • Allure::tms(string $name, ?string $url = null)

Añade un enlace relacionado con la prueba.

Basado en el 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 linkTemplates. Si no se encuentra un patrón para el tipo dado, la URL se deja sin modificar.

El nombre se usará como el texto del enlace. Si se omite, se usará la URL no procesada.

Para comodidad, Allure proporciona funciones abreviadas con tipos de enlace preseleccionados Link::ISSUE y Link::TMS.

php
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Attribute\Issue;
use Qameta\Allure\Attribute\Link;
use Qameta\Allure\Attribute\TmsLink;

final class TestMyWebsite extends TestCase
{
    #[Link('My Website', 'https://example.com/')]
    #[Issue('UI-123')]
    #[TmsLink('TMS-456')]
    public function testLabels()
    {
        // ...
    }
}
php
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Allure;

final class TestMyWebsite extends TestCase
{
    public function testLabels()
    {
        Allure::link('https://example.com/', 'My Website');
        Allure::issue('UI-123');
        Allure::tms('TMS-456');
        // ...
    }
}

Jerarquía basada en el comportamiento ​

  • #[Epic(string $value)]
  • #[Feature(string $value)]
  • #[Story(string $value)]
  • Allure::epic(string $value)
  • Allure::feature(string $value)
  • Allure::story(string $value)

Asigna nombres de épicas, características o historias de usuario para una prueba, como parte de la jerarquía basada en comportamiento de Allure.

php
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Attribute\Epic;
use Qameta\Allure\Attribute\Feature;
use Qameta\Allure\Attribute\Story;

final class TestMyWebsite extends TestCase
{
    #[Epic('Web interface')]
    #[Feature('Essential features')]
    #[Story('Labels')]
    public function testLabels()
    {
        // ...
    }
}
php
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Allure;

final class TestMyWebsite extends TestCase
{
    public function testLabels()
    {
        Allure::epic('Web interface');
        Allure::feature('Essential features');
        Allure::story('Labels');
        // ...
    }
}

Jerarquía basada en la suite ​

  • #[ParentSuite(string $value)]
  • #[Suite(string $value)]
  • #[SubSuite(string $value)]
  • Allure::parentSuite(string $value)
  • Allure::suite(string $value)
  • Allure::subSuite(string $value)

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

php
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Attribute\ParentSuite;
use Qameta\Allure\Attribute\SubSuite;
use Qameta\Allure\Attribute\Suite;

final class TestMyWebsite extends TestCase
{
    #[ParentSuite('Web interface')]
    #[Suite('Essential features')]
    #[SubSuite('Labels')]
    public function testLabels()
    {
        // ...
    }
}
php
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Allure;

final class TestMyWebsite extends TestCase
{
    public function testLabels()
    {
        Allure::parentSuite('Web interface');
        Allure::suite('Essential features');
        Allure::subSuite('Labels');
        // ...
    }
}

Pasos de prueba ​

  • Allure::runStep(callable $callable, ?string $name = null)
  • Allure::addStep(string $name, ?Status $status = null)

Define pasos de prueba.

Hay tres formas de definir un paso.

  • Pasos basados en métodos

    Escribe un paso de prueba en un método público y pásalo a runStep() utilizando la sintaxis de array (es decir, [$obj, 'método']). El método debe aceptar sin argumentos o aceptar un argumento del tipo StepContextInterface. Durante la ejecución de un paso, puedes llamar a runStep() nuevamente para crear un sub-paso.

    Para cambiar el título de un paso (por defecto solo la palabra "step"), puedes:

    • añadir el atributo #[DisplayName] al método,
    • pasar el argumento opcional nombre a runStep(),
    • usar el método name() en el objeto StepContextInterface.
  • Pasos lambda

    Escribe un paso de prueba en una función lambda y pásalo a runStep(). Si la función lambda devuelve un valor, runStep() lo devolverá sin modificación, y no afectará al informe. Durante la ejecución de un paso, puedes llamar a runStep() nuevamente para crear un sub-paso.

    Para cambiar el título de un paso (por defecto solo la palabra "step"), puedes:

    • añadir el atributo #[DisplayName] a la función lambda,
    • pasar el argumento opcional nombre a runStep(),
    • usar el método name() en el objeto StepContextInterface.
  • Pasos no operativos (no-op)

    Si llamas a addStep(), Allure añadirá un paso no operativo al informe. Esto permite un informe estilo log dentro de una prueba o dentro de un paso más grande. Un paso no operativo termina inmediatamente después de que comienza y no puede tener sub-pasos ni parámetros.

    El segundo argumento opcional indica el estado que se mostrará para el paso en el informe. Los valores permitidos son: Status::passed() (por defecto), Status::failed(), Status::broken() y Status::skipped().

Durante la ejecución de un paso basado en método o un paso lambda, es posible describir los datos con los que trabaja el paso, por ejemplo, si lo ejecutas varias veces con diferentes datos. Para hacerlo, usa el método parameter() del objeto StepContextInterface.

php
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Allure;
use Qameta\Allure\Attribute\DisplayName;
use Qameta\Allure\StepContextInterface;

final class TestMyWebsite extends TestCase
{
    public function testLabels()
    {
        Allure::runStep([$this, 'logIn']);
        Allure::runStep([$this, 'createLabel']);
        Allure::runStep([$this, 'checkThatLabelExists']);
    }

    #[DisplayName('Log in')]
    function logIn(StepContextInterface $context)
    {
        $context->parameter('Email', '[email protected]');
        $context->parameter('Password', 'qwerty');
        // ...
    }

    #[DisplayName('Create label')]
    function createLabel(StepContextInterface $context)
    {
        $context->parameter('Label name', 'My Label');
        // ...
    }

    #[DisplayName('Check that label exists')]
    function checkThatLabelExists(StepContextInterface $context)
    {
        $context->parameter('Label name', 'My Label');
        // ...
    }
}
php
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Allure;
use Qameta\Allure\StepContextInterface;

final class TestMyWebsite extends TestCase
{
    public function testLabels()
    {
        Allure::runStep(function (StepContextInterface $context) {
            $context->parameter('Email', '[email protected]');
            $context->parameter('Password', 'qwerty');
            // ...
        }, 'Log in');

        Allure::runStep(function (StepContextInterface $context) {
            $context->parameter('Label name', 'My Label');
            // ...
        }, 'Create label');

        Allure::runStep(function (StepContextInterface $context) {
            $context->parameter('Label name', 'My Label');
            // ...
        }, 'Check that label exists');
    }
}
php
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Allure;

final class TestMyWebsite extends TestCase
{
    public function testLabels()
    {
        // ...
        Allure::addStep('Log in');

        // ...
        Allure::addStep('Create label');

        // ...
        Allure::addStep('Check that label exists');
    }
}

Pruebas parametrizadas ​

  • Allure::parameter(string $name, ?string $value, bool $excluded = false, ?ParameterMode $mode = null)

Allure PHPUnit soporta el patrón de pruebas parametrizadas.

Si pasas parámetros a tus pruebas a través de los proveedores de datos de PHPUnit, el informe de prueba añadirá un pseudo-parámetro numerado para cada iteración de la ejecución, por ejemplo, “Conjunto de datos: #0”, “Conjunto de datos: #1”, etc. Para que el informe muestre los parámetros reales y sus valores, pásalos a Allure::parameter().

Ten en cuenta que Allure::parameter() también se puede usar para añadir los parámetros incluso a funciones fuera de las pruebas parametrizadas de PHPUnit.

Si el argumento excluded se establece en verdadero, Allure no utilizará el parámetro al comparar el resultado actual de la prueba con el anterior en el historial.

El argumento mode afecta cómo se mostrará el parámetro en el informe. Las opciones disponibles son:

  • null — el parámetro y su valor se mostrarán en una tabla junto con otros parámetros.
  • ParameterMode::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.
  • ParameterMode::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.

Los parámetros no solo se pueden añadir a los resultados completos de la prueba, sino también a pasos individuales dentro de ellos. Consulta Pasos de prueba para más detalles.

php
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Allure;

final class TestDataProvider extends TestCase
{
    public static function credentialsProvider()
    {
        return [
            ['johndoe', 'qwerty'],
            ['[email protected]', 'qwerty'],
        ];
    }

    #[DataProvider('credentialsProvider')]
    public function testAuthentication(string $login, string $password)
    {
        Allure::parameter('login', $login);
        Allure::parameter('password', $password);
        // ...
    }
}
php
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Allure;

final class TestMyWebsite extends TestCase
{
    public function testAuthenticationWithUsername()
    {
        Allure::parameter('login', 'johndoe');
        Allure::parameter('password', 'qwerty');
        // ...
    }

    public function testAuthenticationWithEmail()
    {
        Allure::parameter('login', '[email protected]');
        Allure::parameter('password', 'qwerty');
        // ...
    }
}

Archivos adjuntos ​

  • Allure::attachment(string $name, string $content, ?string $type = null, ?string $fileExtension = null)
  • Allure::attachmentFile(string $name, string $file, ?string $type = null, ?string $fileExtension = null)

Añade un archivo adjunto al resultado de la prueba bajo el nombre dado.

TIP

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

Para crear un archivo adjunto utilizando la API de tiempo de ejecución, llama a Allure::attachment() o Allure::attachmentFile() en cualquier momento durante tu prueba. Pasa ya sea el contenido o la ruta desde la que se leerán los datos.

Para asegurarte de que el navegador web del lector muestre los archivos adjuntos correctamente, se recomienda especificar el tipo de cada archivo 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á el dato en el informe de la prueba, mientras que la extensión de archivo se añadirá al nombre del archivo cuando el usuario quiera guardar el archivo.

php
use PHPUnit\Framework\TestCase;
use Qameta\Allure\Allure;

final class TestMyWebsite extends TestCase
{
    public function testLabels()
    {
        // ...
        Allure::attachment('data.txt', 'This is the file content.', 'text/plain');
        Allure::attachmentFile('data.txt', '/path/to/image.png', 'image/png');
    }
}
Pager
Previous pageConfiguración
Next pageEmpezando
Powered by

Únete a nuestro boletín

Allure TestOps
  • Visión general
  • Por qué elegirnos
  • Nube
  • Autoalojado
  • Historias de éxito
Compañía
  • Documentación
  • Blog
  • Sobre nosotros
  • Contacto
  • Eventos
© 2025 Qameta Software Inc. All rights reserved.