Deprecate expect*() methods that have been removed in PHPUnit 10

[sebastianbergmann]

• expectDeprecation(), expectDeprecationMessage(), and expectDeprecationMessageMatches()
• expectError(), expectErrorMessage(), and expectErrorMessageMatches()
• expectNotice(), expectNoticeMessage(), and expectNoticeMessageMatches()
• expectWarning(), expectWarningMessage(), and expectWarningMessageMatches()

[jrfnl]

Just wondering where I can find information on what this will be replaced with ?

[sebastianbergmann]

There are no replacements. PHPUnit 10 no longer converts E_* to exceptions, therefore E_* can no longer be expected.

[InvisibleSmiley]

The situation is quite confusing right now since version 9.5's expectException suggests to switch to these methods...

[thbley]

@jrfnl I changed my test code like this:

    public function testSendEmailFailure(): void
    {
        set_error_handler(static function (int $errno, string $errstr): never {
            throw new Exception($errstr, $errno);
        }, E_USER_WARNING);

        // phpunit 9.5
        //$this->expectWarning();
        //$this->expectWarningMessage('failed to send');

        // phpunit 10.0
        $this->expectExceptionMessage('failed to send');

        // run some code that produces E_USER_WARNING

        restore_error_handler();
    }

[jrfnl]

@thbley Thanks. I think it's good to have such an example in this thread.
It won't help the usecase I was trying to solve, but that's another matter.

[alexpott]

@sebastianbergmann what is the recommended way of testing that an error is triggered in PHPUnit 10? If you want to assert that an E_USER_WARNING is thrown by your code what is the best way to do this? Should you replace the error handler as above or is there a better way?

[anton-vlasenko]

I just want to comment on the proposed solution above:
In my tests,

restore_error_handler();

is never executed because the exception gets thrown before it.
restore_error_handler() has to be called in the custom error handler instead:

public function test_foo() {
    set_error_handler(
        static function ( $errno, $errstr ) {
            restore_error_handler();
            throw new Exception( $errstr, $errno );
        },
        E_ALL
    );
    
    $this->expectException( Exception::class );
    $this->expectExceptionMessageMatches( 'Expected message' );
    
    // run some code that produces E_USER_WARNING
}

[epitre]

In my case, I did this :

    public function setUp(): void
    {
        set_error_handler(
            static function ( $errno, $errstr ) {
                throw new \Exception( $errstr, $errno );
            },
            E_ALL
        );
    }

    public function tearDown(): void
    {
        restore_error_handler();
    }

and then, in each test :

$this->expectException(MyException::class);

[BafS]

Be careful to reset the handler, as @thbley ans @epitre did, some examples don't do it.

It's really unfortunate to have no information about why it got removed and no official explanation about how to upgrade, the upgrade path to v10 is really complex for big codebases.

[jrfnl]

@BafS You can find an explanation about the why in the Release announcement: https://phpunit.de/announcements/phpunit-10.html

[BafS]

@jrfnl thank for the link, great to have something official, I didn't see it mentioned before

[nmeri17]

@sebastianbergmann what is the recommended way of testing that an error is triggered in PHPUnit 10? If you want to assert that an E_USER_WARNING is thrown by your code what is the best way to do this? Should you replace the error handler as above or is there a better way?

I don't understand why he is uncharacteristically mute and unresponsive to suddenly unplugging a widely used method with neither explanation nor an alternative. If I'm expecting a warning, odds are that that is the subject of the test. The example in the version 10 release notes show further assertion that testSomething returns a value. What is the recommended way for the library developer to verify a code block warns its consumer when certain action is performed? Disabling the action altogether is directly antithetical to my original intention. But this is just a powerless rant since feature is removed already, sadly. I expect the thread to be locked soon

[sebastianbergmann]

What is the recommended way for the library developer to verify a code block warns its consumer when certain action is performed?

This is a use case that I do not consider worth supporting. I understand that this is frustrating, and I am sorry for that.

[nmeri17]

This is a use case that I do not consider worth supporting. I understand that this is frustrating, and I am sorry for that.

I guess in my case, the deliberate warning can be relocated to a mockable method. It's a workaround like trying to test register shutdown function. In this case, however, I'm not sure it's possible for all object types and SUTs

[davisngl]

@BafS You can find an explanation about the why in the Release announcement: https://phpunit.de/announcements/phpunit-10.html

There's, unfortunately, no details on what should be the alternative way of testing these things that we would've tested with expect* methods.

