ParaTest\Runners\PHPUnit\ExecutableTest

Complexity

Total Complexity

31

Size/Duplication

Total Lines	352
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

84.71%

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
	getTestCount()	0	1	?
A	getPath()	0	4	1
A	getTempFile()	0	8	2
A	getStderr()	0	4	1
A	getWarnings()	0	17	2
A	stop()	0	4	1
A	deleteFile()	0	5	1
A	isDoneRunning()	0	4	1
A	getExitCode()	0	4	1
A	getLastCommand()	0	4	1
A	run()	0	16	2
A	getToken()	0	4	1
A	command()	0	7	1
A	getCoverageFileName()	0	8	2
A	getStdout()	0	4	1
A	setTempFile()	0	4	1
A	assertValidCommandLineLength()	0	16	3
A	prepareOptions()	0	4	1
A	getCommandString()	0	16	3
A	handleEnvironmentVariables()	0	6	2
A	redirectCoverageOption()	0	10	2

<?php

declare(strict_types=1);

namespace ParaTest\Runners\PHPUnit;

use Symfony\Component\Process\PhpExecutableFinder;
use Symfony\Component\Process\Process;

abstract class ExecutableTest
{
    /**
     * The path to the test to run.
     *
     * @var string
     */
    protected $path;

    /**
     * A path to the temp file created
     * for this test.
     *
     * @var string
     */
    protected $temp;
    protected $fullyQualifiedClassName;
    protected $pipes = [];

    /**
     * Path where the coveragereport is stored.
     *
     * @var string
     */
    protected $coverageFileName;

    /**
     * @var Process
     */
    protected $process;

    /**
     * A unique token value for a given
     * process.
     *
     * @var int
     */
    protected $token;

    /**
     * Last executed process command.
     *
     * @var string
     */
    protected $lastCommand;

    public function __construct(string $path, string $fullyQualifiedClassName = null)
    {
        $this->path = $path;
        $this->fullyQualifiedClassName = $fullyQualifiedClassName;
    }

    /**
     * Get the expected count of tests to be executed.
     *
     * @return int
     */
    abstract public function getTestCount(): int;

    /**
     * Get the path to the test being executed.
     *
     * @return string
     */
    public function getPath(): string
    {
        return $this->path;
    }

    /**
     * Returns the path to this test's temp file.
     * If the temp file does not exist, it will be
     * created.
     *
     * @return string
     */
    public function getTempFile(): string
    {
        if (null === $this->temp) {
            $this->temp = tempnam(sys_get_temp_dir(), 'PT_');
        }

        return $this->temp;
    }

    /**
     * Return the test process' stderr contents.
     *
     * @return string
     */
    public function getStderr(): string
    {
        return $this->process->getErrorOutput();
    }

    /**
     * Return any warnings that are in the test output, or false if there are none.
     *
     * @return mixed
     */
    public function getWarnings()
    {
        if (!$this->process) {
            return false;
        }

        // PHPUnit has a bug where by it doesn't include warnings in the junit
        // output, but still fails. This is a hacky, imperfect method for extracting them
        // see https://github.com/sebastianbergmann/phpunit/issues/1317
        preg_match_all(
            '/^\d+\) Warning\n(.+?)$/ms',
            $this->process->getOutput(),
            $matches
        );

        return $matches[1] ?? false;
    }

    /**
     * Stop the process and return it's
     * exit code.
     *
     * @return int
     */
    public function stop(): int
    {
        return $this->process->stop();
    }

    /**
     * Removes the test file.
     */
    public function deleteFile()
    {
        $outputFile = $this->getTempFile();
        unlink($outputFile);
    }

    /**
     * Check if the process has terminated.
     *
     * @return bool
     */
    public function isDoneRunning(): bool
    {
        return $this->process->isTerminated();
    }

    /**
     * Return the exit code of the process.
     *
     * @return int
     */
    public function getExitCode(): int
    {
        return $this->process->getExitCode();
    }

    /**
     * Return the last process command.
     *
     * @return string
     */
    public function getLastCommand(): string
    {
        return $this->lastCommand;
    }

