Referencia de Allure Codeception

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

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

API de Atributos: agrega un atributo PHP a un método de prueba o a toda una clase para agregar ciertos datos al resultado de la prueba. Al usar este enfoque, se garantiza que los datos se agregarán independientemente de cómo se ejecute la prueba.
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 dinámicamente.
Ten en cuenta que se recomienda llamar a las funciones de Allure lo más cerca posible del comienzo de la prueba. De esta manera, los datos se agregarán incluso si la prueba falla temprano.

Metadatos

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

Title

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

Establece el título de la prueba.

Attributes APIRuntime API

php

use Codeception\Test\Unit;
use Qameta\Allure\Attribute\DisplayName;

class TestMyWebsite extends Unit
{
    #[DisplayName('Test Labels')]
    public function testLabels()
    {
        // ...
    }
}

php

use Codeception\Test\Unit;
use Qameta\Allure\Allure;

class TestMyWebsite extends Unit
{
    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 motivos de seguridad.

Attributes APIRuntime API

php

use Codeception\Test\Unit;
use Qameta\Allure\Attribute\Description;

class TestMyWebsite extends Unit
{
    #[Description('This test attempts to create a label with specified title.')]
    public function testLabels()
    {
        // ...
    }
}

php

use Codeception\Test\Unit;
use Qameta\Allure\Allure;

class TestMyWebsite extends Unit
{
    public function testLabels()
    {
        Allure::description('This test attempts to log into the website using a login and a password.');
        // ...
    }
}

Owner

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

Establece el propietario de la prueba.

Attributes APIRuntime API

php

use Codeception\Test\Unit;
use Qameta\Allure\Attribute\Owner;

class TestMyWebsite extends Unit
{
    #[Owner('John Doe')]
    public function testLabels()
    {
        // ...
    }
}

php

use Codeception\Test\Unit;
use Qameta\Allure\Allure;

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

Tag

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

Establece los tags de la prueba.

Attributes APIRuntime API

php

use Codeception\Test\Unit;
use Qameta\Allure\Attribute\Tag;

class TestMyWebsite extends Unit
{
    #[Tag('UI'), Tag('Labels')]
    public function testLabels()
    {
        // ...
    }
}

php

use Codeception\Test\Unit;
use Qameta\Allure\Allure;

class TestMyWebsite extends Unit
{
    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.

Attributes APIRuntime API

php

use Codeception\Test\Unit;
use Qameta\Allure\Attribute\Severity;

class TestMyWebsite extends Unit
{
    #[Severity(Severity::CRITICAL)]
    public function testLabels()
    {
        // ...
    }
}

php

use Codeception\Test\Unit;
use Qameta\Allure\Allure;
use Qameta\Allure\Model\Severity;

class TestMyWebsite extends Unit
{
    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 ampliar la API de Atributos definiendo tu propio atributo que funcione como un #[Label] con un $name predefinido.

Attributes APIAttributes API with a custom attributeRuntime API

php

use Codeception\Test\Unit;
use Qameta\Allure\Attribute\Label;

class TestMyWebsite extends Unit
{
    #[Label('MyCustomLabel', 'value')]
    public function testLabels()
    {
        // ...
    }
}

php

use Attribute;
use Codeception\Test\Unit;
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);
    }
}

class TestMyWebsite extends Unit
{
    #[MyCustomLabel('value')]
    public function testLabels()
    {
        // ...
    }
}

php

use Codeception\Test\Unit;
use Qameta\Allure\Allure;

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

ID

#[AllureId(string $value)]

Establece el ID de la prueba.

php

use Codeception\Test\Unit;
use Qameta\Allure\Attribute\AllureId;

