php-censor/src/Plugin/PhpUnit.php

<?php

namespace PHPCensor\Plugin;

use PHPCensor\Config;
use PHPCensor;
use PHPCensor\Builder;
use PHPCensor\Model\Build;
use PHPCensor\Model\BuildError;
use PHPCensor\Plugin\Option\PhpUnitOptions;
use PHPCensor\Plugin\Util\PhpUnitResultJson;
use PHPCensor\Plugin\Util\PhpUnitResultJunit;
use PHPCensor\Plugin;
use PHPCensor\ZeroConfigPluginInterface;
use Symfony\Component\Filesystem\Filesystem;

/**
 * PHP Unit Plugin - A rewrite of the original PHP Unit plugin
 *
 * @author Dan Cryer <dan@block8.co.uk>
 * @author Pablo Tejada <pablo@ptejada.com>
 */
class PhpUnit extends Plugin implements ZeroConfigPluginInterface
{
    /**
     * @var string
     */
    protected $buildDirectory;

    /**
     * @var string
     */
    protected $buildBranchDirectory;

    /**
     * @var string
     */
    protected $buildLocation;

    /**
     * @var string
     */
    protected $buildBranchLocation;

    /** @var PhpUnitOptions*/
    protected $options;

    /**
     * @return string
     */
    public static function pluginName()
    {
        return 'php_unit';
    }

    /**
     * Standard Constructor
     * $options['config']    Path to a PHPUnit XML configuration file.
     * $options['run_from']  The directory where the phpunit command will run from when using 'config'.
     * $options['coverage']  Value for the --coverage-html command line flag.
     * $options['directory'] Optional directory or list of directories to run PHPUnit on.
     * $options['args']      Command line args (in string format) to pass to PHP Unit
     *
     * @param Builder  $builder
     * @param Build    $build
     * @param string[] $options
     */
    public function __construct(Builder $builder, Build $build, array $options = [])
    {
        parent::__construct($builder, $build, $options);

        $this->buildDirectory       = $build->getBuildDirectory();
        $this->buildBranchDirectory = $build->getBuildBranchDirectory();

        $this->buildLocation       = PUBLIC_DIR . 'artifacts/phpunit/' . $this->buildDirectory;
        $this->buildBranchLocation = PUBLIC_DIR . 'artifacts/phpunit/' . $this->buildBranchDirectory;

        $this->options = new PhpUnitOptions($options, $this->buildLocation);
    }

    /**
     * Check if the plugin can be executed without any configurations
     *
     * @param string  $stage
     * @param Builder $builder
     * @param Build   $build
     *
     * @return bool
     */
    public static function canExecute($stage, Builder $builder, Build $build)
    {
        if ($stage == Build::STAGE_TEST && !is_null(PhpUnitOptions::findConfigFile($build->getBuildPath()))) {
            return true;
        }

        return false;
    }

    /**
     * Runs PHP Unit tests in a specified directory, optionally using specified config file(s).
     */
    public function execute()
    {
        $xmlConfigFiles = $this->options->getConfigFiles($this->build->getBuildPath());
        $directories    = $this->options->getDirectories();
        if (empty($xmlConfigFiles) && empty($directories)) {
            $this->builder->logFailure('Neither a configuration file nor a test directory found.');
            return false;
        }

        $cmd      = $this->findBinary('phpunit');
        $lastLine = exec($cmd.' --log-json . --version');
        if (false !== strpos($lastLine, '--log-json')) {
            $logFormat = 'junit'; // --log-json is not supported
        } else {
            $logFormat = 'json';
        }

        $success = [];

        // Run any directories
        if (!empty($directories)) {
            foreach ($directories as $directory) {
                $success[] = $this->runConfig($directory, null, $logFormat);
            }
        } else {
            // Run any config files
            if (!empty($xmlConfigFiles)) {
                foreach ($xmlConfigFiles as $configFile) {
                    $success[] = $this->runConfig($this->options->getTestsPath(), $configFile, $logFormat);
                }
            }
        }

        return !in_array(false, $success);
    }