    /**
     * Executes the test by creating a separate process.
     *
     * @param $binary
     * @param array $options
     * @param array $environmentVariables
     *
     * @return $this
     */
    public function run(string $binary, array $options = [], array $environmentVariables = [])
    {
        $environmentVariables['PARATEST'] = 1;
        $this->handleEnvironmentVariables($environmentVariables);
        $finder = new PhpExecutableFinder();
        $command = $finder->find() . ' ' . $this->command($binary, $options);
        $this->assertValidCommandLineLength($command);
        $this->lastCommand = $command;
        $this->process = new Process($command, null, $environmentVariables);
        if (method_exists($this->process, 'inheritEnvironmentVariables')) {
            $this->process->inheritEnvironmentVariables();  // no such method in 3.0, but emits warning if this isn't done in 3.3
        }
        $this->process->start();

        return $this;
    }

    /**
     * Returns the unique token for this test process.
     *
     * @return int
     */
    public function getToken(): int
    {
        return $this->token;
    }

    /**
     * Generate command line with passed options suitable to handle through paratest.
     *
     * @param string $binary  executable binary name
     * @param array  $options command line options
     *
     * @return string command line
     */
    public function command(string $binary, array $options = []): string
    {
        $options = array_merge($this->prepareOptions($options), ['log-junit' => $this->getTempFile()]);
        $options = $this->redirectCoverageOption($options);

        return $this->getCommandString($binary, $options);
    }

    /**
     * Get covertage filename.
     *
     * @return string
     */
    public function getCoverageFileName(): string
    {
        if ($this->coverageFileName === null) {
            $this->coverageFileName = tempnam(sys_get_temp_dir(), 'CV_');
        }

        return $this->coverageFileName;
    }

    /**
     * Get process stdout content.
     *
     * @return string
     */
    public function getStdout(): string
    {
        return $this->process->getOutput();
    }

    /**
     * Set process termporary filename.
     *
     * @param string $temp
     */
    public function setTempFile(string $temp)
    {
        $this->temp = $temp;
    }

    /**
     * Assert that command line lenght is valid.
     *
     * In some situations process command line can became too long when combining different test
     * cases in single --filter arguments so it's better to show error regarding that to user
     * and propose him to decrease max batch size.
     *
     * @param string $cmd Command line
     *
     * @throws \RuntimeException on too long command line
     */
    protected function assertValidCommandLineLength(string $cmd)
    {
        if (DIRECTORY_SEPARATOR === '\\') { // windows
            // symfony's process wrapper
            $cmd = 'cmd /V:ON /E:ON /C "(' . $cmd . ')';
            if (strlen($cmd) > 32767) {
                throw new \RuntimeException('Command line is too long, try to decrease max batch size');
            }
        }
        /*
         * @todo Implement command line length validation for linux/osx/freebsd.
         *       Please note that on unix environment variables also became part of command line:
         *         - linux: echo | xargs --show-limits
         *         - osx/linux: getconf ARG_MAX
         */
    }

    /**
     * A template method that can be overridden to add necessary options for a test.
     *
     * @param array $options the options that are passed to the run method
     *
     * @return array $options the prepared options
     */
    protected function prepareOptions(array $options): array
    {
        return $options;
    }

    /**
     * Returns the command string that will be executed
     * by proc_open.
     *
     * @param string $binary
     * @param array  $options
     *
     * @return mixed
     */
    protected function getCommandString(string $binary, array $options = [])
    {
        // The order we add stuff into $arguments is important
        $arguments = [$binary];
        foreach ($options as $key => $value) {
            $arguments[] = "--$key";
            if ($value !== null) {
                $arguments[] = $value;
            }
        }

        $arguments[] = $this->fullyQualifiedClassName ?? '';
        $arguments[] = $this->getPath();

        return (new Process($arguments))->getCommandLine();
    }

    /**
     * Checks environment variables for the presence of a TEST_TOKEN
     * variable and sets $this->token based on its value.
     *
     * @param $environmentVariables
     */
    protected function handleEnvironmentVariables(array $environmentVariables)
    {
        if (isset($environmentVariables['TEST_TOKEN'])) {
            $this->token = $environmentVariables['TEST_TOKEN'];
        }
    }

    /**
     * Checks if the coverage-php option is set and redirects it to a unique temp file.
     * This will ensure, that multiple tests write to separate coverage-files.
     *
     * @param array $options
     *
     * @return array $options
     */
    protected function redirectCoverageOption(array $options): array
    {
        if (isset($options['coverage-php'])) {
            $options['coverage-php'] = $this->getCoverageFileName();
        }

        unset($options['coverage-html'], $options['coverage-clover']);

        return $options;
    }
}