WebDriverListener.php

<?php declare(strict_types=1);

namespace Lmc\Steward\Listener;

use Facebook\WebDriver\Exception\UnknownServerException;
use Facebook\WebDriver\Exception\WebDriverException;
use Facebook\WebDriver\Remote\DesiredCapabilities;
use Facebook\WebDriver\Remote\WebDriverBrowserType;
use Lmc\Steward\ConfigProvider;
use Lmc\Steward\Selenium\CapabilitiesResolver;
use Lmc\Steward\Test\AbstractTestCase;
use Lmc\Steward\WebDriver\NullWebDriver;
use Lmc\Steward\WebDriver\RemoteWebDriver;
use Nette\Reflection\AnnotationsParser;
use PHPUnit\Framework\Test;
use PHPUnit\Framework\TestListener;
use PHPUnit\Framework\TestListenerDefaultImplementation;
use PHPUnit\Framework\WarningTestCase;
use PHPUnit\Runner\BaseTestRunner;

/**
 * Listener for initialization and destruction of WebDriver before and after each test.
 *
 * Note: This is done as a listener rather then in setUp() and tearDown(), as a workaround
 * for the sequence in which PHPUnit executes tearDown() of tests and addFailure() on listeners.
 * If taking screenshot using addFailure(), tearDown() would have already been called and the
 * browser would be closed.
 */
class WebDriverListener implements TestListener
{
    use TestListenerDefaultImplementation;

    protected const NO_BROWSER_ANNOTATION = 'noBrowser';

    /** @var ConfigProvider */
    protected $config;
    /** @var CapabilitiesResolver */
    protected $capabilitiesResolver;

    public function __construct()
    {
        $this->config = ConfigProvider::getInstance();
    }

    protected function getCapabilitiesResolver(): CapabilitiesResolver
    {
        if ($this->capabilitiesResolver === null) {
            $this->capabilitiesResolver = new CapabilitiesResolver($this->config);
        }

        return $this->capabilitiesResolver;
    }

    public function startTest(Test $test): void
    {
        if ($test instanceof WarningTestCase) {
            return;
        }

        if (!$test instanceof AbstractTestCase) {
            throw new \InvalidArgumentException('Test case must be descendant of Lmc\Steward\Test\AbstractTestCase');
        }

        if ($test->getStatus() === BaseTestRunner::STATUS_SKIPPED) {
            return;
        }

        // Initialize NullWebDriver if self::NO_BROWSER_ANNOTATION is used on testcase class or test method
        $testCaseAnnotations = AnnotationsParser::getAll(new \ReflectionClass($test));
        $testAnnotations = AnnotationsParser::getAll(new \ReflectionMethod($test, $test->getName(false)));

        if (isset($testCaseAnnotations[self::NO_BROWSER_ANNOTATION])
            || isset($testAnnotations[self::NO_BROWSER_ANNOTATION])
        ) {
            $test->wd = new NullWebDriver();
            $test->log(
                'Initializing Null WebDriver (@%s annotation used %s)',
                self::NO_BROWSER_ANNOTATION,
                isset($testCaseAnnotations[self::NO_BROWSER_ANNOTATION]) ? 'on class' : 'on method'
            );

            return;
        }

        // Initialize real WebDriver otherwise
        $test->log('Initializing "%s" WebDriver', $this->config->browserName);

        $desiredCapabilities = $this->getCapabilitiesResolver()->resolveDesiredCapabilities($test);
        $requiredCapabilities = $this->getCapabilitiesResolver()->resolveRequiredCapabilities($test);

        $this->createWebDriver(
            $test,
            $this->config->serverUrl,
            $desiredCapabilities,
            $requiredCapabilities,
            $connectTimeoutMs = 2 * 60 * 1000,
            // How long could request to Selenium take (eg. how long could we wait in hub's queue to available node)
            $requestTimeoutMs = 60 * 60 * 1000 // 1 hour (same as timeout for the whole process)
        );
    }

