ProcessNetteTester.module

<?php namespace ProcessWire;

use Tester\Assert;
use Tester\AssertException;
use Tester\Dumper;
use Tester\Environment;

require_once __DIR__ . '/IProcessNetteTester.php';

/**
 * Run Nette Tester tests within ProcessWire admin.
 * by Roland Toth (tpr)
 *
 * ProcessWire 3.x
 * Copyright (C) 2011 by Ryan Cramer
 * Licensed under GNU/GPL v2, see LICENSE.TXT
 *
 * http://www.processwire.com
 * http://www.ryancramer.com
 *
 * FileCompiler=0
 */

/**
 * Class ProcessNetteTester
 *
 * @package ProcessWire
 */
class ProcessNetteTester extends Process implements \IProcessNetteTester
{
    const TEST_DIR_FIELD = 'tester_tests_directory';
    const EMPTY_VALUE = '';
    const TIMEOUT = 60;

    private $testDirName;
    private $testDirPath;
    private $testFiles;
    private $texts;
    private $totalTestCount = 0;
    private $subsetTestCount = 0;

    /**
     * Basic information about module.
     *
     * @return array
     */
    public static function getModuleInfo()
    {
        return array(
            'title' => 'ProcessNetteTester',
            'summary' => __('Run Nette Tester tests within ProcessWire admin', __FILE__),
            'href' => '',
            'author' => 'Roland Toth',
            'version' => '0.1.3',
            'icon' => 'circle-o-notch',
            'requires' => 'PHP>=5.6.0, ProcessWire>=3.0.0',
            'autoload' => 'process=ProcessNetteTester',
            'singular' => true,
        );
    }

    public function execute()
    {
        $this->texts = $this->getTexts();
        
        if ($this->wire('config')->ajax) {
            return $this->getAjaxResponse();
        }

        $this->testDirName = $this->getTestDirName();
        $this->testDirPath = $this->getTestDirPath();
        $this->testFiles = $this->getTestFiles();

        return $this->renderMarkup();
    }

    public function formatTime($microtime, $decimals = 4)
    {
        return number_format($microtime, $decimals, '.', '');
    }

    public function getLineInfo($line = null)
    {
        $lineInfo = '';

        if (is_int($line)) {
            $lineInfo = sprintf($this->texts['lineNum'], $line);
        }

        return '<em class="line-info">' . $lineInfo . '</em>';
    }

    public function getModifiedDumperMessage($exception)
    {
        Dumper::$maxLength = 800; // default is 70
        $origMessage = $exception->origMessage;

        $msg = strtr($origMessage, [
            '%1 ' => '<span class="actual">%1</span><span>',
            '%2 ' => '</span><span class="expected">%2</span><span>',
        ]);

        $msg .= '</span>';

        $actual = Dumper::toLine($exception->actual);
        $expected = Dumper::toLine($exception->expected);

        $msg = strtr($msg, array(
            '%1' => htmlentities($actual),
            '%2' => htmlentities($expected),
        ));

        return $msg;
    }

    public function getTestDirName()
    {
        return rtrim($this->wire('page')->{self::TEST_DIR_FIELD}, '/');
    }

    public function getTestDirPath()
    {
        return $this->wire('config')->paths->root . ltrim($this->testDirName, '/') . '/';
    }

    public function getTestFiles()
    {
        $includes = !empty($_GET['include']) ? explode(',', $_GET['include']) : false;
        $excludes = !empty($_GET['exclude']) ? explode(',', $_GET['exclude']) : false;

        $allFiles = $this->rglob($this->testDirPath . '*Test.php');

        $subset = array_filter($allFiles, function ($v) use ($includes, $excludes) {

            $name = strtolower(basename($v, '.php'));
            $nameWithoutSuffix = substr($name, 0, -4);

            if ($includes) {
                return \in_array($name, $includes, true) || \in_array($nameWithoutSuffix, $includes, true);
            }

            if ($excludes) {
                return !\in_array($name, $excludes, true) && !\in_array($nameWithoutSuffix, $excludes, true);
            }

            return true;
        });

        $this->totalTestCount = \count($allFiles);
        $this->subsetTestCount = \count($subset);

        return $subset;
    }

    public function install()
    {
        if ($this->fields->get(self::TEST_DIR_FIELD) === null) {
            $field = new Field();
            $field->type = $this->modules->get('FieldtypeText');
            $field->name = self::TEST_DIR_FIELD;
            $field->label = $this->_('Tests directory');
            $field->description = $this->_('Directory path where test files are located (relative to site root)');
            $field->notes = $this->_('Eg. `/site/tests/`');
            $field->showIf = 'process=ProcessNetteTester';
            $field->required = 1;
            $field->requiredIf = 'process=ProcessNetteTester';
            $field->save();

            // Add field to admin template
            $adminTemplate = $this->templates->get('admin');
            $adminTemplate->fields->add($field);
            $adminTemplate->fields->save();

            $this->message($this->_("Added field '" . self::TEST_DIR_FIELD . "' to admin template."));
        }
    }

