ParaTest\Runners\PHPUnit\SuiteLoader

Complexity

Total Complexity

62

Size/Duplication

Total Lines	304
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

84.33%

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	getSuites()	0	4	1
A	getTestMethods()	0	9	2
A	__construct()	0	4	1
C	load()	0	35	12
A	initSuites()	0	13	4
A	executableTests()	0	11	2
B	getMethodBatches()	0	21	7
A	addDependentTestsToBatchSet()	0	11	4
A	addTestsToBatchSet()	0	13	4
C	getMethodTests()	0	28	7
B	testMatchGroupOptions()	0	20	6
A	testMatchFilterOptions()	0	13	3
A	testMatchOptions()	0	7	2
A	methodDataProvider()	0	6	2
A	methodDependency()	0	6	2
A	methodGroups()	0	8	2
A	createSuite()	0	11	1

<?php

declare(strict_types=1);

namespace ParaTest\Runners\PHPUnit;

use ParaTest\Parser\NoClassInFileException;
use ParaTest\Parser\ParsedClass;
use ParaTest\Parser\ParsedFunction;
use ParaTest\Parser\ParsedObject;
use ParaTest\Parser\Parser;

class SuiteLoader
{
    /**
     * The collection of loaded files.
     *
     * @var array
     */
    protected $files = [];

    /**
     * The collection of parsed test classes.
     *
     * @var array
     */
    protected $loadedSuites = [];

    /**
     * @var Options
     */
    public $options;

    public function __construct(Options $options = null)
    {
        $this->options = $options;
    }

    /**
     * Returns all parsed suite objects as ExecutableTest
     * instances.
     *
     * @return array
     */
    public function getSuites(): array
    {
        return $this->loadedSuites;
    }

    /**
     * Returns a collection of TestMethod objects
     * for all loaded ExecutableTest instances.
     *
     * @return array
     */
    public function getTestMethods(): array
    {
        $methods = [];
        foreach ($this->loadedSuites as $suite) {
            $methods = array_merge($methods, $suite->getFunctions());
        }

        return $methods;
    }

    /**
     * Populates the loaded suite collection. Will load suites
     * based off a phpunit xml configuration or a specified path.
     *
     * @param string $path
     *
     * @throws \RuntimeException
     */
    public function load(string $path = '')
    {
        if (is_object($this->options) && isset($this->options->filtered['configuration'])) {

The property $filtered is declared protected in ParaTest\Runners\PHPUnit\Options. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

            $configuration = $this->options->filtered['configuration'];

The property $filtered is declared protected in ParaTest\Runners\PHPUnit\Options. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

        } else {
            $configuration = new Configuration('');
        }

        if ($path) {
            $testFileLoader = new TestFileLoader($this->options);
            $this->files = array_merge($this->files, $testFileLoader->loadPath($path));
        } elseif (isset($this->options->testsuite) && $this->options->testsuite) {

The property $testsuite is declared protected in ParaTest\Runners\PHPUnit\Options. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

            foreach ($configuration->getSuiteByName($this->options->testsuite) as $suite) {

The property $testsuite is declared protected in ParaTest\Runners\PHPUnit\Options. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

                foreach ($suite as $suitePath) {
                    $testFileLoader = new TestFileLoader($this->options);
                    $this->files = array_merge($this->files, $testFileLoader->loadSuitePath($suitePath));
                }
            }
        } elseif ($suites = $configuration->getSuites()) {
            foreach ($suites as $suite) {
                foreach ($suite as $suitePath) {
                    $testFileLoader = new TestFileLoader($this->options);
                    $this->files = array_merge($this->files, $testFileLoader->loadSuitePath($suitePath));
                }
            }
        }

        if (!$this->files) {

The expression $this->files of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            throw new \RuntimeException('No path or configuration provided (tests must end with Test.php)');
        }

        $this->files = array_unique($this->files); // remove duplicates

        $this->initSuites();
    }

    /**
     * Called after all files are loaded. Parses loaded files into
     * ExecutableTest objects - either Suite or TestMethod.
     */
    private function initSuites()
    {
        foreach ($this->files as $path) {
            try {
                $parser = new Parser($path);
                if ($class = $parser->getClass()) {

Are you sure the assignment to $class is correct as $parser->getClass() (which targets ParaTest\Parser\Parser::getClass()) seems to always return null.

                    $this->loadedSuites[$path] = $this->createSuite($path, $class);
                }
            } catch (NoClassInFileException $e) {
                continue;
            }
        }
    }

    private function executableTests(string $path, ParsedClass $class)
    {
        $executableTests = [];
        $methodBatches = $this->getMethodBatches($class);
        foreach ($methodBatches as $methodBatch) {
            $executableTest = new TestMethod($path, $methodBatch);
            $executableTests[] = $executableTest;
        }

        return $executableTests;
    }

