php - remove - strip_tags wordpress

PHPUnit afirma que una excepción fue lanzada?

Question

¿Alguien sabe si hay una assert o algo similar que pueda probar si se lanzó una excepción en el código que se está probando?

Answer 1

Aquí están todas las afirmaciones de excepción que puedes hacer. Tenga en cuenta que todos ellos son opcionales .

class ExceptionTest extends PHPUnit_Framework_TestCase
{
    public function testException()
    {
        // make your exception assertions
        $this->expectException(InvalidArgumentException::class);
        // if you use namespaces:
        // $this->expectException(''/Namespace/MyExceptio‌​n'');
        $this->expectExceptionMessage(''message'');
        $this->expectExceptionMessageRegExp(''/essage$/'');
        $this->expectExceptionCode(123);
        // code that throws an exception
        throw new InvalidArgumentException(''message'', 123);
   }

   public function testAnotherException()
   {
        // repeat as needed
        $this->expectException(Exception::class);
        throw new Exception(''Oh no!'');
    }
}

La documentación se puede encontrar here .

Answer 2

El código a continuación probará el mensaje de excepción y el código de excepción.

Importante: fallará si no se lanza la excepción esperada.

try{
    $test->methodWhichWillThrowException();//if this method not throw exception it must be fail too.
    $this->fail("Expected exception 1162011 not thrown");
}catch(MySpecificException $e){ //Not catching a generic Exception or the fail function is also catched
    $this->assertEquals(1162011, $e->getCode());
    $this->assertEquals("Exception Message", $e->getMessage());
}

Answer 3

El método expectException es muy inconveniente porque permite probar solo una excepción por método de prueba.

He hecho esta función auxiliar para afirmar que alguna función lanza una excepción:

/**
 * Asserts that the given callback throws the given exception.
 *
 * @param string $expectClass The name of the expected exception class
 * @param callable $callback A callback which should throw the exception
 */
protected function assertException(string $expectClass, callable $callback)
{
    try {
        $callback();
    } catch (/Throwable $exception) {
        $this->assertInstanceOf($expectClass, $exception, ''An invalid exception was thrown'');
        return;
    }

    $this->fail(''No exception was thrown'');
}

Agrégalo a tu clase de prueba y llama de esta manera:

public function testSomething() {
    $this->assertException(/PDOException::class, function() {
        new /PDO(''bad:param'');
    });
    $this->assertException(/PDOException::class, function() {
        new /PDO(''foo:bar'');
    });
}

Answer 4

Las " mejores prácticas " actuales de PHPUnit para pruebas de excepciones son ... deslustradas.

• No soporta múltiples excepciones por prueba, o aseveraciones llamadas después de que se lanza la excepción
• La documentación carece de ejemplos sólidos o claros.
• Sintaxis no estándar y potencialmente confusa ("esperar" frente a "afirmar")
• Solo admite aserciones para mensaje, código y clase
• No inverso, como "expectNoException"

Abrí un problema de Github para PHPUnit y el responsable lo descartó de inmediato.

Como estoy totalmente en desacuerdo con la implementación actual de expectException , hice un rasgo para usar en mis casos de prueba.

Biblioteca

El rasgo AssertThrows se publica en Github y packagist para que pueda instalarse con el compositor.

Ejemplo simple

Solo para ilustrar el espíritu detrás de la sintaxis:

<?php

// Within your test case...
$this->assertThrows(MyException::class, function() use ($obj) {
    $obj->doSomethingBad();
});

¿Con buena pinta?

Ejemplo de uso completo

Aquí hay una clase de TestCase real que muestra un ejemplo de uso más completo:

<?php

declare(strict_types=1);

use Jchook/AssertThrows/AssertThrows;
use PHPUnit/Framework/TestCase;

// These are just for illustration
use MyNamespace/MyException;
use MyNamespace/MyObject;

final class MyTest extends TestCase
{
    use AssertThrows; // <--- adds the assertThrows method

    public function testMyObject()
    {
        $obj = new MyObject();

        // Test a basic exception is thrown
        $this->assertThrows(MyException::class, function() use ($obj) {
            $obj->doSomethingBad();
        });

        // Test custom aspects of a custom extension class
        $this->assertThrows(MyException::class, 
            function() use ($obj) {
                $obj->doSomethingBad();
            },
            function($exception) {
                $this->assertEquals(''Expected value'', $exception->getCustomThing());
                $this->assertEquals(123, $exception->getCode());
            }
        );

        // Test that a specific exception is NOT thrown
        $this->assertNotThrows(MyException::class, function() use ($obj) {
            $obj->doSomethingGood();
        });
    }
}

