[m6w6/seekat] / tests / bootstrap.php

<?php

require_once __DIR__."/../vendor/autoload.php";

function headers() : array {
        static $headers;

        if (!isset($headers)) {
                if (($token = getenv("GITHUB_TOKEN"))) {
                        $headers["Authorization"] = "token $token";
                } elseif (function_exists("posix_isatty") && defined("STDIN") && posix_isatty(STDIN)) {
                        fprintf(STDOUT, "GITHUB_TOKEN is not set in the environment, enter Y to continue without: ");
                        fflush(STDOUT);
                        if (strncasecmp(fgets(STDIN), "Y", 1)) {
                                exit;
                        }
                        $headers = [];
                } else {
                        throw new Exception("GITHUB_TOKEN is not set in the environment");
                }
        }

        return $headers;
}

function logger() : \Monolog\Logger {
        static $logger;

        if (!isset($logger)) {
                $logger = new \Monolog\Logger(
                        "test",
                        [
                                new \Monolog\Handler\FingersCrossedHandler(
                                        new \Monolog\Handler\StreamHandler(STDERR),
                                        \Monolog\Logger::EMERGENCY
                                )
                        ]
                );
        }

        return $logger;
}

class BaseTest extends \PHPUnit\Framework\TestCase
{
        function provideAPI() {
                $headers = headers();
                $logger = logger();

                return [
                        "using ReactPHP" => [new \seekat\API(\seekat\API\Future\react(), $headers, logger: $logger)],
                        "using AmPHP"   => [new \seekat\API(\seekat\API\Future\amp(), $headers, logger: $logger)],
                ];
        }
}

trait ConsumePromise
{
        function consumePromise($p, &$errors, &$results) {
                if (method_exists($p, "done")) {
                        $p->then(function($result) use(&$results) {
                                if (isset($result)) {
                                        $results[] = $result;
                                }
                        }, function($error) use (&$errors) {
                                if (isset($error)) {
                                        $errors[] = $error;
                                }
                        });
                } else {
                        $p->onResolve(function($error, $result) use(&$errors, &$results) {
                                if (isset($error)) {
                                        $errors[] = $error;
                                }
                                if (isset($result)) {
                                        $results[] = $result;
                                }
                        });
                }
        }
}

trait AssertSuccess
{
        function assertAllSuccess(array $apis, ...$args) {
                foreach ($apis as $api) {
                        $this->consumePromise($api->get(...$args), $errors, $results);
                }
                $api->send();
                $this->assertEmpty($errors, "errors");
                $this->assertNotEmpty($results, "results");
                return $results;
        }

        function assertSuccess(seekat\API $api, ...$args) {
                $this->consumePromise($api->get(...$args), $errors, $results);
                $api->send();
                $this->assertEmpty($errors, "errors");
                $this->assertNotEmpty($results, "results");
                return $results[0];
        }
}

trait AssertCancelled
{
        function assertCancelled($promise) {
                $this->consumePromise($promise, $errors, $results);

                $this->assertEmpty($results);
                $this->assertStringMatchesFormat("%SCancelled%S", \seekat\Exception\message($errors[0]));
        }
}

trait AssertFailure
{
        function assertFailure(seekat\API $api, ...$args) {
                $this->consumePromise($api->get(...$args), $errors, $results);
                $api->send();
                $this->assertNotEmpty($errors, "errors");
                $this->assertEmpty($results, "results");
                return $errors[0];
        }
}

class CombinedTestdoxPrinter extends PHPUnit\TextUI\DefaultResultPrinter
{
        function isTestClass(PHPUnit\Framework\TestSuite $suite) {
                $suiteName = $suite->getName();
                return false === strpos($suiteName, "::")
                        && substr($suiteName, -4) === "Test";
        }

        function startTestSuite(PHPUnit\Framework\TestSuite $suite) : void {
                if ($this->isTestClass($suite)) {
                        $this->column = 0;
                }

                parent::startTestSuite($suite);
        }

        function endTestSuite(PHPUnit\Framework\TestSuite $suite) : void {
                /* print % progress */
                if ($this->isTestClass($suite)) {
                        if ($this->numTestsRun != $this->numTests) {
                                $colWidth = $this->maxColumn - $this->column;
                                $this->column = $this->maxColumn - 1;

                                --$this->numTestsRun;
                                $this->writeProgress(str_repeat(" ", $colWidth));
                        } else {
                                $this->writeNewLine();
                        }
                }

                parent::endTestSuite($suite);
        }
}

class TestdoxListener implements PHPUnit\Framework\TestListener
{
        private $groups;
        private $testdox;

        function __construct() {
                $this->testdox = new PHPUnit\Util\TestDox\TextResultPrinter("php://stdout", ["testdox"]);
                $this->groups = new ReflectionProperty("\PHPUnit\Util\TestDox\ResultPrinter", "groups");
                $this->groups->setAccessible(true);
        }

        function startTest(PHPUnit\Framework\Test $test) : void {
                /* always show test class, even if no testdox test */
                if ($test instanceof \PHPUnit\Framework\TestCase) {
                        if ($test->getGroups() == ["default"]) {
                                $this->groups->setValue($this->testdox, ["default"]);
                        }
                }

                $this->testdox->startTest($test);
                $this->groups->setValue($this->testdox, ["testdox"]);
        }

        public function addError(\PHPUnit\Framework\Test $test, Throwable $t, float $time): void
        {
                $this->testdox->addError($test, $t, $time);
        }

        public function addWarning(\PHPUnit\Framework\Test $test, \PHPUnit\Framework\Warning $e, float $time): void
        {
                $this->testdox->addWarning($test, $e, $time);
        }

        public function addFailure(\PHPUnit\Framework\Test $test, \PHPUnit\Framework\AssertionFailedError $e, float $time): void
        {
                $this->testdox->addFailure($test, $e, $time);
        }

        public function addIncompleteTest(\PHPUnit\Framework\Test $test, Throwable $t, float $time): void
        {
                $this->testdox->addIncompleteTest($test, $t, $time);
        }

        public function addRiskyTest(\PHPUnit\Framework\Test $test, Throwable $t, float $time): void
        {
                $this->testdox->addRiskyTest($test, $t, $time);
        }

        public function addSkippedTest(\PHPUnit\Framework\Test $test, Throwable $t, float $time): void
        {
                $this->testdox->addSkippedTest($test, $t, $time);
        }

        public function startTestSuite(\PHPUnit\Framework\TestSuite $suite): void
        {
                $this->testdox->startTestSuite($suite);
        }

        public function endTestSuite(\PHPUnit\Framework\TestSuite $suite): void
        {
                $this->testdox->endTestSuite($suite);
        }

        public function endTest(\PHPUnit\Framework\Test $test, float $time): void
        {
                $this->testdox->endTest($test, $time);
        }
}

class DebugLogListener implements \PHPUnit\Framework\TestListener
{
        use \PHPUnit\Framework\TestListenerDefaultImplementation;

        private $printLog = false;

        function endTest(PHPUnit\Framework\Test $test, float $time) : void {
                /* @var $handler \Monolog\Handler\FingersCrossedHandler */
                $handler = logger()->getHandlers()[0];
                if ($this->printLog) {
                        $this->printLog = false;
                        $handler->activate();
                } else {
                        $handler->clear();
                }
        }

        function addError(PHPUnit\Framework\Test $test, \Throwable $e, float $time) : void {
                $this->printLog = true;
        }

        function addFailure(PHPUnit\Framework\Test $test, PHPUnit\Framework\AssertionFailedError $e, float $time) : void {
                $this->printLog = true;
        }

}