Failed asserting that exception of type "PHPUnit\Framework\Error\Deprecated" is thrown.

The code in the test is as follows:

$this->expectDeprecation();

and the code that should be tested is like this:

\trigger_error('foo', \E_USER_DEPRECATED);

However PHPUnit does not convert the deprecation to a testable error.
By default PHPUnit converts only errors, warnings and notices but not deprecations as we can read here:
https://phpunit.readthedocs.io/en/9.5/writing-tests-for-phpunit.html#testing-php-errors-warnings-and-notices

So we have to tell PHPUnit to convert also deprecations to exceptions and we do this in the phpunit.xml.dist by setting the attribute

convertDeprecationsToExceptions="true"

in the root element.

Now the test should work and deprecations are handled as exceptions.

To disable them you can set the ENV var
SYMFONY_DEPRECATIONS_HELPER=disabled
and the warnings will not be displayed anymore and CI/CD will pass again.
Update from comments:
SYMFONY_DEPRECATIONS_HELPER=weak does also work and will still show the deprecation warnings count. (Thx Max)

This was introduced a while ago with this PullRequest and works for symfony >= 3.1.

So for running the tests manually, do like this:

SYMFONY_DEPRECATIONS_HELPER=disabled vendor/bin/phpunit

Or add it to the phpunit.xml

<php>
    <ini name="error_reporting" value="-1" />
    <env name="KERNEL_CLASS" value="App\Kernel" />
    ...
    <env name="SYMFONY_DEPRECATIONS_HELPER" value="disabled" />
</php>

With bitbucket pipelines it looks like this:

pipelines:
   branches:
     master:
       - step:
           script:
             - curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer
             - composer install
             - SYMFONY_DEPRECATIONS_HELPER=disabled composer test
             - composer check-style

Then you need to mock the API and deliever responses from fixtures.
Though there is this term of “Don’t mock what you don’t own” we will mock the API because we dont own it. :)

https://github.com/julienfalque/http-mock is a nice library which helps a lot when mocking an API.
And when your client is using Guzzle there is also a Guzzle handler for HttpMock that makes integration easy.

How does this work?

See below but with caution: its pseudo code but you get the idea dont you? :)

1. lets create a HttpMock Server object through a Factory
and define the endpoints and assign the fixture.

<?php

namespace Nerdpress\Tests;

use GuzzleHttp\Psr7\Response;
use Jfalque\HttpMock\Server;

class HttpMockFactory
{
    public static function create(): Server
    {
        $server = (new Server())->whenUri('http://mock.api/action/ding')
                                ->andWhenMethod('POST')
                                ->return($foo = new Response(200, [],
                                    file_get_contents(__DIR__.'/fixtures/DingResponse.xml')))
                                ->end();

        return $server;
    }
}

2. lets create a mock Guzzle client that takes the HttpMock server and delegates the requests.

<?php

namespace Nerdpress\Tests;

use GuzzleHttp\Client;
use GuzzleHttp\ClientInterface;
use GuzzleHttp\Middleware;
use Jfalque\HttpMock\Guzzle\HttpMockHandler;
use Jfalque\HttpMock\Server;
use Psr\Http\Message\RequestInterface;

class HttpClientMock implements ClientInterface
{
    /**
     * @var Server
     */
    protected $server;
    /**
     * @var \GuzzleHttp\Client
     */
    protected $delegate;
    /**
     * The set of requests that have been sent through the client.
     *
     * @var \Psr\Http\Message\RequestInterface[]
     */
    protected $requestHistory = [];

    /**
     * HttpClientMock constructor.
     * @param Server $server
     * @param array $options
     */
    public function __construct(Server $server, array $options = [])
    {
        $this->initialize($server, $options);
    }

    /**
     * {@inheritDoc}
     */
    public function send(RequestInterface $request, array $options = [])
    {
        return $this->delegate->send($request, $options);
    }

    /**
     * {@inheritDoc}
     */
    public function sendAsync(RequestInterface $request, array $options = [])
    {
        return $this->delegate->sendAsync($request, $options);
    }

    /**
     * {@inheritDoc}
     */
    public function request($method, $uri, array $options = [])
    {
        return $this->delegate->request($method, $uri, $options);
    }

    /**
     * {@inheritDoc}
     */
    public function requestAsync($method, $uri, array $options = [])
    {
        return $this->delegate->requestAsync($method, $uri, $options);
    }

    /**
     * {@inheritDoc}
     */
    public function getConfig($option = null)
    {
        return $this->delegate->getConfig($option);
    }

    /**
     * @return RequestInterface[]
     */
    public function getRequestHistory(): array
    {
        return $this->requestHistory;
    }