?>

Answer 5

Para PHPUnit 5.7.27 y PHP 5.6 y para probar múltiples excepciones en una prueba, fue importante forzar la prueba de excepción. El uso del manejo de excepciones solo para afirmar la instancia de Excepción omitirá probar la situación si no se produce una excepción.

public function testSomeFunction() {

    $e=null;
    $targetClassObj= new TargetClass();
    try {
        $targetClassObj->doSomething();
    } catch ( /Exception $e ) {
    }
    $this->assertInstanceOf(/Exception::class,$e);
    $this->assertEquals(''Some message'',$e->getMessage());

    $e=null;
    try {
        $targetClassObj->doSomethingElse();
    } catch ( Exception $e ) {
    }
    $this->assertInstanceOf(/Exception::class,$e);
    $this->assertEquals(''Another message'',$e->getMessage());

}

Answer 6

Puede usar la extensión assertException para hacer valer más de una excepción durante una ejecución de prueba.

Inserte el método en su TestCase y use:

public function testSomething()
{
    $test = function() {
        // some code that has to throw an exception
    };
    $this->assertException( $test, ''InvalidArgumentException'', 100, ''expected message'' );
}

También hice un trait para los amantes del código bonito ..

Answer 7

Si está ejecutando PHP 5.5+, puede usar ::class resolution para obtener el nombre de la clase con expectException/setExpectedException . Esto proporciona varios beneficios:

• El nombre estará completamente calificado con su espacio de nombres (si corresponde).
• Se resuelve en una string por lo que funcionará con cualquier versión de PHPUnit.
• Obtiene código completado en su IDE.
• El compilador de PHP emitirá un error si escribe mal el nombre de la clase.

Ejemplo:

namespace /My/Cool/Package;

class AuthTest extends /PHPUnit_Framework_TestCase
{
    public function testLoginFailsForWrongPassword()
    {
        $this->expectException(WrongPasswordException::class);
        Auth::login(''Bob'', ''wrong'');
    }
}

PHP compila

WrongPasswordException::class

dentro

"/My/Cool/Package/WrongPasswordException"

sin PHPUnit ser el más sabio

Nota : PHPUnit 5.2 introdujo expectException como un reemplazo para setExpectedException .

Answer 8

También puede utilizar una anotación docblock :

class ExceptionTest extends PHPUnit_Framework_TestCase
{
    /**
     * @expectedException InvalidArgumentException
     */
    public function testException()
    {
        ...
    }
}

Para PHP 5.5+ (especialmente con código de espacio de nombres), ahora prefiero usar ::class

Answer 9

Una forma alternativa puede ser la siguiente:

$this->expectException(/InvalidArgumentException::class);
$this->expectExceptionMessage(''Expected Exception Message'');

Asegúrese de que su clase de prueba /PHPUnit_Framework_TestCase .

Answer 10

<?php
require_once ''PHPUnit/Framework.php'';

class ExceptionTest extends PHPUnit_Framework_TestCase
{
    public function testException()
    {
        $this->expectException(InvalidArgumentException::class);
        // or for PHPUnit < 5.2
        // $this->setExpectedException(InvalidArgumentException::class);

        //...and then add your test code that generates the exception 
        exampleMethod($anInvalidArgument);
    }
}

expectException () PHPUnit documentación

El artículo del autor de PHPUnit proporciona una explicación detallada sobre las mejores prácticas de prueba de excepciones.

Answer 11

/**
 * @expectedException Exception
 * @expectedExceptionMessage Amount has to be bigger then 0!
 */
public function testDepositNegative()
{
    $this->account->deposit(-7);
}

Tenga mucho cuidado con "/**" , observe el doble "*". Escribir solo "**" (asterix) fallará su código. También asegúrese de que está utilizando la última versión de phpUnit. En algunas versiones anteriores de phpunit @expectedException, la excepción no es compatible. Tenía 4.0 y no me funcionó, tuve que actualizar a 5.5 https://coderwall.com/p/mklvdw/install-phpunit-with-composer para actualizar con composer.

Answer 12

public function testException() {
    try {
        $this->methodThatThrowsException();
        $this->fail("Expected Exception has not been raised.");
    } catch (Exception $ex) {
        $this->assertEquals($ex->getMessage(), "Exception message");
    }

}