Adakah yang tahu apakah ada assertatau sesuatu seperti itu yang dapat menguji apakah pengecualian dilemparkan ke dalam kode yang sedang diuji?

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

Artikel penulis PHPUnit memberikan penjelasan terperinci tentang pengujian pengecualian praktik terbaik.

Anda juga dapat menggunakan anotasi docblock hingga PHPUnit 9 dirilis:

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

Untuk PHP 5.5+ (terutama dengan kode namespaced), saya sekarang lebih suka menggunakan ::class

Jika Anda menggunakan PHP 5.5+, Anda bisa menggunakan ::classresolusi untuk mendapatkan nama kelas dengan expectException/setExpectedException . Ini memberikan beberapa manfaat:

• Nama akan sepenuhnya memenuhi syarat dengan namespace-nya (jika ada).
• Itu memutuskan untuk stringjadi itu akan bekerja dengan versi PHPUnit.
• Anda mendapatkan penyelesaian kode dalam IDE Anda.
• Kompiler PHP akan memunculkan kesalahan jika Anda salah ketik nama kelas.

Contoh:

namespace \My\Cool\Package;

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

Kompilasi PHP

WrongPasswordException::class

ke

"\My\Cool\Package\WrongPasswordException"

tanpa PHPUnit menjadi lebih bijak.

Catatan : PHPUnit 5.2 diperkenalkan expectException sebagai pengganti setExpectedException.

Kode di bawah ini akan menguji pesan pengecualian dan kode pengecualian.

Penting: Ini akan gagal jika pengecualian yang diharapkan tidak dibuang juga.

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

Anda dapat menggunakan ekstensi assertException untuk menegaskan lebih dari satu pengecualian selama satu pengujian dijalankan.

Masukkan metode ke dalam TestCase Anda dan gunakan:

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

Saya juga membuat sifat untuk pecinta kode yang bagus ..

Cara alternatif bisa sebagai berikut:

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

Harap pastikan bahwa kelas tes Anda meluas \PHPUnit_Framework_TestCase.

expectExceptionMetode PHPUnit sangat merepotkan karena memungkinkan untuk menguji hanya satu pengecualian per metode pengujian.

Saya telah membuat fungsi pembantu ini untuk menyatakan bahwa beberapa fungsi melempar pengecualian:

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

Tambahkan ke kelas tes Anda dan panggil seperti ini:

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

Solusi Komprehensif

" Praktik terbaik " PHPUnit saat ini untuk pengujian pengecualian tampaknya .. kurang bersemangat ( dokumen ).

Karena saya menginginkan lebih dari expectExceptionimplementasi saat ini , saya membuat sifat untuk digunakan pada kasus pengujian saya. Hanya ~ 50 baris kode .

• Mendukung banyak pengecualian per tes
• Mendukung pernyataan yang dipanggil setelah pengecualian dilemparkan
• Contoh penggunaan yang kuat dan jelas
• assertSintaks standar
• Mendukung pernyataan untuk lebih dari sekadar pesan, kode, dan kelas
• Mendukung pernyataan terbalik, assertNotThrows
• Mendukung Throwablekesalahan PHP 7

Perpustakaan

Saya menerbitkan AssertThrowssifat tersebut ke Github dan pembuat kemasan sehingga dapat diinstal dengan komposer.

Contoh sederhana

Hanya untuk menggambarkan semangat di balik sintaks:

<?php

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

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

Cukup rapi?

Contoh Penggunaan Lengkap

Silakan lihat di bawah untuk contoh penggunaan yang lebih komprehensif:

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

}

Berikut semua pernyataan pengecualian yang dapat Anda lakukan. Perhatikan bahwa semuanya adalah opsional .

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

Dokumentasi dapat ditemukan di sini .

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

Berhati-hatilah "/**", perhatikan ganda "*". Hanya menulis "**" (asterix) yang akan gagal kode Anda. Pastikan juga Anda menggunakan versi terakhir phpUnit. Dalam beberapa versi sebelumnya, phpunit @expectedException Exception tidak didukung. Saya memiliki 4.0 dan tidak berfungsi untuk saya, saya harus memperbarui ke 5.5 https://coderwall.com/p/mklvdw/install-phpunit-with-composer untuk memperbarui dengan komposer.

Untuk PHPUnit 5.7.27 dan PHP 5.6 dan untuk menguji beberapa pengecualian dalam satu pengujian, penting untuk memaksa pengujian pengecualian. Menggunakan penanganan pengecualian saja untuk menegaskan instance Exception akan melewatkan pengujian situasi jika tidak ada pengecualian yang terjadi.

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

ini tesnya

class FunctionTest extends \PHPUnit_Framework_TestCase{

   public function testException(){

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

   }

}

PhpUnit adalah perpustakaan yang luar biasa, tetapi poin khusus ini agak membuat frustrasi. Inilah sebabnya kami dapat menggunakan pustaka opensource php-turbotesting yang memiliki metode pernyataan yang sangat nyaman untuk membantu kami menguji pengecualian. Itu ditemukan di sini:

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

Dan untuk menggunakannya, kita cukup melakukan hal berikut:

AssertUtils::throwsException(function(){

    // Some code that must throw an exception here

}, '/expected error message/');

Jika kode yang kita ketikkan di dalam fungsi anonim tidak memunculkan eksepsi, eksepsi akan dilempar.

Jika kode yang kita ketikkan di dalam fungsi anonim melempar pengecualian, tetapi pesannya tidak cocok dengan regexp yang diharapkan, pengecualian juga akan dibuang.