    /**
     * @param Server $server
     * @param array $options
     */
    private function initialize(Server $server, array $options)
    {
        $this->requestHistory = [];
        $history              = Middleware::history($this->requestHistory);
        $stack                = HttpMockHandler::createStack($server);
        $stack->push($history);
        $client         = new Client(array_merge($options, [
            'handler' => $stack,
        ]));
        $this->delegate = $client;
    }
}

3. lets say we use symfony and create services for the mocks

services:
  Nerdpress\Tests\HttpMockFactory:
  Nerdpress\Tests\HttpClientMock:
    arguments: ["@=service('Nerdpress\\\\Tests\\\\HttpMockFactory').create()", base_uri: 'http://mock.api']

my_bundle:
  client: 'Nerdpress\Tests\HttpClientMock'

4. lets write a test and use the client and work on the returned fixtures

<?php

namespace Nerdpress\Tests;

use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;

class RequestTest extends WebTestCase
{

    protected function setUp()
    {
        parent::setUp();
        static::createClient();
    }

    public function testRequest()
    {
        $container     = static::$kernel->getContainer();

        $request = $container->get('my_bundle.request.with.client');

        $payload = ['testo' => 'bert'];
        $response = $request->send($payload);

        //hey lets have a look at the request
        $reqs = $container->get('Nerdpress\Tests\HttpClientMockt')->getRequestHistory();
        $sendedRequest = $reqs[0]['request']->getBody()->__toString();

        $this->assertEquals($sendedRequest, '<req><action type="testo">bert</action></req>');
        $this->assertEquals('you got pinged', $response->getData());
    }
}

Happy Testing :)

Was ist PTI? PTI ist ein Plugin für Eclipse PDT (zumeist), das folgende Tools in Eclipse integriert:

* PHP_CodeSniffer
* PHPUnit
* PHP Depend
* PHP Copy/Paste Detector

Das sind meines Erachtens alles eher Tools die auf den CI Server gehören, aber ist doch irgendwie praktisch die direkt in Eclipse zu haben.
Falls man mal was sichten oder direkt checken will.
Für mich der Hauptvorteil ist wohl, dass man die Tools ohne viel Aufwand zu Verfügung gestellt kriegt.
Ich hätte mir wohl sonst nie phpdepend oder phpcpd installiert und benutzt.

… und auch prompt über phpdepend, als netter Seiteneffekt, ein Syntax Fehler gefunden :).

Dafür braucht man noch den PHP Client für die Selenium Remote Control.

pear install Testing_Selenium-0.4.3

Bei mir auf Debian Lenny, bzw. Mac OSX musste ich noch den include_path dafür anpassen,
damit phpunit Testing/Selenium.php gefunden hat.

Damit kann man mit PHP komfortabel einen Selenium Test Server über die Selenium RC ansprechen,
der dann beliebige Browser für functional Tests benutzt.

Der Selenium Server ist auch im Prinzip schnell installiert
und lokal ist das ganze einigermaßen unproblematisch, weil man ja schon mal die Browser seines OS zur Verfügung hat.

In einem Continuous Integration Setup möchte man aber vielleicht Selenium lieber auf einem Web Server laufen lassen.

Da sieht es dann erstmal weniger gut aus mit Browser executables.
Was also tun?

Eine Möglichkeit ist saucelabs.com.
Die bieten “Cross browser testing with Selenium in the cloud” an.
Sogar gratis für Firefox unter Linux.
Für die anderen Browser und OS muss man dann schon auf einen bezahlten Account umsteigen.

Dann einfach den saucelabs Selenium Server mit oben erwähnter Extension aus PHPUnit ansprechen:

Das Example.php Script von saucelabs

require_once 'Testing/Selenium.php';
require_once 'PHPUnit/Framework/TestCase.php';

class Example extends PHPUnit_Framework_TestCase
{
    private $selenium;

    public function setUp()
    {
        $this->selenium = new Testing_Selenium(
            json_encode(array(
                "username" => "YOUR_USERNAME",
                "access-key" => "YOUR_ACCESS_KEY",
                "os" => "Windows 2003", 
                "browser" => "firefox",
                "browser-version" => "3.6.",
                "name" => $this->getName()
            )),
            "http://saucelabs.com", 
            "ondemand.saucelabs.com",
            80,
            90000);
        $this->selenium->start();
    }

    public function tearDown()
    {
        $this->selenium->stop();
    }

    public function testSauce()
    {
        $this->selenium->open("/");
        $this->assertEquals("Cross browser testing with Selenium - Sauce Labs",
                            $this->selenium->getTitle());
    }

}

und PHPUnit macht Selenium Tests:

phpunit Example.php

:)