    public function uninstall()
    {
        // Remove tester_tests_directory field from admin template
        $adminTemplate = $this->templates->get('admin');

        if ($adminTemplate->fields->get(self::TEST_DIR_FIELD)) {
            $adminTemplate->fields->remove($adminTemplate->fields->get(self::TEST_DIR_FIELD));
            $adminTemplate->fields->save();
        }

        // Delete tester_tests_directory field
        $field = $this->fields->get(self::TEST_DIR_FIELD);

        if ($field) {
            $this->fields->delete($field);
        }
    }

    public function rglob($pattern, $flags = 0)
    {
        $files = glob($pattern, $flags);
        foreach (glob(dirname($pattern) . '/*', GLOB_ONLYDIR | GLOB_NOSORT) as $dir) {
            $files = array_merge($files, $this->rglob($dir . '/' . basename($pattern), $flags));
        }

        return $files;
    }

    public function renderControls()
    {
        $wrapper = new InputfieldWrapper();

        /** @var InputfieldCheckboxes $f */
        $f = $this->wire('modules')->get('InputfieldCheckboxes');
        $f->name = 'controls';
        $f->label = '';
        $f->optionColumns = 1;
        $f->skipLabel = true;
        $f->themeBorder = 'none';
        $f->wrapAttr('data-no-checkall-checkboxes', '1'); // aos
        $f->collapsed = Inputfield::collapsedNever;

        $f->addOption('testerStopOnFail',
            $this->_('Stop on fail'),
            array(
                'title' => $this->_('Stop bulk run if a test fails or times out'),
            ));

        $f->addOption('testerHidePassed',
            $this->_('Hide passed'),
            array(
                'title' => $this->_('Hide passed tests from the list'),
            ));

        $f->addOption('testerCountFailed',
            $this->_('Count failed'),
            array(
                'title' => $this->_('Count failed test on the main display'),
            ));

        $f->addOption('testerRetryFailed',
            $this->_('Retry failed only'),
            array(
                'title' => $this->_('Skip passed test on restarting a bulk run'),
            ));

        $f->addOption('testerAutoScroll',
            $this->_('Autoscroll'),
            array(
                'title' => $this->_('Keep currently running tests within the viewport (bulk run only)'),
            ));

        $f->addOption('testerShowBreadcrumbs',
            $this->_('Show breadcrumbs'),
            array(
                'title' => $this->_('Show parent directories above test names'),
            ));

        $wrapper->add($f);

        return $wrapper->render();
    }

    public function renderMarkup()
    {
        $texts = $this->texts;
        $total = $this->totalTestCount;

        if ($total === 0) {
            return sprintf($texts['noTestsFound'], $this->testDirName);
        }

        $jsonTexts = json_encode($texts, ENT_QUOTES | HTML_ENTITIES);
        $maxTimeout = self::TIMEOUT * 1000;
        $controls = $this->renderControls();
        $tableMarkup = $this->renderTable();

        if ($this->subsetTestCount < $this->totalTestCount) {
            $introText = sprintf($texts['introSubset'], $this->subsetTestCount, '<a href="' . wire('page')->url . '">' . $total . '</a>');
        } else {
            $introText = $texts['intro'];
        }

        $display = <<< HTML
<div id="display" data-texts='$jsonTexts' data-max-timeout="$maxTimeout">
<h3><span class="counter">0</span></em><span class="total">{$this->subsetTestCount}</span><span id="main-launcher"><em>{$texts['run']}</em><em>{$texts['stop']}</em></span></h3>
</div>
HTML;

        return <<< HTML
<div id="ProcessNetteTester-wrap">
$display
<div class="tester-data-container">
    <div class="settings">
        <p>{$introText} <i>{$this->testDirName}</i><br>
        <small>{$texts['help']}</small>
        </p>
        <div id="controls">$controls</div>
    </div>
    $tableMarkup
</div>
</div>
HTML;
    }

