assert throws

cspray/assert-lanzamientos

Proporciona una forma alternativa de probar código que genera excepciones usando PHPUnit 10 u 11. El beneficio principal es el acceso a la excepción lanzada para una inspección más detallada. Esto puede resultar útil cuando necesite verificar los detalles de una excepción que no está disponible en PHPUnit. El siguiente ejemplo actúa como un inicio rápido; para obtener más detalles, consulte la guía detallada a continuación.

 <?php declare (strict_types= 1 );

use Cspray  AssertThrows  ThrowableAssert ;
use PHPUnit  Framework  TestCase ;

final class MyTest extends TestCase {
    public function testExceptionPreviousInstanceOf () : void {
        $ throwable = ThrowableAssert:: assertThrows (
            static fn () => throw new RuntimeException (previous: new BadMethodCallException ())
        );
        
        self :: assertInstanceOf (BadMethodCallException::class, $ throwable -> getPrevious ());
    }
}

Instalación

Composer es el único método admitido para instalar este paquete.

composer require --dev cspray/assert-throws

Guía detallada

PHPUnit proporciona una forma razonable de probar las excepciones esperadas de forma inmediata. Para la mayoría de situaciones, los métodos proporcionados por PHPUnit deberían ser suficientes. Sin embargo, hay escenarios en los que es posible que necesites probar el código de lanzamiento de excepciones de una manera que no está disponible en PHPUnit. Ejemplos de esto incluyen código en el que desea probar la excepción anterior o si la excepción incluye información específica del dominio. Es en estas situaciones que esta biblioteca es más apropiada.

Todas las afirmaciones proporcionadas por esta biblioteca toman un elemento invocable que se espera que genere una excepción. Si no se genera una excepción, se generará PHPUnitFrameworkExpectationFailedException lo que provocará un error en la prueba. De lo contrario, la excepción lanzada se devolverá para afirmaciones adicionales.

Los siguientes métodos estáticos están disponibles en la clase CsprayAssertThrowsThrowableAssert :

 <?php

use  Cspray  AssertThrows  ThrowableAssert ;

$ throwable = ThrowableAssert:: assertThrows ( static fn () => throw new RuntimeException ());

$ throwable = ThrowableAssert:: assertThrowsExceptionType (
    static fn () => throw new BadMethodCallException (),
    BadMethodCallException::class
);

$ throwable = ThrowableAssert:: assertThrowsExceptionTypeWithMessage (
    static fn () => throw new RuntimeException ( ' My exception message ' ),
    RuntimeException::class,
    ' My exception message '
);

Además de la clase ThrowableAssert con métodos estáticos, hay funciones globales disponibles:

 <?php

use function Cspray  AssertThrows  assertThrows ;
use function Cspray  AssertThrows  assertThrowsExceptionType ;
use function Cspray  AssertThrows  assertThrowsExceptionTypeWithMessage ;

$ throwable = assertThrows ( static fn () => throw new RuntimeException ());

$ throwable = assertThrowsExceptionType (
    static fn () => throw new BadMethodCallException (),
    BadMethodCallException::class
);

$ throwable = assertThrowsExceptionTypeWithMessage (
    static fn () => throw new RuntimeException ( ' My exception message ' ),
    RuntimeException::class,
    ' My exception message '
);

Además de un rasgo para usar en sus implementaciones PHPUnitFrameworkTestCase :

 <?php

use Cspray  AssertThrows  ThrowableAssertTestCaseMethods ;
use PHPUnit  Framework  TestCase ;

class MyTestCase extends TestCase {
    use ThrowableAssertTestCaseMethods;
    
    public function testAssertThrows () : void {
        $ throwable = self :: assertThrows ( static fn () => new RuntimeException ());
    }
    
    public function testAssertThrowsExceptionType () : void {
        $ throwable = self :: assertThrowsExceptionType (
            static fn () => throw new BadMethodCallException (),
            BadMethodCallException::class
        );
    }
    
    public function testAssertThrowsExceptionTypeWithMessage () : void {
        $ throwable = self :: assertThrowsExceptionTypeWithMessage (
            static fn () => throw new RuntimeException ( ' My exception message ' ),
            RuntimeException::class,
            ' My exception message '
        );
    }
}

El método que utilice es una preferencia personal. En última instancia, todos los ejemplos utilizan los métodos estáticos disponibles en la clase ThrowableAssert .