    /**
     * Get method batches.
     *
     * Identify method dependencies, and group dependents and dependees on a single methodBatch.
     * Use max batch size to fill batches.
     *
     * @param ParsedClass $class
     *
     * @return array of MethodBatches. Each MethodBatch has an array of method names
     */
    private function getMethodBatches(ParsedClass $class): array
    {
        $classMethods = $class->getMethods($this->options ? $this->options->annotations : []);

The property $annotations is declared protected in ParaTest\Runners\PHPUnit\Options. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

        $maxBatchSize = $this->options && $this->options->functional ? $this->options->maxBatchSize : 0;

The property $functional is declared protected in ParaTest\Runners\PHPUnit\Options. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

The property $maxBatchSize is declared protected in ParaTest\Runners\PHPUnit\Options. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

        $batches = [];
        foreach ($classMethods as $method) {
            $tests = $this->getMethodTests($class, $method, $maxBatchSize !== 0);
            // if filter passed to paratest then method tests can be blank if not match to filter
            if (!$tests) {

The expression $tests of type string[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

                continue;
            }

            if (($dependsOn = $this->methodDependency($method)) !== null) {
                $this->addDependentTestsToBatchSet($batches, $dependsOn, $tests);
            } else {
                $this->addTestsToBatchSet($batches, $tests, $maxBatchSize);
            }
        }

        return $batches;
    }

    private function addDependentTestsToBatchSet(array &$batches, string $dependsOn, array $tests)
    {
        foreach ($batches as $key => $batch) {
            foreach ($batch as $methodName) {
                if ($dependsOn === $methodName) {
                    $batches[$key] = array_merge($batches[$key], $tests);
                    continue;
                }
            }
        }
    }

    private function addTestsToBatchSet(array &$batches, array $tests, int $maxBatchSize)
    {
        foreach ($tests as $test) {
            $lastIndex = count($batches) - 1;
            if ($lastIndex !== -1
                && count($batches[$lastIndex]) < $maxBatchSize
            ) {
                $batches[$lastIndex][] = $test;
            } else {
                $batches[] = [$test];
            }
        }
    }

    /**
     * Get method all available tests.
     *
     * With empty filter this method returns single test if doesnt' have data provider or
     * data provider is not used and return all test if has data provider and data provider is used.
     *
     * @param ParsedClass  $class           parsed class
     * @param ParsedObject $method          parsed method
     * @param bool         $useDataProvider try to use data provider or not
     *
     * @return string[] array of test names
     */
    private function getMethodTests(ParsedClass $class, ParsedFunction $method, bool $useDataProvider = false): array
    {
        $result = [];

        $groups = $this->methodGroups($method);

        $dataProvider = $this->methodDataProvider($method);
        if ($useDataProvider && isset($dataProvider)) {
            $testFullClassName = '\\' . $class->getName();
            $testClass = new $testFullClassName();
            $result = [];
            $datasetKeys = array_keys($testClass->$dataProvider());
            foreach ($datasetKeys as $key) {
                $test = sprintf(
                    '%s with data set %s',
                    $method->getName(),
                    is_int($key) ? '#' . $key : '"' . $key . '"'
                );
                if ($this->testMatchOptions($class->getName(), $test, $groups)) {
                    $result[] = $test;
                }
            }
        } elseif ($this->testMatchOptions($class->getName(), $method->getName(), $groups)) {
            $result = [$method->getName()];
        }

        return $result;
    }

    private function testMatchGroupOptions(array $groups): bool
    {
        if (empty($groups)) {
            return true;
        }

        if (!empty($this->options->groups)

The property $groups is declared protected in ParaTest\Runners\PHPUnit\Options. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

            && !array_intersect($groups, $this->options->groups)

The property $groups is declared protected in ParaTest\Runners\PHPUnit\Options. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

        ) {
            return false;
        }

        if (!empty($this->options->excludeGroups)

The property $excludeGroups is declared protected in ParaTest\Runners\PHPUnit\Options. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

            && array_intersect($groups, $this->options->excludeGroups)

The property $excludeGroups is declared protected in ParaTest\Runners\PHPUnit\Options. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

        ) {
            return false;
        }

        return true;
    }

    private function testMatchFilterOptions(string $className, string $name): bool
    {
        if (empty($this->options->filter)) {

The property $filter is declared protected in ParaTest\Runners\PHPUnit\Options. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

            return true;
        }

        $re = substr($this->options->filter, 0, 1) === '/'

The property $filter is declared protected in ParaTest\Runners\PHPUnit\Options. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

            ? $this->options->filter

The property $filter is declared protected in ParaTest\Runners\PHPUnit\Options. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

            : '/' . $this->options->filter . '/';

The property $filter is declared protected in ParaTest\Runners\PHPUnit\Options. Since you implemented __get(), maybe consider adding a @property or @property-read annotation. This makes it easier for IDEs to provide auto-completion.

        $fullName = $className . '::' . $name;

        return 1 === preg_match($re, $fullName);
    }

    private function testMatchOptions(string $className, string $name, array $group): bool
    {
        $result = $this->testMatchGroupOptions($group)
                && $this->testMatchFilterOptions($className, $name);

        return $result;
    }

    private function methodDataProvider(ParsedFunction $method)
    {
        if (preg_match("/@\bdataProvider\b \b(.*)\b/", $method->getDocBlock(), $matches)) {
            return $matches[1];
        }
    }

    private function methodDependency(ParsedFunction $method)
    {
        if (preg_match("/@\bdepends\b \b(.*)\b/", $method->getDocBlock(), $matches)) {
            return $matches[1];
        }
    }

    private function methodGroups(ParsedFunction $method)
    {
        if (preg_match_all("/@\bgroup\b \b(.*)\b/", $method->getDocBlock(), $matches)) {
            return $matches[1];
        }

        return [];
    }

    private function createSuite(string $path, ParsedClass $class): Suite
    {
        return new Suite(
            $path,
            $this->executableTests(
                $path,
                $class
            ),
            $class->getName()
        );
    }
}