ExecutableTest::setTempFile() - Code Metrics - Inspection of "Merge pull request #260 from Slamdunk/travis_opti" - brianium/paratest - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 743834...4ffa9b )

by Julian

created 2017-07-04 20:36 UTC

ExecutableTest::setTempFile() A

↳ Parent: ExecutableTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	3
cts	3
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	1
crap	1

<?php

namespace ParaTest\Runners\PHPUnit;

use Symfony\Component\Process\Process;
use Symfony\Component\Process\ProcessBuilder;

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($path, $fullyQualifiedClassName = null)
    {
        $this->path = $path;
        $this->fullyQualifiedClassName = $fullyQualifiedClassName;
    }

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

    /**
     * Get the path to the test being executed.
     *
     * @return string
     */
    public function getPath()
    {
        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()
    {
        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()
    {
        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()
    {
        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()
    {
        return $this->process->isTerminated();
    }

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

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

    /**
     * Executes the test by creating a separate process.
     *
     * @param $binary
     * @param array $options
     * @param array $environmentVariables
     *
     * @return $this
     */
    public function run($binary, $options = [], $environmentVariables = [])
    {
        $environmentVariables['PARATEST'] = 1;
        $this->handleEnvironmentVariables($environmentVariables);
        $command = PHP_BINARY . ' ' . $this->command($binary, $options);
        $this->assertValidCommandLineLength($command);
        $this->lastCommand = $command;
        $this->process = new Process($command, null, $environmentVariables);
        $this->process->start();

        return $this;
    }

    /**
     * Returns the unique token for this test process.
     *
     * @return int
     */
    public function getToken()
    {
        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($binary, $options = [])
    {
        $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()
    {
        if ($this->coverageFileName === null) {
            $this->coverageFileName = tempnam(sys_get_temp_dir(), 'CV_');
        }

        return $this->coverageFileName;
    }

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

    /**
     * Set process termporary filename.
     *
     * @param string $temp
     */
    public function setTempFile($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($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($options)
    {
        return $options;
    }

    /**
     * Returns the command string that will be executed
     * by proc_open.
     *
     * @param $binary
     * @param array $options
     *
     * @return mixed
     */
    protected function getCommandString($binary, $options = [])
    {
        $builder = new ProcessBuilder();
        $builder->setPrefix($binary);
        foreach ($options as $key => $value) {
            $builder->add("--$key");
            if ($value !== null) {
                $builder->add($value);
            }
        }

        $builder->add($this->fullyQualifiedClassName);
        $builder->add($this->getPath());

        $process = $builder->getProcess();

        return $process->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($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($options)
    {
        if (isset($options['coverage-php'])) {
            $options['coverage-php'] = $this->getCoverageFileName();
        }

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

        return $options;
    }
}


1		<?php
2
3		namespace ParaTest\Runners\PHPUnit;
4
5		use Symfony\Component\Process\Process;
6		use Symfony\Component\Process\ProcessBuilder;
7
8		abstract class ExecutableTest
9		{
10		/**
11		* The path to the test to run.
12		*
13		* @var string
14		*/
15		protected $path;
16
17		/**
18		* A path to the temp file created
19		* for this test.
20		*
21		* @var string
22		*/
23		protected $temp;
24		protected $fullyQualifiedClassName;
25		protected $pipes = [];
26
27		/**
28		* Path where the coveragereport is stored.
29		*
30		* @var string
31		*/
32		protected $coverageFileName;
33
34		/**
35		* @var Process
36		*/
37		protected $process;
38
39		/**
40		* A unique token value for a given
41		* process.
42		*
43		* @var int
44		*/
45		protected $token;
46
47		/**
48		* Last executed process command.
49		*
50		* @var string
51		*/
52		protected $lastCommand;
53
54	66	public function __construct($path, $fullyQualifiedClassName = null)
55		{
56	66	$this->path = $path;
57	66	$this->fullyQualifiedClassName = $fullyQualifiedClassName;
58	66	}
59
60		/**
61		* Get the expected count of tests to be executed.
62		*
63		* @return int
64		*/
65		abstract public function getTestCount();
66
67		/**
68		* Get the path to the test being executed.
69		*
70		* @return string
71		*/
72	6	public function getPath()
73		{
74	6	return $this->path;
75		}
76
77		/**
78		* Returns the path to this test's temp file.
79		* If the temp file does not exist, it will be
80		* created.
81		*
82		* @return string
83		*/
84	32	public function getTempFile()
85		{
86	32	if (null === $this->temp) {
87	5	$this->temp = tempnam(sys_get_temp_dir(), 'PT_');
88		}
89
90	32	return $this->temp;
91		}
92
93		/**
94		* Return the test process' stderr contents.
95		*
96		* @return string
97		*/
98		public function getStderr()
99		{
100		return $this->process->getErrorOutput();
101		}
102
103		/**
104		* Return any warnings that are in the test output, or false if there are none.
105		*
106		* @return mixed
107		*/
108	11	public function getWarnings()
109		{
110	11	if (!$this->process) {
111	9	return false;
112		}
113
114		// PHPUnit has a bug where by it doesn't include warnings in the junit
115		// output, but still fails. This is a hacky, imperfect method for extracting them
116		// see https://github.com/sebastianbergmann/phpunit/issues/1317
117	2	preg_match_all(
118	2	'/^\d+\) Warning\n(.+?)$/ms',
119	2	$this->process->getOutput(),
120	2	$matches
121		);
122
123	2	return $matches[1] ?? false;
124		}
125
126		/**
127		* Stop the process and return it's
128		* exit code.
129		*
130		* @return int
131		*/
132	2	public function stop()
133		{
134	2	return $this->process->stop();
135		}
136
137		/**
138		* Removes the test file.
139		*/
140		public function deleteFile()
141		{
142		$outputFile = $this->getTempFile();
143		unlink($outputFile);
144		}
145
146		/**
147		* Check if the process has terminated.
148		*
149		* @return bool
150		*/
151	2	public function isDoneRunning()
152		{
153	2	return $this->process->isTerminated();
154		}
155
156		/**
157		* Return the exit code of the process.
158		*
159		* @return int
160		*/
161	2	public function getExitCode()
162		{
163	2	return $this->process->getExitCode();
164		}
165
166		/**
167		* Return the last process command.
168		*
169		* @return string
170		*/
171		public function getLastCommand()
172		{
173		return $this->lastCommand;
174		}
175
176		/**
177		* Executes the test by creating a separate process.
178		*
179		* @param $binary
180		* @param array $options
181		* @param array $environmentVariables
182		*
183		* @return $this
184		*/
185	2	public function run($binary, $options = [], $environmentVariables = [])
186		{
187	2	$environmentVariables['PARATEST'] = 1;
188	2	$this->handleEnvironmentVariables($environmentVariables);
189	2	$command = PHP_BINARY . ' ' . $this->command($binary, $options);
190	2	$this->assertValidCommandLineLength($command);
191	2	$this->lastCommand = $command;
192	2	$this->process = new Process($command, null, $environmentVariables);
193	2	$this->process->start();
194
195	2	return $this;
196		}
197
198		/**
199		* Returns the unique token for this test process.
200		*
201		* @return int
202		*/
203	1	public function getToken()
204		{
205	1	return $this->token;
206		}
207
208		/**
209		* Generate command line with passed options suitable to handle through paratest.
210		*
211		* @param string $binary executable binary name
212		* @param array $options command line options
213		*
214		* @return string command line
215		*/
216	3	public function command($binary, $options = [])
217		{
218	3	$options = array_merge($this->prepareOptions($options), ['log-junit' => $this->getTempFile()]);
219	3	$options = $this->redirectCoverageOption($options);
220
221	3	return $this->getCommandString($binary, $options);
222		}
223
224		/**
225		* Get covertage filename.
226		*
227		* @return string
228		*/
229	3	public function getCoverageFileName()
230		{
231	3	if ($this->coverageFileName === null) {
232	3	$this->coverageFileName = tempnam(sys_get_temp_dir(), 'CV_');
233		}
234
235	3	return $this->coverageFileName;
236		}
237
238		/**
239		* Get process stdout content.
240		*
241		* @return string
242		*/
243		public function getStdout()
244		{
245		return $this->process->getOutput();
246		}
247
248		/**
249		* Set process termporary filename.
250		*
251		* @param string $temp
252		*/
253	37	public function setTempFile($temp)
254		{
255	37	$this->temp = $temp;
256	37	}
257
258		/**
259		* Assert that command line lenght is valid.
260		*
261		* In some situations process command line can became too long when combining different test
262		* cases in single --filter arguments so it's better to show error regarding that to user
263		* and propose him to decrease max batch size.
264		*
265		* @param string $cmd Command line
266		*
267		* @throws \RuntimeException on too long command line
268		*/
269	2	protected function assertValidCommandLineLength($cmd)
270		{
271	2	if (DIRECTORY_SEPARATOR === '\\') { // windows
272		// symfony's process wrapper
273		$cmd = 'cmd /V:ON /E:ON /C "(' . $cmd . ')';
274		if (strlen($cmd) > 32767) {
275		throw new \RuntimeException('Command line is too long, try to decrease max batch size');
276		}
277		}
278		// TODO: Implement command line length validation for linux/osx/freebsd
279		// Please note that on unix environment variables also became part of command line
280		// linux: echo \| xargs --show-limits
281		// osx/linux: getconf ARG_MAX
282	2	}
283
284		/**
285		* A template method that can be overridden to add necessary options for a test.
286		*
287		* @param array $options the options that are passed to the run method
288		*
289		* @return array $options the prepared options
290		*/
291	3	protected function prepareOptions($options)
292		{
293	3	return $options;
294		}
295
296		/**
297		* Returns the command string that will be executed
298		* by proc_open.
299		*
300		* @param $binary
301		* @param array $options
302		*
303		* @return mixed
304		*/
305	6	protected function getCommandString($binary, $options = [])
306		{
307	6	$builder = new ProcessBuilder();
308	6	$builder->setPrefix($binary);
309	6	foreach ($options as $key => $value) {
310	5	$builder->add("--$key");
311	5	if ($value !== null) {
312	5	$builder->add($value);
313		}
314		}
315
316	6	$builder->add($this->fullyQualifiedClassName);
317	6	$builder->add($this->getPath());
318
319	6	$process = $builder->getProcess();
320
321	6	return $process->getCommandLine();
322		}
323
324		/**
325		* Checks environment variables for the presence of a TEST_TOKEN
326		* variable and sets $this->token based on its value.
327		*
328		* @param $environmentVariables
329		*/
330	3	protected function handleEnvironmentVariables($environmentVariables)
331		{
332	3	if (isset($environmentVariables['TEST_TOKEN'])) {
333	3	$this->token = $environmentVariables['TEST_TOKEN'];
334		}
335	3	}
336
337		/**
338		* Checks if the coverage-php option is set and redirects it to a unique temp file.
339		* This will ensure, that multiple tests write to separate coverage-files.
340		*
341		* @param array $options
342		*
343		* @return array $options
344		*/
345	3	protected function redirectCoverageOption($options)
346		{
347	3	if (isset($options['coverage-php'])) {
348	3	$options['coverage-php'] = $this->getCoverageFileName();
349		}
350
351	3	unset($options['coverage-html'], $options['coverage-clover']);
352
353	3	return $options;
354		}
355		}
356

brianium / paratest

Push — master ( 743834...4ffa9b )

ExecutableTest::setTempFile() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like