    public function getAjaxResponse()
    {
        ini_set('max_execution_time', '120');

        require_once __DIR__ . '/tester/src/bootstrap.php';
        Environment::setup();

        $isSuccess = true;
        $testMethodCount = 0;
        $msg = $this->texts['passed'];
        $file = filter_input(INPUT_GET, 'testfile');
        $time_pre = microtime(true);

        try {
            include $file;

        } catch (\Error $error) {
            $isSuccess = false;
            $msg = $error->getMessage() . $this->getLineInfo($error->getLine());

        } catch (\Exception $exception) {

            $isSuccess = false;
            $errorMsg = $exception->getMessage();
            $line = $exception->getLine();

            if ($exception instanceof AssertException) {
                $errorMsg = $this->getModifiedDumperMessage($exception);
            }

            // get line number from trace
            $trace = $exception->getTrace();

            foreach ($trace as $info) {
                // trace file name contains test basename
                if (strpos($info['file'], basename($file)) !== false) {
                    $line = $info['line'];
                    break;
                }
            }

            $msg = $errorMsg . $this->getLineInfo($line);

        } finally {

            $testInfo = '';
            
            if ($isSuccess) {
                $assertionsCount = Assert::$counter;
                $testMethodCount = $this->countTestMethods($file);

                $methodsText = $this->getTexts($testMethodCount === 1 ? 'test' : 'tests');
                $assertionsText = $this->getTexts($assertionsCount === 1 ? 'assertion' : 'assertions');
                $testInfo = "<i class='test-info'>$testMethodCount $methodsText &middot; $assertionsCount $assertionsText</i>";
            }

            $data = array(
                'result' => $msg . $testInfo,
                'time' => $this->formatTime($exec_time = microtime(true) - $time_pre),
            );

            echo json_encode(array(
                'success' => $isSuccess,
                'data' => $data,
            ));

            exit;
        }
    }

    public function countTestMethods($file) {
        $namespace = $this->extractNamespace($file);

        if($namespace === null) {
            return 0;
        }

        $methods = get_class_methods('\\' . trim($namespace, '\\') . '\\' . basename($file, '.php'));

        if(!\is_array($methods)) {
            return 0;
        }

        $methods = array_filter($methods, function($name) {
            return substr($name, 0, 4) === 'test';
        });

        return count($methods);
    }

    public function renderTable()
    {
        $isTracyInstalled = $this->wire('modules')->isInstalled('TracyDebugger');

        /** @var MarkupAdminDataTable $table */
        $table = $this->wire('modules')->get('MarkupAdminDataTable');
        $table->id = 'pnt-table';
        $table->setEncodeEntities(false);
        $table->addClass('ProcessNetteTester uk-table-striped');

        $table->headerRow(array(
            $this->texts['name'],
            $this->texts['run'],
            $this->texts['result'],
            $this->texts['time'],
        ));

        foreach ($this->testFiles as $file) {
            $attributes = array('data-testfile' => $file);
            $testPath = $this->testDirName . '/' . basename($file);
            $editorAttr = !$isTracyInstalled ? '' : ' data-editor-url="' . ltrim($testPath, '\/') . '"';
            $breadcrumb = str_replace($this->testDirPath, '', $file);
            $tooltipText = $this->testDirName . '/' . $breadcrumb;
            $breadcrumb = str_replace(basename($file), '', $breadcrumb);
            if($breadcrumb !== '') {
                $breadcrumb = '<span class="breadcrumb">' . $breadcrumb . '</span>';
            }
            $testName = '<i class="fa status-icon"></i><span title="' . $tooltipText . '"' . $editorAttr . '>' . $breadcrumb . basename($file, 'Test.php') . '</span>';

            $table->row(array(
                $testName,
                $this->getAjaxButton($file),
                self::EMPTY_VALUE,
                self::EMPTY_VALUE,
            ), $attributes);
        }

        return $table->render();
    }

    public function getAjaxButton($file)
    {
        return '<a href="#" class="run-single ui-button ui-priority-primary" data-url="?testfile=' . $file . '"><i class="fa"></i></a>';
    }

    public function getTexts($key = null)
    {
        $texts = array(
            'test' => $this->_('test'),
            'tests' => $this->_('tests'),
            'assertion' => $this->_('assertion'),
            'assertions' => $this->_('assertions'),
            'run' => $this->_('Start'),
            'stop' => $this->_('Stop'),
            'passed' => $this->_('Passed'),
            'aborted' => $this->_('Aborted'),
            'restart' => $this->_('Restart'),
            'retryFailed' => $this->_('Retry failed'),
            'timedout' => $this->_('Timed out'),
            'total' => $this->_('Total: %f'),
            'intro' => $this->_('All tests loaded from'),
            'introSubset' => $this->_('%d of %s tests loaded from'),
            'help' => $this->_('Click on the main counter to bulk run tests (spacebar). Ctrl+click to reset. Use the checkboxes to control behaviour.'),
            'noTestsFound' => $this->_('No test files found in "%s".'),
            'name' => $this->_('Name'),
            'result' => $this->_('Result'),
            'time' => $this->_('Time'),
            'emptyValue' => self::EMPTY_VALUE,
            'lineNum' => $this->_('on line %s'),
        );

        return $key === null ? $texts : $texts[$key];
    }

    protected function extractNamespace($file) {
        $ns = null;
        $handle = fopen($file, "r");
        if ($handle) {
            while (($line = fgets($handle)) !== false) {
                $line = str_replace('<?php', '', $line);
                $line = trim($line, " \t\r\n\0");
                if (strpos($line, 'namespace') === 0) {
                    $parts = explode(' ', $line);
                    $ns = rtrim(trim($parts[1]), ';');
                    break;
                }
            }
            fclose($handle);
        }
        return $ns;
    }
}