ParaTest\Console\Testers\PHPUnit

Complexity

Total Complexity

30

Size/Duplication

Total Lines	218
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	6

Test Coverage

Coverage

66.25%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	configure()	0	17	1
A	hasPath()	0	7	2
A	hasConfig()	0	4	1
A	getConfig()	0	16	4
A	getRunnerOptions()	0	17	3
A	requireBootstrap()	0	13	3
A	scopedRequire()	0	6	1
A	hasCoverage()	0	7	3
A	getBootstrapFile()	0	15	4
C	execute()	0	27	8

<?php

declare(strict_types=1);

namespace ParaTest\Console\Testers;

use ParaTest\Runners\PHPUnit\Configuration;
use ParaTest\Runners\PHPUnit\Runner;
use ParaTest\Runners\PHPUnit\WrapperRunner;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;

/**
 * Class PHPUnit.
 *
 * Creates the interface for PHPUnit testing
 */
class PHPUnit extends Tester
{
    /**
     * @var \ParaTest\Console\Commands\ParaTestCommand
     */
    protected $command;

    /**
     * Configures the ParaTestCommand with PHPUnit specific
     * definitions.
     *
     * @param Command $command
     */
    public function configure(Command $command)
    {
        $command
            ->addOption('phpunit', null, InputOption::VALUE_REQUIRED, 'The PHPUnit binary to execute. <comment>(default: vendor/bin/phpunit)</comment>')
            ->addOption('runner', null, InputOption::VALUE_REQUIRED, 'Runner or WrapperRunner. <comment>(default: Runner)</comment>')
            ->addOption('bootstrap', null, InputOption::VALUE_REQUIRED, 'The bootstrap file to be used by PHPUnit.')
            ->addOption('configuration', 'c', InputOption::VALUE_REQUIRED, 'The PHPUnit configuration file to use.')
            ->addOption('group', 'g', InputOption::VALUE_REQUIRED, 'Only runs tests from the specified group(s).')
            ->addOption('exclude-group', null, InputOption::VALUE_REQUIRED, 'Don\'t run tests from the specified group(s).')
            ->addOption('stop-on-failure', null, InputOption::VALUE_NONE, 'Don\'t start any more processes after a failure.')
            ->addOption('log-junit', null, InputOption::VALUE_REQUIRED, 'Log test execution in JUnit XML format to file.')
            ->addOption('colors', null, InputOption::VALUE_NONE, 'Displays a colored bar as a test result.')
            ->addOption('testsuite', null, InputOption::VALUE_OPTIONAL, 'Filter which testsuite to run')
            ->addArgument('path', InputArgument::OPTIONAL, 'The path to a directory or file containing tests. <comment>(default: current directory)</comment>')
            ->addOption('path', null, InputOption::VALUE_REQUIRED, 'An alias for the path argument.');
        $this->command = $command;

$command is of type object<Symfony\Component\Console\Command\Command>, but the property $command was declared to be of type object<ParaTest\Console\Commands\ParaTestCommand>. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

    }

    /**
     * Executes the PHPUnit Runner. Will Display help if no config and no path
     * supplied.
     *
     * @param InputInterface  $input
     * @param OutputInterface $output
     *
     * @return int|mixed
     */
    public function execute(InputInterface $input, OutputInterface $output)
    {
        if (!$this->hasConfig($input) && !$this->hasPath($input)) {
            $this->displayHelp($input, $output);
        }

        if ($input->getOption('runner') === 'WrapperRunner') {
            $runner = new WrapperRunner($this->getRunnerOptions($input));
        } else {
            if ($input->getOption('runner') !== '') {
                // because we want to have to bootstrap script inherited before check/initialization
                $runnerOption = $this->getRunnerOptions($input);
                $runnerClass = $input->getOption('runner');
                if (null !== $runnerClass && class_exists($runnerClass)) {
                    $runner = new $runnerClass($runnerOption);
                }
            }
        }

        if (!isset($runner)) {
            $runner = new Runner($this->getRunnerOptions($input));
        }

        $runner->run();

        return $runner->getExitCode();
    }

    /**
     * Returns whether or not a test path has been supplied
     * via option or regular input.
     *
     * @param InputInterface $input
     *
     * @return bool
     */
    protected function hasPath(InputInterface $input)
    {
        $argument = $input->getArgument('path');
        $option = $input->getOption('path');

        return $argument || $option;
    }

    /**
     * Is there a PHPUnit xml configuration present.
     *
     * @param InputInterface $input
     *
     * @return bool
     */
    protected function hasConfig(InputInterface $input): bool
    {
        return false !== $this->getConfig($input);
    }

    /**
     * @param \Symfony\Component\Console\Input\InputInterface $input
     *
     * @return \ParaTest\Runners\PHPUnit\Configuration|bool
     */
    protected function getConfig(InputInterface $input)
    {
        $cwd = getcwd() . DIRECTORY_SEPARATOR;

        if ($input->getOption('configuration')) {
            $configFilename = $input->getOption('configuration');
        } elseif (file_exists($cwd . 'phpunit.xml.dist')) {
            $configFilename = $cwd . 'phpunit.xml.dist';
        } elseif (file_exists($cwd . 'phpunit.xml')) {
            $configFilename = $cwd . 'phpunit.xml';
        } else {
            return false;
        }

        return new Configuration($configFilename);
    }

    /**
     * @param \Symfony\Component\Console\Input\InputInterface $input
     *
     * @throws \RuntimeException
     *
     * @return array
     */
    public function getRunnerOptions(InputInterface $input): array
    {
        $path = $input->getArgument('path');
        $options = $this->getOptions($input);
        $bootstrap = $this->getBootstrapFile($input, $options);
        $this->requireBootstrap($bootstrap);

        if ($this->hasCoverage($options)) {
            $options['coverage-php'] = tempnam(sys_get_temp_dir(), 'paratest_');
        }

        if ($path) {
            $options = array_merge(['path' => $path], $options);
        }

        return $options;
    }

    /**
     * Require the bootstrap. If the file is specified, but does not exist
     * then an exception will be raised.
     *
     * @param $file
     *
     * @throws \RuntimeException
     */
    public function requireBootstrap(string $file)
    {
        if (!$file) {
            return;
        }

        if (!file_exists($file)) {
            $message = sprintf('Bootstrap specified but could not be found (%s)', $file);
            throw new \RuntimeException($message);
        }

        $this->scopedRequire($file);
    }

    /**
     * This function limits the scope of a required file
     * so that variables defined in it do not break
     * this object's configuration.
     *
     * @param mixed $file
     */
    protected function scopedRequire(string $file)
    {
        $cwd = getcwd();
        require_once $file;
        chdir($cwd);
    }

    /**
     * Return whether or not code coverage information should be collected.
     *
     * @param $options
     *
     * @return bool
     */
    protected function hasCoverage(array $options): bool
    {
        $isFileFormat = isset($options['coverage-html']) || isset($options['coverage-clover']);
        $isPHP = isset($options['coverage-php']);

        return $isFileFormat && !$isPHP;
    }

    /**
     * Fetch the path to the bootstrap file.
     *
     * @param InputInterface $input
     * @param array          $options
     *
     * @return string
     */
    protected function getBootstrapFile(InputInterface $input, array $options): string
    {
        if (isset($options['bootstrap'])) {
            return $options['bootstrap'];
        }

        if (!$this->hasConfig($input)) {
            return '';
        }

        $config = $this->getConfig($input);
        $bootstrap = $config->getBootstrap();

        return ($bootstrap) ? $config->getConfigDir() . $bootstrap : '';
    }
}