    /**
     * Run the tests defined in a PHPUnit config file or in a specific directory.
     *
     * @param string      $directory
     * @param string|null $configFile
     * @param string      $logFormat
     *
     * @return bool|mixed
     *
     * @throws \Exception
     */
    protected function runConfig($directory, $configFile, $logFormat)
    {
        $allowPublicArtifacts = (bool)Config::getInstance()->get(
            'php-censor.build.allow_public_artifacts',
            true
        );

        $fileSystem = new Filesystem();

        $options   = clone $this->options;
        $buildPath = $this->build->getBuildPath();

        // Save the results into a log file
        $logFile = tempnam(sys_get_temp_dir(), 'jlog_');
        $options->addArgument('log-' . $logFormat, $logFile);

        // Removes any current configurations files
        $options->removeArgument('configuration');
        if (null !== $configFile) {
            // Only the add the configuration file been passed
            $options->addArgument('configuration', $buildPath . $configFile);
        }

        if ($options->getOption('coverage') && $allowPublicArtifacts) {
            if (!$fileSystem->exists($this->buildLocation)) {
                $fileSystem->mkdir($this->buildLocation, (0777 & ~umask()));
            }

            if (!is_writable($this->buildLocation)) {
                throw new \Exception(sprintf(
                    'The location %s is not writable or does not exist.',
                    $this->buildLocation
                ));
            }
        }

        $arguments = $this->builder->interpolate($options->buildArgumentString());
        $cmd       = $this->findBinary('phpunit') . ' %s %s';
        $success   = $this->builder->executeCommand($cmd, $arguments, $directory);
        $output    = $this->builder->getLastOutput();

        if (
            $fileSystem->exists($this->buildLocation) &&
            $options->getOption('coverage') &&
            $allowPublicArtifacts
        ) {
            $fileSystem->remove($this->buildBranchLocation);
            $fileSystem->mirror($this->buildLocation, $this->buildBranchLocation);
        }

        $this->processResults($logFile, $logFormat);

        $config = $this->builder->getSystemConfig('php-censor');

        if ($options->getOption('coverage')) {
            preg_match(
                '#Classes:[\s]*(.*?)%[^M]*?Methods:[\s]*(.*?)%[^L]*?Lines:[\s]*(.*?)\%#s',
                $output,
                $matches
            );

            $this->build->storeMeta('phpunit-coverage', [
                'classes' => !empty($matches[1]) ? $matches[1] : '0.00',
                'methods' => !empty($matches[2]) ? $matches[2] : '0.00',
                'lines'   => !empty($matches[3]) ? $matches[3] : '0.00',
            ]);

            if ($allowPublicArtifacts) {
                $this->builder->logSuccess(
                    sprintf(
                        "\nPHPUnit successful build coverage report.\nYou can use coverage report for this build: %s\nOr coverage report for last build in the branch: %s",
                        $config['url'] . '/artifacts/phpunit/' . $this->buildDirectory . '/index.html',
                        $config['url'] . '/artifacts/phpunit/' . $this->buildBranchDirectory . '/index.html'
                    )
                );
            }
        }

        return $success;
    }

    /**
     * Saves the test results
     *
     * @param string $logFile
     * @param string $logFormat
     *
     * @throws \Exception If failed to parse the log file
     */
    protected function processResults($logFile, $logFormat)
    {
        if (file_exists($logFile)) {
            if ('json' === $logFormat) {
                $parser = new PhpUnitResultJson($logFile, $this->build->getBuildPath());
            } else {
                $parser = new PhpUnitResultJunit($logFile, $this->build->getBuildPath());
            }

            $this->build->storeMeta('phpunit-data', $parser->parse()->getResults());
            $this->build->storeMeta('phpunit-errors', $parser->getFailures());

            foreach ($parser->getErrors() as $error) {
                $severity = $error['severity'] ==
                    $parser::SEVERITY_ERROR ?
                        BuildError::SEVERITY_CRITICAL :
                        BuildError::SEVERITY_HIGH;
                $this->build->reportError(
                    $this->builder, 'php_unit', $error['message'], $severity, $error['file'], $error['line']
                );
            }
            unlink($logFile);
        } else {
            throw new \Exception('log output file does not exist: ' . $logFile);
        }
    }
}