Est-ce que quelqu'un sait s'il existe un assertou quelque chose comme ça qui peut tester si une exception a été levée dans le code testé?

<?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 () documentation PHPUnit

L'article de l'auteur PHPUnit fournit des explications détaillées sur les meilleures pratiques de test des exceptions.

Vous pouvez également utiliser une annotation docblock jusqu'à la sortie de PHPUnit 9:

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

Pour PHP 5.5+ (en particulier avec le code avec espace de noms), je préfère maintenant utiliser ::class

Si vous utilisez PHP 5.5+, vous pouvez utiliser la ::classrésolution pour obtenir le nom de la classe avec expectException/setExpectedException . Cela offre plusieurs avantages:

• Le nom sera pleinement qualifié avec son espace de noms (le cas échéant).
• Il se résout en un stringdonc il fonctionnera avec n'importe quelle version de PHPUnit.
• Vous obtenez la complétion de code dans votre IDE.
• Le compilateur PHP émettra une erreur si vous saisissez mal le nom de la classe.

Exemple:

namespace \My\Cool\Package;

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

PHP compile

WrongPasswordException::class

dans

"\My\Cool\Package\WrongPasswordException"

sans PHPUnit étant le plus sage.

Remarque : PHPUnit 5.2 a été introduit expectException en remplacement de setExpectedException.

Le code ci-dessous testera le message d'exception et le code d'exception.

Important: il échouera si l'exception attendue n'est pas levée également.

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());
}

Vous pouvez utiliser l' extension assertException pour affirmer plusieurs exceptions au cours d'une exécution de test.

Insérez la méthode dans votre TestCase et utilisez:

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

J'ai aussi fait un trait pour les amateurs de joli code ..

Une autre manière peut être la suivante:

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

Veuillez vous assurer que votre classe de test s'étend \PHPUnit_Framework_TestCase.

PHPUnit expectException méthode est très gênante car elle permet de tester une seule exception par méthode de test.

J'ai créé cette fonction d'aide pour affirmer que certaines fonctions lèvent une exception:

/**
 * 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');
}

Ajoutez-le à votre classe de test et appelez ainsi:

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

Solution complète

Les " meilleures pratiques " actuelles de PHPUnit pour les tests d'exception semblent .. terne ( docs ).

Comme je voulais plus que l' expectExceptionimplémentation actuelle , j'ai fait un trait à utiliser sur mes cas de test. Ce ne sont que ~ 50 lignes de code .

• Prend en charge plusieurs exceptions par test
• Prend en charge les assertions appelées après la levée de l'exception
• Exemples d'utilisation robustes et clairs
• assertSyntaxe standard
• Prend en charge les assertions pour plus qu'un simple message, code et classe
• Prend en charge l'assertion inverse, assertNotThrows
• Prend en charge les Throwableerreurs PHP 7

Bibliothèque

J'ai publié le AssertThrowstrait sur Github et packagist pour qu'il puisse être installé avec composer.

Exemple simple

Juste pour illustrer l'esprit derrière la syntaxe:

<?php

// Using simple callback
$this->assertThrows(MyException::class, [$obj, 'doSomethingBad']);

// Using anonymous function
$this->assertThrows(MyException::class, function() use ($obj) {
    $obj->doSomethingBad();
});

Génial?

Exemple d'utilisation complète

Veuillez voir ci-dessous pour un exemple d'utilisation plus complet:

<?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();
        });
    }
}

?>

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

}

Voici toutes les affirmations d'exception que vous pouvez faire. Notez que tous sont facultatifs .

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 documentation peut être trouvée ici .

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

Faites très attention "/**", notez le double "*". Écrire seulement "**" (astérisque) échouera votre code. Assurez-vous également que vous utilisez la dernière version de phpUnit. Dans certaines versions antérieures de phpunit, l'exception @expectedException n'est pas prise en charge. J'avais 4.0 et cela ne fonctionnait pas pour moi, j'ai dû mettre à jour vers 5.5 https://coderwall.com/p/mklvdw/install-phpunit-with-composer pour mettre à jour avec composer.

Pour PHPUnit 5.7.27 et PHP 5.6 et pour tester plusieurs exceptions dans un seul test, il était important de forcer le test d'exception. L'utilisation de la gestion des exceptions seule pour affirmer l'instance d'Exception sautera le test de la situation si aucune exception ne se produit.

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());

}

function yourfunction($a,$z){
   if($a<$z){ throw new <YOUR_EXCEPTION>; }
}

voici le test

class FunctionTest extends \PHPUnit_Framework_TestCase{

   public function testException(){

      $this->setExpectedException(<YOUR_EXCEPTION>::class);
      yourfunction(1,2);//add vars that cause the exception 

   }

}

PhpUnit est une bibliothèque incroyable, mais ce point spécifique est un peu frustrant. C'est pourquoi nous pouvons utiliser la bibliothèque open source turbotesting-php qui a une méthode d'assertion très pratique pour nous aider à tester les exceptions. On le trouve ici:

https://github.com/edertone/TurboTesting/blob/master/TurboTesting-Php/src/main/php/utils/AssertUtils.php

Et pour l'utiliser, nous ferions simplement ce qui suit:

AssertUtils::throwsException(function(){

    // Some code that must throw an exception here

}, '/expected error message/');

Si le code que nous tapons à l'intérieur de la fonction anonyme ne lève pas d'exception, une exception sera levée.

Si le code que nous tapons à l'intérieur de la fonction anonyme lève une exception, mais que son message ne correspond pas à l'expression rationnelle attendue, une exception sera également levée.