[gustavo-olegario-lawnstarter]

If you want to keep a similar implementation but also looking for moving on with PHPUnit updates, you can implement this method in your common test class:

protected function assertThrowableMessage(
    string $message,
    callable $callback,
    ...$args
): void
{
    try {
        $callback(...$args);
    } catch (Throwable $e) {
        $this->assertEquals($message, $e->getMessage());
    }
}

This way you can assert the exception was properly thrown during runtime and don't have to deal with the set_error_handler madness.

[davisngl]

If you want to keep a similar implementation but also looking for moving on with PHPUnit updates, you can implement this method in your common test class:

protected function assertThrowableMessage(
    string $message,
    callable $callback,
    ...$args
): void
{
    try {
        $callback(...$args);
    } catch (Throwable $e) {
        $this->assertEquals($message, $e->getMessage());
    }
}

This way you can assert the exception was properly thrown during runtime and don't have to deal with the set_error_handler madness.

Thank you!
I am just not sure why would their users have to implement something that we use a lot when testing for exceptions.
The reasoning isn't even there, no answer in sight.

[Sopamo]

Just want to add, that for folk who come from google and are using Laravel, you can use the assertThrows method that Laravel provides:

$this->assertThrows(function () use ($news) {
    // Code that should throw
});

There is also an optional second parameter which accepts the class name of the throwable that should get thrown and a third with the error message you expect.

[alexeyp0708]

I always use this approach and don’t have to dance with a tambourine (calling Exception);

$check=false;

set_error_handler(funciton(...$args)use(&$check){
// your code
$check=true;
// your code
},E_NOTICE);
// trigger error your code
restore_error_handler();
unset($check):

$this->assertTrue($check);

You can write your own solution

trait MyAssertionsTrait
{
    /**
     * Will return TRUE if an observed error was thrown, FALSE if there are generated other errors or no errors  , and will throw an error if other errors are observed
     * @param\Closure $call Runs a closure with a code that needs to be checked for an error. If the error is an exception, then the variable $this will be defined in the closure. Checking for $this - isset($this)
     * @param string|\Closure $eql If a line, then checks whether this substring is present at the beginning of the error message.
     * If there is a closure, then the error checking code must be specified in the closure. If the test is successful, the closure should return true.
     * @param int|\Error $level
     */
    public static function isError($call, $eql, $level = E_ALL): bool
    {
        $err_level=is_int($level)?$level:E_ALL;
        $exc_level=is_string($level)?$level:\Error::class;
        if (is_string($eql)) {
            $substr = $eql;
            $eql = function (...$args) use ($substr) {
                if (substr($args[1], 0, strlen($substr)) === $substr) {
                    return true;
                }
                return false;
            };
        }
        $check = false;
        $bef_hand = null;
        $is_caught_error=false;
        $bef_hand = set_error_handler(function (...$args) use (&$bef_hand, &$check, $eql,&$is_caught_error) {
            $is_caught_error=true;
            if (true===$eql(...$args)) {
                // Expected error
                $check = true;
                return true;
            } else if ($bef_hand !== null) {
                //We pass other errors to the previous error handler
                return $bef_hand(...$args);
            }
            return false;
        }, $err_level);
        try{
            $call();
        }catch(\Error $e){
            if(!($e instanceof $exc_level)){
                throw $e;
            }
            $eql=$eql->bindTo($e);
            $code=$e->getCode();
            if(empty($code)){
                $code=E_ERROR;
            }
            if(!$is_caught_error && true===$eql($code,$e->getMessage(),$e->getFile(),$e->getLine())){
                $check=true;
            }
        } finally {
            restore_error_handler();
            return $check;
        }
    }
}    

https://github.com/alexeyp0708/php_phpunit_helpers/blob/master/src/Assertions/AdditionalAssertionsTrait.php

MyAssertionsTrait::isError(); or self::isError() , If you have added a trait to your test class.

$this->assertTrue(self::isError(fn()=>trigger_error('Ops!');,'Ops!',E_USER_NOTICE));

Examples :
https://github.com/alexeyp0708/php_phpunit_helpers/blob/master/tests/Assertions/AdditionalAssertionsTest.php

For the beauty of the design code, you can do this

use MyAssertionsTrait as Assert;
//....
$this->assertTrue(Assert::isError(....));
//...

In any case, you will have to have your own (or shared) repository with assistants to improve testing. In this repository you can collect all the necessary libraries for testing.