class TestMyWebsite extends Unit
{
    #[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)

Agrega un enlace relacionado con la prueba.

Según el tipo, Allure intentará cargar un patrón de enlace correspondiente para procesar la URL, tal como se define en la opción de configuración linkTemplates. Si no se encuentra ningún patrón para el tipo dado, la URL se deja sin modificar.

Al usar la API en tiempo de ejecución, el tipo debe ser un valor de la enumeración LinkType. Al usar la API de atributos, el tipo puede ser cualquier cadena. Ambas API proporcionan abreviaciones para los tipos de enlace “issue” y “tms”.

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

Attributes APIRuntime API

php

use Codeception\Test\Unit;
use Qameta\Allure\Attribute\Issue;
use Qameta\Allure\Attribute\Link;
use Qameta\Allure\Attribute\TmsLink;

class TestMyWebsite extends Unit
{
    #[Link('My Website', 'https://example.com/')]
    #[Issue('UI-123')]
    #[TmsLink('TMS-456')]
    public function testLabels()
    {
        // ...
    }
}

php

use Codeception\Test\Unit;
use Qameta\Allure\Allure;

class TestMyWebsite extends Unit
{
    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 epic (épicos), feature (características) o user stories (historias de usuario) para una prueba, como parte de la jerarquía basada en el comportamiento de Allure.

Attributes APIRuntime API

php

use Codeception\Test\Unit;
use Qameta\Allure\Attribute\Epic;
use Qameta\Allure\Attribute\Feature;
use Qameta\Allure\Attribute\Story;

class TestMyWebsite extends Unit
{
    #[Epic('Web interface')]
    #[Feature('Essential features')]
    #[Story('Labels')]
    public function testLabels()
    {
        // ...
    }
}

php

use Codeception\Test\Unit;
use Qameta\Allure\Allure;

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

Jerarquía basada en suites

#[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.

Attributes APIRuntime API

php

use Codeception\Test\Unit;
use Qameta\Allure\Attribute\ParentSuite;
use Qameta\Allure\Attribute\SubSuite;
use Qameta\Allure\Attribute\Suite;

class TestMyWebsite extends Unit
{
    #[ParentSuite('Web interface')]
    #[Suite('Essential features')]
    #[SubSuite('Labels')]
    public function testLabels()
    {
        // ...
    }
}

php

use Codeception\Test\Unit;
use Qameta\Allure\Allure;

class TestMyWebsite extends Unit
{
    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.

Existen 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() usando la sintaxis de array (es decir, [$obj, 'method']). 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 (que por defecto es solo la palabra “step”), puedes:
- agregar el atributo #[DisplayName] al método,
- pasar el argumento opcional name 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 modificaciones, y no afectará el reporte. 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 (que por defecto es solo la palabra “step”), puedes:
- agregar el atributo #[DisplayName] a la función lambda,
- pasar el argumento opcional name a runStep(),
- usar el método name() en el objeto StepContextInterface.
Pasos no-op
Si llamas a addStep(), Allure añadirá al reporte un paso no-op. Esto permite un reporte estilo log dentro de una prueba o dentro de un paso mayor. Un paso no-op finaliza inmediatamente después de que comenzó y no puede tener sub-pasos ni parámetros.
El segundo argumento opcional indica el estado que se mostrará para el paso en el reporte. Los valores permitidos son: Status::passed() (el valor predeterminado), 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 el paso trabaja, por ejemplo, si lo ejecutas múltiples veces con diferentes datos. Para hacerlo, utiliza el método parameter() del objeto StepContextInterface.

Method-based stepsLambda stepsNo-op steps

php

use Codeception\Test\Unit;
use Qameta\Allure\Allure;
use Qameta\Allure\Attribute\DisplayName;
use Qameta\Allure\StepContextInterface;

class TestMyWebsite extends Unit
{
    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 Codeception\Test\Unit;
use Qameta\Allure\Allure;
use Qameta\Allure\StepContextInterface;

class TestMyWebsite extends Unit
{
    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 Codeception\Test\Unit;
use Qameta\Allure\Allure;

class TestMyWebsite extends Unit
{
    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)

Especifica un name y un value de un parámetro que se utilizó durante esta prueba. Consulta Pruebas parametrizadas para más detalles.

Ten en cuenta que Allure Codeception no extrae automáticamente los parámetros del DataProvider de Codeception. En una función de prueba que utiliza un proveedor de datos, pasa los nombres y valores a Allure::parameter() manualmente, como se muestra en el ejemplo a continuación.

Si el argumento excluded se establece en true, 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 reporte. 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 reporte de la prueba. Sin embargo, es posible extraer el valor del directorio allure_results si lo publicas.

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

Runtime APIDataProvider + Runtime API

php

use Codeception\Test\Unit;
use Qameta\Allure\Allure;

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

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

php

use Codeception\Attribute\DataProvider;
use Codeception\Test\Unit;
use Qameta\Allure\Allure;

class ParametersProviderTest extends Unit
{
    protected function dataProvider()
    {
        return [
            ['login' => 'johndoe', 'password' => 'qwerty'],
            ['login' => '[email protected]', 'password' => 'qwerty'],
        ];
    }

    #[DataProvider('dataProvider')]
    public function testAuthenticationWithData($login, $password)
    {
        Allure::parameter('Login', $login);
        Allure::parameter('Password', $password);
        // ...
    }
}

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)

Agrega 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 de un archivo real.

Para crear un archivo adjunto utilizando la API en tiempo de ejecución, llama a Allure::attachment() o Allure::attachmentFile() en cualquier punto durante tu prueba. Pasa ya sea el content o la path desde la cual 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 ello, 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á los datos en el reporte de la prueba, mientras que la extensión de archivo se adjuntará al nombre del archivo cuando el usuario quiera guardar el archivo.

Runtime API

php

use Codeception\Test\Unit;
use Qameta\Allure\Allure;

class TestMyWebsite extends Unit
{
    public function testLabels()
    {
        // ...
        Allure::attachment('data.txt', 'This is the file content.', 'text/plain');
        Allure::attachmentFile('data.txt', '/path/to/image.png', 'image/png');
    }
}

Referencia de Allure Codeception

Metadatos

Title

Description

Owner

Tag

Severity

Label

ID

Link

Jerarquía basada en el comportamiento

Jerarquía basada en suites

Pasos de prueba

Pruebas parametrizadas

Archivos adjuntos

Powered by

Únete a nuestro boletín

Allure TestOps

Compañía

Referencia de Allure Codeception ​

Metadatos ​

Title ​

Description ​

Owner ​

Tag ​

Severity ​

Label ​

ID ​

Link ​

Jerarquía basada en el comportamiento ​

Jerarquía basada en suites ​

Pasos de prueba ​

Pruebas parametrizadas ​

Archivos adjuntos ​

Powered by

Únete a nuestro boletín

Allure TestOps

Compañía

Referencia de Allure Codeception

Metadatos

Title

Description

Owner

Tag

Severity

Label

ID

Link

Jerarquía basada en el comportamiento

Jerarquía basada en suites

Pasos de prueba

Pruebas parametrizadas

Archivos adjuntos