    public function endTest(Test $test, float $time): void
    {
        if ($test instanceof WarningTestCase) {
            return;
        }

        if (!$test instanceof AbstractTestCase) {
            throw new \InvalidArgumentException('Test case must be descendant of Lmc\Steward\Test\AbstractTestCase');
        }

        if ($test->wd instanceof RemoteWebDriver) {
            // The endTest() method of WebDriverListener is called before endTest() of ResultPrinter, so any output
            // from this listener would overtake output from the tests itself, what would be confusing. Instead of this,
            // we append them to the output of the test itself, to print them in proper chronological order.
            $test->appendTestLog(
                'Destroying "%s" WebDriver for session "%s"',
                ConfigProvider::getInstance()->browserName,
                $test->wd->getSessionID()
            );

            ob_start(); // Capture any output from commands bellow to make them appended to output of the test.
            try {
                // Workaround for PhantomJS 1.x - see https://github.com/detro/ghostdriver/issues/343
                // Should be removed with PhantomJS 2
                if (ConfigProvider::getInstance()->browserName === WebDriverBrowserType::PHANTOMJS) {
                    $test->wd->execute('deleteAllCookies');
                }

                $test->wd->close();
                $test->wd->quit();
            } catch (WebDriverException $e) {
                $test->warn('Error closing the session, browser may died.');
            } finally {
                $output = ob_get_clean();
                $test->appendFormattedTestLog($output);
            }
        }
    }

    /**
     * Subroutine to encapsulate creation of real WebDriver. Handles some exceptions that may occur etc.
     * The WebDriver instance is stored to $test->wd when created.
     *
     * @throws UnknownServerException
     */
    protected function createWebDriver(
        AbstractTestCase $test,
        string $remoteServerUrl,
        DesiredCapabilities $desiredCapabilities,
        DesiredCapabilities $requiredCapabilities,
        int $connectTimeoutMs,
        int $requestTimeoutMs
    ): void {
        $browserName = ConfigProvider::getInstance()->browserName;

        for ($startAttempts = 0; $startAttempts < 4; $startAttempts++) {
            try {
                $test->wd = RemoteWebDriver::create(
                    $remoteServerUrl,
                    $desiredCapabilities,
                    $connectTimeoutMs,
                    $requestTimeoutMs,
                    null,
                    null,
                    $requiredCapabilities
                );

                return;
            } catch (UnknownServerException $e) {
                if ($this->cannotBindToFirefoxLockingPort($browserName, $e->getMessage())) {
                    // As a consequence of Selenium issue #5172 (cannot change locking port), Firefox may on CI server
                    // collide with other FF instance. As a workaround, we try to start it again after a short delay.
                    $test->warn(
                        'Firefox locking port is occupied; beginning attempt #%d to start it ("%s")',
                        $startAttempts + 2,
                        $e->getMessage()
                    );
                    sleep(1);
                    continue;
                }

                if (mb_strpos($e->getMessage(), 'Error forwarding the new session') !== false) {
                    $test->warn('Cannot execute test on the node. Maybe you started just the hub and not the node?');
                }

                throw $e;
            } catch (WebDriverException $e) {
                if ($this->mayBeMissingFullServerUrl($remoteServerUrl, $e->getMessage())) {
                    $test->warn('Unable to initialize new WebDriver session.');
                    $test->warn(
                        'Server URL ("%s") appears to be missing "/wd/hub" part, so make sure you are ussing full URL'
                        . ' of the server (not just a hostname and port).',
                        $remoteServerUrl
                    );
                }

                throw $e;
            }
        }

        $test->warn('All %d attempts to instantiate Firefox WebDriver failed', $startAttempts + 1);
        throw $e;
    }

    private function cannotBindToFirefoxLockingPort(string $browserName, string $exceptionMessage): bool
    {
        return $browserName === 'firefox'
            && mb_strpos($exceptionMessage, 'Unable to bind to locking port') !== false;
    }

    private function mayBeMissingFullServerUrl(string $remoteServerUrl, string $exceptionMessage): bool
    {
        return mb_strpos($exceptionMessage, 'JSON decoding of remote response failed.') !== false
            && mb_strpos($remoteServerUrl, 'wd/hub') === false;
    }
}