diff --git a/core/lib/Drupal/Core/Test/Exception/MissingGroupException.php b/core/lib/Drupal/Core/Test/Exception/MissingGroupException.php new file mode 100644 index 0000000000..448b4f5b2d --- /dev/null +++ b/core/lib/Drupal/Core/Test/Exception/MissingGroupException.php @@ -0,0 +1,11 @@ +root = $root; + $this->classLoader = $class_loader; + } + + /** + * Registers test namespaces of all extensions and core test classes. + * + * @return array + * An associative array whose keys are PSR-4 namespace prefixes and whose + * values are directory names. + */ + public function registerTestNamespaces() { + if (isset($this->testNamespaces)) { + return $this->testNamespaces; + } + $this->testNamespaces = []; + + $existing = $this->classLoader->getPrefixesPsr4(); + + // Add PHPUnit test namespaces of Drupal core. + $this->testNamespaces['Drupal\\Tests\\'] = [$this->root . '/core/tests/Drupal/Tests']; + $this->testNamespaces['Drupal\\KernelTests\\'] = [$this->root . '/core/tests/Drupal/KernelTests']; + $this->testNamespaces['Drupal\\FunctionalTests\\'] = [$this->root . '/core/tests/Drupal/FunctionalTests']; + $this->testNamespaces['Drupal\\FunctionalJavascriptTests\\'] = [$this->root . '/core/tests/Drupal/FunctionalJavascriptTests']; + + $this->availableExtensions = []; + foreach ($this->getExtensions() as $name => $extension) { + $this->availableExtensions[$extension->getType()][$name] = $name; + + $base_path = $this->root . '/' . $extension->getPath(); + + // Add namespace of disabled/uninstalled extensions. + if (!isset($existing["Drupal\\$name\\"])) { + $this->classLoader->addPsr4("Drupal\\$name\\", "$base_path/src"); + } + // Add Simpletest test namespace. + $this->testNamespaces["Drupal\\$name\\Tests\\"][] = "$base_path/src/Tests"; + + // Add PHPUnit test namespaces. + $this->testNamespaces["Drupal\\Tests\\$name\\Unit\\"][] = "$base_path/tests/src/Unit"; + $this->testNamespaces["Drupal\\Tests\\$name\\Kernel\\"][] = "$base_path/tests/src/Kernel"; + $this->testNamespaces["Drupal\\Tests\\$name\\Functional\\"][] = "$base_path/tests/src/Functional"; + $this->testNamespaces["Drupal\\Tests\\$name\\FunctionalJavascript\\"][] = "$base_path/tests/src/FunctionalJavascript"; + + // Add discovery for traits which are shared between different test + // suites. + $this->testNamespaces["Drupal\\Tests\\$name\\Traits\\"][] = "$base_path/tests/src/Traits"; + } + + foreach ($this->testNamespaces as $prefix => $paths) { + $this->classLoader->addPsr4($prefix, $paths); + } + + return $this->testNamespaces; + } + + /** + * Discovers all available tests in all extensions. + * + * @param string $extension + * (optional) The name of an extension to limit discovery to; e.g., 'node'. + * @param string[] $types + * An array of included test types. + * + * @return array + * An array of tests keyed by the the group name. If a test is annotated to + * belong to multiple groups, it will appear under all group keys it belongs + * to. + * @code + * $groups['block'] => array( + * 'Drupal\Tests\block\Functional\BlockTest' => array( + * 'name' => 'Drupal\Tests\block\Functional\BlockTest', + * 'description' => 'Tests block UI CRUD functionality.', + * 'group' => 'block', + * 'groups' => ['block', 'group2', 'group3'], + * ), + * ); + * @endcode + * + * @todo Remove singular grouping; retain list of groups in 'group' key. + * @see https://www.drupal.org/node/2296615 + */ + public function getTestClasses($extension = NULL, array $types = []) { + if (!isset($extension) && empty($types)) { + if (!empty($this->testClasses)) { + return $this->testClasses; + } + } + $list = []; + + $classmap = $this->findAllClassFiles($extension); + + // Prevent expensive class loader lookups for each reflected test class by + // registering the complete classmap of test classes to the class loader. + // This also ensures that test classes are loaded from the discovered + // pathnames; a namespace/classname mismatch will throw an exception. + $this->classLoader->addClassMap($classmap); + + foreach ($classmap as $classname => $pathname) { + $finder = MockFileFinder::create($pathname); + $parser = new StaticReflectionParser($classname, $finder, TRUE); + try { + $info = static::getTestInfo($classname, $parser->getDocComment()); + } + catch (MissingGroupException $e) { + // If the class name ends in Test and is not a migrate table dump. + if (preg_match('/Test$/', $classname) && strpos($classname, 'migrate_drupal\Tests\Table') === FALSE) { + throw $e; + } + // If the class is @group annotation just skip it. Most likely it is an + // abstract class, trait or test fixture. + continue; + } + // Skip this test class if it is a Simpletest-based test and requires + // unavailable modules. TestDiscovery should not filter out module + // requirements for PHPUnit-based test classes. + // @todo Move this behavior to \Drupal\simpletest\TestBase so tests can be + // marked as skipped, instead. + // @see https://www.drupal.org/node/1273478 + if ($info['type'] == 'Simpletest') { + if (!empty($info['requires']['module'])) { + if (array_diff($info['requires']['module'], $this->availableExtensions['module'])) { + continue; + } + } + } + + foreach ($info['groups'] as $group) { + $list[$group][$classname] = $info; + } + } + + // Sort the groups and tests within the groups by name. + uksort($list, 'strnatcasecmp'); + foreach ($list as &$tests) { + uksort($tests, 'strnatcasecmp'); + } + + if (!isset($extension) && empty($types)) { + $this->testClasses = $list; + } + + if ($types) { + $list = NestedArray::filter($list, function ($element) use ($types) { + return !(is_array($element) && isset($element['type']) && !in_array($element['type'], $types)); + }); + } + + return $list; + } + + /** + * Discovers all class files in all available extensions. + * + * @param string $extension + * (optional) The name of an extension to limit discovery to; e.g., 'node'. + * + * @return array + * A classmap containing all discovered class files; i.e., a map of + * fully-qualified classnames to pathnames. + */ + public function findAllClassFiles($extension = NULL) { + $classmap = []; + $namespaces = $this->registerTestNamespaces(); + if (isset($extension)) { + // Include tests in the \Drupal\Tests\{$extension} namespace. + $pattern = "/Drupal\\\(Tests\\\)?$extension\\\/"; + $namespaces = array_intersect_key($namespaces, array_flip(preg_grep($pattern, array_keys($namespaces)))); + } + foreach ($namespaces as $namespace => $paths) { + foreach ($paths as $path) { + if (!is_dir($path)) { + continue; + } + $classmap += static::scanDirectory($namespace, $path); + } + } + return $classmap; + } + + /** + * Scans a given directory for class files. + * + * @param string $namespace_prefix + * The namespace prefix to use for discovered classes. Must contain a + * trailing namespace separator (backslash). + * For example: 'Drupal\\node\\Tests\\' + * @param string $path + * The directory path to scan. + * For example: '/path/to/drupal/core/modules/node/tests/src' + * + * @return array + * An associative array whose keys are fully-qualified class names and whose + * values are corresponding filesystem pathnames. + * + * @throws \InvalidArgumentException + * If $namespace_prefix does not end in a namespace separator (backslash). + * + * @todo Limit to '*Test.php' files (~10% less files to reflect/introspect). + * @see https://www.drupal.org/node/2296635 + */ + public static function scanDirectory($namespace_prefix, $path) { + if (substr($namespace_prefix, -1) !== '\\') { + throw new \InvalidArgumentException("Namespace prefix for $path must contain a trailing namespace separator."); + } + $flags = \FilesystemIterator::UNIX_PATHS; + $flags |= \FilesystemIterator::SKIP_DOTS; + $flags |= \FilesystemIterator::FOLLOW_SYMLINKS; + $flags |= \FilesystemIterator::CURRENT_AS_SELF; + $flags |= \FilesystemIterator::KEY_AS_FILENAME; + + $iterator = new \RecursiveDirectoryIterator($path, $flags); + $filter = new \RecursiveCallbackFilterIterator($iterator, function ($current, $file_name, $iterator) { + if ($iterator->hasChildren()) { + return TRUE; + } + // We don't want to discover abstract TestBase classes, traits or + // interfaces. They can be deprecated and will call @trigger_error() + // during discovery. + return substr($file_name, -4) === '.php' && + substr($file_name, -12) !== 'TestBase.php' && + substr($file_name, -9) !== 'Trait.php' && + substr($file_name, -13) !== 'Interface.php'; + }); + $files = new \RecursiveIteratorIterator($filter); + $classes = []; + foreach ($files as $fileinfo) { + $class = $namespace_prefix; + if ('' !== $subpath = $fileinfo->getSubPath()) { + $class .= strtr($subpath, '/', '\\') . '\\'; + } + $class .= $fileinfo->getBasename('.php'); + $classes[$class] = $fileinfo->getPathname(); + } + return $classes; + } + + /** + * Retrieves information about a test class for UI purposes. + * + * @param string $classname + * The test classname. + * @param string $doc_comment + * (optional) The class PHPDoc comment. If not passed in reflection will be + * used but this is very expensive when parsing all the test classes. + * + * @return array + * An associative array containing: + * - name: The test class name. + * - description: The test (PHPDoc) summary. + * - group: The test's first @group (parsed from PHPDoc annotations). + * - groups: All of the test's @group annotations, as an array (parsed from + * PHPDoc annotations). + * - requires: An associative array containing test requirements parsed from + * PHPDoc annotations: + * - module: List of Drupal module extension names the test depends on. + * + * @throws \Drupal\simpletest\Exception\MissingGroupException + * If the class does not have a @group annotation. + */ + public static function getTestInfo($classname, $doc_comment = NULL) { + if ($doc_comment === NULL) { + $reflection = new \ReflectionClass($classname); + $doc_comment = $reflection->getDocComment(); + } + $info = [ + 'name' => $classname, + ]; + $annotations = []; + // Look for annotations, allow an arbitrary amount of spaces before the + // * but nothing else. + preg_match_all('/^[ ]*\* \@([^\s]*) (.*$)/m', $doc_comment, $matches); + if (isset($matches[1])) { + foreach ($matches[1] as $key => $annotation) { + // For historical reasons, there is a single-value 'group' result key + // and a 'groups' key as an array. + if ($annotation === 'group') { + $annotations['groups'][] = $matches[2][$key]; + } + if (!empty($annotations[$annotation])) { + // Only @group is allowed to have more than one annotation, in the + // 'groups' key. Other annotations only have one value per key. + continue; + } + $annotations[$annotation] = $matches[2][$key]; + } + } + + if (empty($annotations['group'])) { + // Concrete tests must have a group. + throw new MissingGroupException(sprintf('Missing @group annotation in %s', $classname)); + } + $info['group'] = $annotations['group']; + $info['groups'] = $annotations['groups']; + + // Sort out PHPUnit-runnable tests by type. + if ($testsuite = static::getPhpunitTestSuite($classname)) { + $info['type'] = 'PHPUnit-' . $testsuite; + } + else { + $info['type'] = 'Simpletest'; + } + + if (!empty($annotations['coversDefaultClass'])) { + $info['description'] = 'Tests ' . $annotations['coversDefaultClass'] . '.'; + } + else { + $info['description'] = static::parseTestClassSummary($doc_comment); + } + if (isset($annotations['dependencies'])) { + $info['requires']['module'] = array_map('trim', explode(',', $annotations['dependencies'])); + } + + return $info; + } + + /** + * Parses the phpDoc summary line of a test class. + * + * @param string $doc_comment + * + * @return string + * The parsed phpDoc summary line. An empty string is returned if no summary + * line can be parsed. + */ + public static function parseTestClassSummary($doc_comment) { + // Normalize line endings. + $doc_comment = preg_replace('/\r\n|\r/', '\n', $doc_comment); + // Strip leading and trailing doc block lines. + $doc_comment = substr($doc_comment, 4, -4); + + $lines = explode("\n", $doc_comment); + $summary = []; + // Add every line to the summary until the first empty line or annotation + // is found. + foreach ($lines as $line) { + if (preg_match('/^[ ]*\*$/', $line) || preg_match('/^[ ]*\* \@/', $line)) { + break; + } + $summary[] = trim($line, ' *'); + } + return implode(' ', $summary); + } + + /** + * Parses annotations in the phpDoc of a test class. + * + * @param \ReflectionClass $class + * The reflected test class. + * + * @return array + * An associative array that contains all annotations on the test class; + * typically including: + * - group: A list of @group values. + * - requires: An associative array of @requires values; e.g.: + * - module: A list of Drupal module dependencies that are required to + * exist. + * + * @see PHPUnit_Util_Test::parseTestMethodAnnotations() + * @see http://phpunit.de/manual/current/en/incomplete-and-skipped-tests.html#incomplete-and-skipped-tests.skipping-tests-using-requires + */ + public static function parseTestClassAnnotations(\ReflectionClass $class) { + $annotations = PHPUnit_Util_Test::parseTestMethodAnnotations($class->getName())['class']; + + // @todo Enhance PHPUnit upstream to allow for custom @requires identifiers. + // @see PHPUnit_Util_Test::getRequirements() + // @todo Add support for 'PHP', 'OS', 'function', 'extension'. + // @see https://www.drupal.org/node/1273478 + if (isset($annotations['requires'])) { + foreach ($annotations['requires'] as $i => $value) { + list($type, $value) = explode(' ', $value, 2); + if ($type === 'module') { + $annotations['requires']['module'][$value] = $value; + unset($annotations['requires'][$i]); + } + } + } + return $annotations; + } + + /** + * Determines the phpunit testsuite for a given classname. + * + * @param string $classname + * The test classname. + * + * @return string|false + * The testsuite name or FALSE if its not a phpunit test. + */ + public static function getPhpunitTestSuite($classname) { + if (preg_match('/Drupal\\\\Tests\\\\Core\\\\(\w+)/', $classname, $matches)) { + return 'Unit'; + } + if (preg_match('/Drupal\\\\Tests\\\\Component\\\\(\w+)/', $classname, $matches)) { + return 'Unit'; + } + // Module tests. + if (preg_match('/Drupal\\\\Tests\\\\(\w+)\\\\(\w+)/', $classname, $matches)) { + return $matches[2]; + } + // Core tests. + elseif (preg_match('/Drupal\\\\(\w*)Tests\\\\/', $classname, $matches)) { + if ($matches[1] == '') { + return 'Unit'; + } + return $matches[1]; + } + return FALSE; + } + + /** + * Returns all available extensions. + * + * @return \Drupal\Core\Extension\Extension[] + * An array of Extension objects, keyed by extension name. + */ + protected function getExtensions() { + $listing = new ExtensionDiscovery($this->root); + // Ensure that tests in all profiles are discovered. + $listing->setProfileDirectories([]); + $extensions = $listing->scan('module', TRUE); + $extensions += $listing->scan('profile', TRUE); + $extensions += $listing->scan('theme', TRUE); + return $extensions; + } + +} diff --git a/core/lib/Drupal/Core/Test/TestRunnerKernel.php b/core/lib/Drupal/Core/Test/TestRunnerKernel.php index b615ce356f..963a6c4e4d 100644 --- a/core/lib/Drupal/Core/Test/TestRunnerKernel.php +++ b/core/lib/Drupal/Core/Test/TestRunnerKernel.php @@ -70,7 +70,11 @@ public function boot() { $this->getContainer()->get('module_handler')->loadAll(); - $this->getContainer()->get('test_discovery')->registerTestNamespaces(); + $test_discovery = new TestDiscovery( + $this->getContainer()->get('app.root'), + $this->getContainer()->get('class_loader') + ); + $test_discovery->registerTestNamespaces(); // Register stream wrappers. $this->getContainer()->get('stream_wrapper_manager')->register(); diff --git a/core/modules/simpletest/simpletest.services.yml b/core/modules/simpletest/simpletest.services.yml index 326cf38f2d..2415197957 100644 --- a/core/modules/simpletest/simpletest.services.yml +++ b/core/modules/simpletest/simpletest.services.yml @@ -1,5 +1,7 @@ services: test_discovery: + # @todo Change this service so that it uses \Drupal\Core\Test\TestDiscovery + # in https://www.drupal.org/node/1667822 class: Drupal\simpletest\TestDiscovery arguments: ['@app.root', '@class_loader', '@module_handler'] cache_context.test_discovery: diff --git a/core/modules/simpletest/src/Exception/MissingGroupException.php b/core/modules/simpletest/src/Exception/MissingGroupException.php index 85a0696ca1..1c595ebbb2 100644 --- a/core/modules/simpletest/src/Exception/MissingGroupException.php +++ b/core/modules/simpletest/src/Exception/MissingGroupException.php @@ -2,8 +2,17 @@ namespace Drupal\simpletest\Exception; +@trigger_error('Deprecated in Drupal 8.8.x for removal before Drupal 9.0.0 release. Use \Drupal\Core\Test\Exception\MissingGroupException instead.', E_USER_DEPRECATED); + +use Drupal\Core\Test\Exception\MissingGroupException as CoreMissingGroupException; + /** * Exception thrown when a simpletest class is missing an @group annotation. + * + * @deprecated in Drupal 8.8.x for removal before Drupal 9.0.0 release. Use + * \Drupal\Core\Test\Exception\MissingGroupException instead. + * + * @see \Drupal\Core\Test\Exception\MissingGroupException */ -class MissingGroupException extends \LogicException { +class MissingGroupException extends CoreMissingGroupException { } diff --git a/core/modules/simpletest/src/TestDiscovery.php b/core/modules/simpletest/src/TestDiscovery.php index a9cbe15db7..d58e3245d9 100644 --- a/core/modules/simpletest/src/TestDiscovery.php +++ b/core/modules/simpletest/src/TestDiscovery.php @@ -5,50 +5,20 @@ use Doctrine\Common\Reflection\StaticReflectionParser; use Drupal\Component\Annotation\Reflection\MockFileFinder; use Drupal\Component\Utility\NestedArray; -use Drupal\Core\Extension\ExtensionDiscovery; use Drupal\Core\Extension\ModuleHandlerInterface; -use Drupal\simpletest\Exception\MissingGroupException; -use PHPUnit_Util_Test; +use Drupal\Core\Test\Exception\MissingGroupException; +use Drupal\Core\Test\TestDiscovery as CoreTestDiscovery; /** * Discovers available tests. + * + * This class provides backwards compatibility for code which uses the legacy + * \Drupal\simpletest\TestDiscovery. + * + * @todo Formally deprecate this class when we decide the fate of the Simpletest + * UI test runner: https://www.drupal.org/project/drupal/issues/2750461 */ -class TestDiscovery { - - /** - * The class loader. - * - * @var \Composer\Autoload\ClassLoader - */ - protected $classLoader; - - /** - * Statically cached list of test classes. - * - * @var array - */ - protected $testClasses; - - /** - * Cached map of all test namespaces to respective directories. - * - * @var array - */ - protected $testNamespaces; - - /** - * Cached list of all available extension names, keyed by extension type. - * - * @var array - */ - protected $availableExtensions; - - /** - * The app root. - * - * @var string - */ - protected $root; +class TestDiscovery extends CoreTestDiscovery { /** * The module handler. @@ -70,66 +40,17 @@ class TestDiscovery { * The module handler. */ public function __construct($root, $class_loader, ModuleHandlerInterface $module_handler) { - $this->root = $root; - $this->classLoader = $class_loader; + parent::__construct($root, $class_loader); $this->moduleHandler = $module_handler; } - /** - * Registers test namespaces of all extensions and core test classes. - * - * @return array - * An associative array whose keys are PSR-4 namespace prefixes and whose - * values are directory names. - */ - public function registerTestNamespaces() { - if (isset($this->testNamespaces)) { - return $this->testNamespaces; - } - $this->testNamespaces = []; - - $existing = $this->classLoader->getPrefixesPsr4(); - - // Add PHPUnit test namespaces of Drupal core. - $this->testNamespaces['Drupal\\Tests\\'] = [$this->root . '/core/tests/Drupal/Tests']; - $this->testNamespaces['Drupal\\KernelTests\\'] = [$this->root . '/core/tests/Drupal/KernelTests']; - $this->testNamespaces['Drupal\\FunctionalTests\\'] = [$this->root . '/core/tests/Drupal/FunctionalTests']; - $this->testNamespaces['Drupal\\FunctionalJavascriptTests\\'] = [$this->root . '/core/tests/Drupal/FunctionalJavascriptTests']; - - $this->availableExtensions = []; - foreach ($this->getExtensions() as $name => $extension) { - $this->availableExtensions[$extension->getType()][$name] = $name; - - $base_path = $this->root . '/' . $extension->getPath(); - - // Add namespace of disabled/uninstalled extensions. - if (!isset($existing["Drupal\\$name\\"])) { - $this->classLoader->addPsr4("Drupal\\$name\\", "$base_path/src"); - } - // Add Simpletest test namespace. - $this->testNamespaces["Drupal\\$name\\Tests\\"][] = "$base_path/src/Tests"; - - // Add PHPUnit test namespaces. - $this->testNamespaces["Drupal\\Tests\\$name\\Unit\\"][] = "$base_path/tests/src/Unit"; - $this->testNamespaces["Drupal\\Tests\\$name\\Kernel\\"][] = "$base_path/tests/src/Kernel"; - $this->testNamespaces["Drupal\\Tests\\$name\\Functional\\"][] = "$base_path/tests/src/Functional"; - $this->testNamespaces["Drupal\\Tests\\$name\\FunctionalJavascript\\"][] = "$base_path/tests/src/FunctionalJavascript"; - - // Add discovery for traits which are shared between different test - // suites. - $this->testNamespaces["Drupal\\Tests\\$name\\Traits\\"][] = "$base_path/tests/src/Traits"; - } - - foreach ($this->testNamespaces as $prefix => $paths) { - $this->classLoader->addPsr4($prefix, $paths); - } - - return $this->testNamespaces; - } - /** * Discovers all available tests in all extensions. * + * This method is a near-duplicate of + * \Drupal\Core\Tests\TestDiscovery::getTestClasses(). It exists so that we + * can provide a BC invocation of hook_simpletest_alter(). + * * @param string $extension * (optional) The name of an extension to limit discovery to; e.g., 'node'. * @param string[] $types @@ -149,9 +70,6 @@ public function registerTestNamespaces() { * ), * ); * @endcode - * - * @todo Remove singular grouping; retain list of groups in 'group' key. - * @see https://www.drupal.org/node/2296615 */ public function getTestClasses($extension = NULL, array $types = []) { if (!isset($extension) && empty($types)) { @@ -225,279 +143,4 @@ public function getTestClasses($extension = NULL, array $types = []) { return $list; } - /** - * Discovers all class files in all available extensions. - * - * @param string $extension - * (optional) The name of an extension to limit discovery to; e.g., 'node'. - * - * @return array - * A classmap containing all discovered class files; i.e., a map of - * fully-qualified classnames to pathnames. - */ - public function findAllClassFiles($extension = NULL) { - $classmap = []; - $namespaces = $this->registerTestNamespaces(); - if (isset($extension)) { - // Include tests in the \Drupal\Tests\{$extension} namespace. - $pattern = "/Drupal\\\(Tests\\\)?$extension\\\/"; - $namespaces = array_intersect_key($namespaces, array_flip(preg_grep($pattern, array_keys($namespaces)))); - } - foreach ($namespaces as $namespace => $paths) { - foreach ($paths as $path) { - if (!is_dir($path)) { - continue; - } - $classmap += static::scanDirectory($namespace, $path); - } - } - return $classmap; - } - - /** - * Scans a given directory for class files. - * - * @param string $namespace_prefix - * The namespace prefix to use for discovered classes. Must contain a - * trailing namespace separator (backslash). - * For example: 'Drupal\\node\\Tests\\' - * @param string $path - * The directory path to scan. - * For example: '/path/to/drupal/core/modules/node/tests/src' - * - * @return array - * An associative array whose keys are fully-qualified class names and whose - * values are corresponding filesystem pathnames. - * - * @throws \InvalidArgumentException - * If $namespace_prefix does not end in a namespace separator (backslash). - * - * @todo Limit to '*Test.php' files (~10% less files to reflect/introspect). - * @see https://www.drupal.org/node/2296635 - */ - public static function scanDirectory($namespace_prefix, $path) { - if (substr($namespace_prefix, -1) !== '\\') { - throw new \InvalidArgumentException("Namespace prefix for $path must contain a trailing namespace separator."); - } - $flags = \FilesystemIterator::UNIX_PATHS; - $flags |= \FilesystemIterator::SKIP_DOTS; - $flags |= \FilesystemIterator::FOLLOW_SYMLINKS; - $flags |= \FilesystemIterator::CURRENT_AS_SELF; - $flags |= \FilesystemIterator::KEY_AS_FILENAME; - - $iterator = new \RecursiveDirectoryIterator($path, $flags); - $filter = new \RecursiveCallbackFilterIterator($iterator, function ($current, $file_name, $iterator) { - if ($iterator->hasChildren()) { - return TRUE; - } - // We don't want to discover abstract TestBase classes, traits or - // interfaces. They can be deprecated and will call @trigger_error() - // during discovery. - return substr($file_name, -4) === '.php' && - substr($file_name, -12) !== 'TestBase.php' && - substr($file_name, -9) !== 'Trait.php' && - substr($file_name, -13) !== 'Interface.php'; - }); - $files = new \RecursiveIteratorIterator($filter); - $classes = []; - foreach ($files as $fileinfo) { - $class = $namespace_prefix; - if ('' !== $subpath = $fileinfo->getSubPath()) { - $class .= strtr($subpath, '/', '\\') . '\\'; - } - $class .= $fileinfo->getBasename('.php'); - $classes[$class] = $fileinfo->getPathname(); - } - return $classes; - } - - /** - * Retrieves information about a test class for UI purposes. - * - * @param string $classname - * The test classname. - * @param string $doc_comment - * (optional) The class PHPDoc comment. If not passed in reflection will be - * used but this is very expensive when parsing all the test classes. - * - * @return array - * An associative array containing: - * - name: The test class name. - * - description: The test (PHPDoc) summary. - * - group: The test's first @group (parsed from PHPDoc annotations). - * - groups: All of the test's @group annotations, as an array (parsed from - * PHPDoc annotations). - * - requires: An associative array containing test requirements parsed from - * PHPDoc annotations: - * - module: List of Drupal module extension names the test depends on. - * - * @throws \Drupal\simpletest\Exception\MissingGroupException - * If the class does not have a @group annotation. - */ - public static function getTestInfo($classname, $doc_comment = NULL) { - if ($doc_comment === NULL) { - $reflection = new \ReflectionClass($classname); - $doc_comment = $reflection->getDocComment(); - } - $info = [ - 'name' => $classname, - ]; - $annotations = []; - // Look for annotations, allow an arbitrary amount of spaces before the - // * but nothing else. - preg_match_all('/^[ ]*\* \@([^\s]*) (.*$)/m', $doc_comment, $matches); - if (isset($matches[1])) { - foreach ($matches[1] as $key => $annotation) { - // For historical reasons, there is a single-value 'group' result key - // and a 'groups' key as an array. - if ($annotation === 'group') { - $annotations['groups'][] = $matches[2][$key]; - } - if (!empty($annotations[$annotation])) { - // Only @group is allowed to have more than one annotation, in the - // 'groups' key. Other annotations only have one value per key. - continue; - } - $annotations[$annotation] = $matches[2][$key]; - } - } - - if (empty($annotations['group'])) { - // Concrete tests must have a group. - throw new MissingGroupException(sprintf('Missing @group annotation in %s', $classname)); - } - $info['group'] = $annotations['group']; - $info['groups'] = $annotations['groups']; - - // Sort out PHPUnit-runnable tests by type. - if ($testsuite = static::getPhpunitTestSuite($classname)) { - $info['type'] = 'PHPUnit-' . $testsuite; - } - else { - $info['type'] = 'Simpletest'; - } - - if (!empty($annotations['coversDefaultClass'])) { - $info['description'] = 'Tests ' . $annotations['coversDefaultClass'] . '.'; - } - else { - $info['description'] = static::parseTestClassSummary($doc_comment); - } - if (isset($annotations['dependencies'])) { - $info['requires']['module'] = array_map('trim', explode(',', $annotations['dependencies'])); - } - - return $info; - } - - /** - * Parses the phpDoc summary line of a test class. - * - * @param string $doc_comment - * - * @return string - * The parsed phpDoc summary line. An empty string is returned if no summary - * line can be parsed. - */ - public static function parseTestClassSummary($doc_comment) { - // Normalize line endings. - $doc_comment = preg_replace('/\r\n|\r/', '\n', $doc_comment); - // Strip leading and trailing doc block lines. - $doc_comment = substr($doc_comment, 4, -4); - - $lines = explode("\n", $doc_comment); - $summary = []; - // Add every line to the summary until the first empty line or annotation - // is found. - foreach ($lines as $line) { - if (preg_match('/^[ ]*\*$/', $line) || preg_match('/^[ ]*\* \@/', $line)) { - break; - } - $summary[] = trim($line, ' *'); - } - return implode(' ', $summary); - } - - /** - * Parses annotations in the phpDoc of a test class. - * - * @param \ReflectionClass $class - * The reflected test class. - * - * @return array - * An associative array that contains all annotations on the test class; - * typically including: - * - group: A list of @group values. - * - requires: An associative array of @requires values; e.g.: - * - module: A list of Drupal module dependencies that are required to - * exist. - * - * @see PHPUnit_Util_Test::parseTestMethodAnnotations() - * @see http://phpunit.de/manual/current/en/incomplete-and-skipped-tests.html#incomplete-and-skipped-tests.skipping-tests-using-requires - */ - public static function parseTestClassAnnotations(\ReflectionClass $class) { - $annotations = PHPUnit_Util_Test::parseTestMethodAnnotations($class->getName())['class']; - - // @todo Enhance PHPUnit upstream to allow for custom @requires identifiers. - // @see PHPUnit_Util_Test::getRequirements() - // @todo Add support for 'PHP', 'OS', 'function', 'extension'. - // @see https://www.drupal.org/node/1273478 - if (isset($annotations['requires'])) { - foreach ($annotations['requires'] as $i => $value) { - list($type, $value) = explode(' ', $value, 2); - if ($type === 'module') { - $annotations['requires']['module'][$value] = $value; - unset($annotations['requires'][$i]); - } - } - } - return $annotations; - } - - /** - * Determines the phpunit testsuite for a given classname. - * - * @param string $classname - * The test classname. - * - * @return string|false - * The testsuite name or FALSE if its not a phpunit test. - */ - public static function getPhpunitTestSuite($classname) { - if (preg_match('/Drupal\\\\Tests\\\\Core\\\\(\w+)/', $classname, $matches)) { - return 'Unit'; - } - if (preg_match('/Drupal\\\\Tests\\\\Component\\\\(\w+)/', $classname, $matches)) { - return 'Unit'; - } - // Module tests. - if (preg_match('/Drupal\\\\Tests\\\\(\w+)\\\\(\w+)/', $classname, $matches)) { - return $matches[2]; - } - // Core tests. - elseif (preg_match('/Drupal\\\\(\w*)Tests\\\\/', $classname, $matches)) { - if ($matches[1] == '') { - return 'Unit'; - } - return $matches[1]; - } - return FALSE; - } - - /** - * Returns all available extensions. - * - * @return \Drupal\Core\Extension\Extension[] - * An array of Extension objects, keyed by extension name. - */ - protected function getExtensions() { - $listing = new ExtensionDiscovery($this->root); - // Ensure that tests in all profiles are discovered. - $listing->setProfileDirectories([]); - $extensions = $listing->scan('module', TRUE); - $extensions += $listing->scan('profile', TRUE); - $extensions += $listing->scan('theme', TRUE); - return $extensions; - } - } diff --git a/core/modules/simpletest/tests/src/Functional/ThroughUITest.php b/core/modules/simpletest/tests/src/Functional/ThroughUITest.php index 48737433f3..1e325e4c55 100644 --- a/core/modules/simpletest/tests/src/Functional/ThroughUITest.php +++ b/core/modules/simpletest/tests/src/Functional/ThroughUITest.php @@ -10,6 +10,7 @@ * @see \Drupal\simpletest\Tests::testTestingThroughUI() * * @group simpletest + * @group legacy */ class ThroughUITest extends BrowserTestBase { diff --git a/core/modules/simpletest/tests/src/Kernel/SimpletestDeprecationTest.php b/core/modules/simpletest/tests/src/Kernel/SimpletestDeprecationTest.php index 384f8c1b9b..7ab1cf7dd0 100644 --- a/core/modules/simpletest/tests/src/Kernel/SimpletestDeprecationTest.php +++ b/core/modules/simpletest/tests/src/Kernel/SimpletestDeprecationTest.php @@ -5,7 +5,7 @@ use Drupal\KernelTests\KernelTestBase; /** - * Verify deprecation of simpletest. + * Verify deprecations within the simpletest module. * * @group simpletest * @group legacy diff --git a/core/modules/simpletest/tests/src/Kernel/TestDiscoveryDeprecationTest.php b/core/modules/simpletest/tests/src/Kernel/TestDiscoveryDeprecationTest.php index 6d4f44888a..c9c781d278 100644 --- a/core/modules/simpletest/tests/src/Kernel/TestDiscoveryDeprecationTest.php +++ b/core/modules/simpletest/tests/src/Kernel/TestDiscoveryDeprecationTest.php @@ -3,6 +3,7 @@ namespace Drupal\Tests\simpletest\Kernel; use Drupal\KernelTests\KernelTestBase; +use Drupal\simpletest\TestDiscovery; /** * @group simpletest @@ -22,11 +23,13 @@ class TestDiscoveryDeprecationTest extends KernelTestBase { * @covers ::getTestClasses */ public function testHookSimpletestAlter() { + $test_discovery = $this->container->get('test_discovery'); + + $this->assertEquals(TestDiscovery::class, get_class($test_discovery)); + // The simpletest_test module implements hook_simpletest_alter(), which // should trigger a deprecation error during getTestClasses(). - $this->assertNotEmpty( - $this->container->get('test_discovery')->getTestClasses() - ); + $this->assertNotEmpty($test_discovery->getTestClasses()); } } diff --git a/core/modules/simpletest/tests/src/Unit/TestDiscoveryTest.php b/core/modules/simpletest/tests/src/Unit/TestDiscoveryTest.php index 7bf10a0664..1474b5427e 100644 --- a/core/modules/simpletest/tests/src/Unit/TestDiscoveryTest.php +++ b/core/modules/simpletest/tests/src/Unit/TestDiscoveryTest.php @@ -7,7 +7,7 @@ use Drupal\Core\DrupalKernel; use Drupal\Core\Extension\Extension; use Drupal\Core\Extension\ModuleHandlerInterface; -use Drupal\simpletest\Exception\MissingGroupException; +use Drupal\Core\Test\Exception\MissingGroupException; use Drupal\simpletest\TestDiscovery; use Drupal\Tests\UnitTestCase; use org\bovigo\vfs\vfsStream; @@ -363,19 +363,34 @@ class FunctionalExampleTest {} } /** - * @covers ::getTestClasses + * Mock a TestDiscovery object to return specific extension values. */ - public function testGetTestClasses() { - $this->setupVfsWithTestClasses(); + protected function getTestDiscoveryMock($app_root, $extensions) { $class_loader = $this->prophesize(ClassLoader::class); $module_handler = $this->prophesize(ModuleHandlerInterface::class); - $test_discovery = new TestTestDiscovery('vfs://drupal', $class_loader->reveal(), $module_handler->reveal()); + $test_discovery = $this->getMockBuilder(TestDiscovery::class) + ->setConstructorArgs([$app_root, $class_loader->reveal(), $module_handler->reveal()]) + ->setMethods(['getExtensions']) + ->getMock(); + $test_discovery->expects($this->any()) + ->method('getExtensions') + ->willReturn($extensions); + + return $test_discovery; + } + + /** + * @covers ::getTestClasses + */ + public function testGetTestClasses() { + $this->setupVfsWithTestClasses(); $extensions = [ 'test_module' => new Extension('vfs://drupal', 'module', 'modules/test_module/test_module.info.yml'), ]; - $test_discovery->setExtensions($extensions); + $test_discovery = $this->getTestDiscoveryMock('vfs://drupal', $extensions); + $result = $test_discovery->getTestClasses(); $this->assertCount(3, $result); $this->assertEquals([ @@ -421,16 +436,12 @@ public function testGetTestClasses() { */ public function testGetTestClassesWithSelectedTypes() { $this->setupVfsWithTestClasses(); - $class_loader = $this->prophesize(ClassLoader::class); - $module_handler = $this->prophesize(ModuleHandlerInterface::class); - - $test_discovery = new TestTestDiscovery('vfs://drupal', $class_loader->reveal(), $module_handler->reveal()); - $extensions = [ 'test_module' => new Extension('vfs://drupal', 'module', 'modules/test_module/test_module.info.yml'), 'test_profile_module' => new Extension('vfs://drupal', 'profile', 'profiles/test_profile/modules/test_profile_module/test_profile_module.info.yml'), ]; - $test_discovery->setExtensions($extensions); + $test_discovery = $this->getTestDiscoveryMock('vfs://drupal', $extensions); + $result = $test_discovery->getTestClasses(NULL, ['PHPUnit-Kernel']); $this->assertCount(4, $result); $this->assertEquals([ diff --git a/core/scripts/run-tests copy.sh.php b/core/scripts/run-tests copy.sh.php new file mode 100755 index 0000000000..c509bdb376 --- /dev/null +++ b/core/scripts/run-tests copy.sh.php @@ -0,0 +1,1594 @@ +getTestClasses($args['module']); + } + catch (Exception $e) { + error_log((string) $e); + echo (string) $e; + exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION); + } + + // A given class can appear in multiple groups. For historical reasons, we + // need to present each test only once. The test is shown in the group that is + // printed first. + $printed_tests = []; + foreach ($groups as $group => $tests) { + echo $group . "\n"; + $tests = array_diff(array_keys($tests), $printed_tests); + foreach ($tests as $test) { + echo " - $test\n"; + } + $printed_tests = array_merge($printed_tests, $tests); + } + exit(SIMPLETEST_SCRIPT_EXIT_SUCCESS); +} + +// List-files and list-files-json provide a way for external tools such as the +// testbot to prioritize running changed tests. +// @see https://www.drupal.org/node/2569585 +if ($args['list-files'] || $args['list-files-json']) { + // List all files which could be run as tests. + $test_discovery = NULL; + try { + $test_discovery = \Drupal::service('test_discovery'); + } + catch (Exception $e) { + error_log((string) $e); + echo (string) $e; + exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION); + } + // TestDiscovery::findAllClassFiles() gives us a classmap similar to a + // Composer 'classmap' array. + $test_classes = $test_discovery->findAllClassFiles(); + // JSON output is the easiest. + if ($args['list-files-json']) { + echo json_encode($test_classes); + exit(SIMPLETEST_SCRIPT_EXIT_SUCCESS); + } + // Output the list of files. + else { + foreach (array_values($test_classes) as $test_class) { + echo $test_class . "\n"; + } + } + exit(SIMPLETEST_SCRIPT_EXIT_SUCCESS); +} + +simpletest_script_setup_database(TRUE); + +if ($args['clean']) { + // Clean up left-over tables and directories. + try { + simpletest_clean_environment(); + } + catch (Exception $e) { + echo (string) $e; + exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION); + } + echo "\nEnvironment cleaned.\n"; + + // Get the status messages and print them. + $messages = \Drupal::messenger()->messagesByType('status'); + foreach ($messages as $text) { + echo " - " . $text . "\n"; + } + exit(SIMPLETEST_SCRIPT_EXIT_SUCCESS); +} + +// Ensure we have the correct PHPUnit version for the version of PHP. +if (class_exists('\PHPUnit_Runner_Version')) { + $phpunit_version = \PHPUnit_Runner_Version::id(); +} +else { + $phpunit_version = Version::id(); +} + +$test_list = simpletest_script_get_test_list(); + +// Try to allocate unlimited time to run the tests. +drupal_set_time_limit(0); +simpletest_script_reporter_init(); + +$tests_to_run = []; +for ($i = 0; $i < $args['repeat']; $i++) { + $tests_to_run = array_merge($tests_to_run, $test_list); +} + +// Execute tests. +$status = simpletest_script_execute_batch($tests_to_run); + +// Stop the timer. +simpletest_script_reporter_timer_stop(); + +// Ensure all test locks are released once finished. If tests are run with a +// concurrency of 1 the each test will clean up its own lock. Test locks are +// not released if using a higher concurrency to ensure each test method has +// unique fixtures. +TestDatabase::releaseAllTestLocks(); + +// Display results before database is cleared. +if ($args['browser']) { + simpletest_script_open_browser(); +} +else { + simpletest_script_reporter_display_results(); +} + +if ($args['xml']) { + simpletest_script_reporter_write_xml_results(); +} + +// Clean up all test results. +if (!$args['keep-results']) { + try { + simpletest_clean_results_table(); + } + catch (Exception $e) { + echo (string) $e; + exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION); + } +} + +// Test complete, exit. +exit($status); + +/** + * Print help text. + */ +function simpletest_script_help() { + global $args; + + echo << +Example: {$args['script']} Profile + +All arguments are long options. + + --help Print this page. + + --list Display all available test groups. + + --list-files + Display all discoverable test file paths. + + --list-files-json + Display all discoverable test files as JSON. The array key will be + the test class name, and the value will be the file path of the + test. + + --clean Cleans up database tables or directories from previous, failed, + tests and then exits (no tests are run). + + --url The base URL of the root directory of this Drupal checkout; e.g.: + http://drupal.test/ + Required unless the Drupal root directory maps exactly to: + http://localhost:80/ + Use a https:// URL to force all tests to be run under SSL. + + --sqlite A pathname to use for the SQLite database of the test runner. + Required unless this script is executed with a working Drupal + installation that has Simpletest module installed. + A relative pathname is interpreted relative to the Drupal root + directory. + Note that ':memory:' cannot be used, because this script spawns + sub-processes. However, you may use e.g. '/tmpfs/test.sqlite' + + --keep-results-table + + Boolean flag to indicate to not cleanup the simpletest result + table. For testbots or repeated execution of a single test it can + be helpful to not cleanup the simpletest result table. + + --dburl A URI denoting the database driver, credentials, server hostname, + and database name to use in tests. + Required when running tests without a Drupal installation that + contains default database connection info in settings.php. + Examples: + mysql://username:password@localhost/databasename#table_prefix + sqlite://localhost/relative/path/db.sqlite + sqlite://localhost//absolute/path/db.sqlite + + --php The absolute path to the PHP executable. Usually not needed. + + --concurrency [num] + + Run tests in parallel, up to [num] tests at a time. + + --all Run all available tests. + + --module Run all tests belonging to the specified module name. + (e.g., 'node') + + --class Run tests identified by specific class names, instead of group names. + A specific test method can be added, for example, + 'Drupal\book\Tests\BookTest::testBookExport'. + + --file Run tests identified by specific file names, instead of group names. + Specify the path and the extension + (i.e. 'core/modules/user/user.test'). + + --types + + Runs just tests from the specified test type, for example + run-tests.sh + (i.e. --types "Simpletest,PHPUnit-Functional") + + --directory Run all tests found within the specified file directory. + + --xml + + If provided, test results will be written as xml files to this path. + + --color Output text format results with color highlighting. + + --verbose Output detailed assertion messages in addition to summary. + + --keep-results + + Keeps detailed assertion results (in the database) after tests + have completed. By default, assertion results are cleared. + + --repeat Number of times to repeat the test. + + --die-on-fail + + Exit test execution immediately upon any failed assertion. This + allows to access the test site by changing settings.php to use the + test database and configuration directories. Use in combination + with --repeat for debugging random test failures. + + --browser Opens the results in the browser. This enforces --keep-results and + if you want to also view any pages rendered in the simpletest + browser you need to add --verbose to the command line. + + --non-html Removes escaping from output. Useful for reading results on the + CLI. + + --suppress-deprecations + + Stops tests from failing if deprecation errors are triggered. If + this is not set the value specified in the + SYMFONY_DEPRECATIONS_HELPER environment variable, or the value + specified in core/phpunit.xml (if it exists), or the default value + will be used. The default is that any unexpected silenced + deprecation error will fail tests. + + [,[, ...]] + + One or more tests to be run. By default, these are interpreted + as the names of test groups as shown at + admin/config/development/testing. + These group names typically correspond to module names like "User" + or "Profile" or "System", but there is also a group "Database". + If --class is specified then these are interpreted as the names of + specific test classes whose test methods will be run. Tests must + be separated by commas. Ignored if --all is specified. + +To run this script you will normally invoke it from the root directory of your +Drupal installation as the webserver user (differs per configuration), or root: + +sudo -u [wwwrun|www-data|etc] php ./core/scripts/{$args['script']} + --url http://example.com/ --all +sudo -u [wwwrun|www-data|etc] php ./core/scripts/{$args['script']} + --url http://example.com/ --class "Drupal\block\Tests\BlockTest" + +Without a preinstalled Drupal site and enabled Simpletest module, specify a +SQLite database pathname to create and the default database connection info to +use in tests: + +sudo -u [wwwrun|www-data|etc] php ./core/scripts/{$args['script']} + --sqlite /tmpfs/drupal/test.sqlite + --dburl mysql://username:password@localhost/database + --url http://example.com/ --all + +EOF; +} + +/** + * Parse execution argument and ensure that all are valid. + * + * @return array + * The list of arguments. + */ +function simpletest_script_parse_args() { + // Set default values. + $args = [ + 'script' => '', + 'help' => FALSE, + 'list' => FALSE, + 'list-files' => FALSE, + 'list-files-json' => FALSE, + 'clean' => FALSE, + 'url' => '', + 'sqlite' => NULL, + 'dburl' => NULL, + 'php' => '', + 'concurrency' => 1, + 'all' => FALSE, + 'module' => NULL, + 'class' => FALSE, + 'file' => FALSE, + 'types' => [], + 'directory' => NULL, + 'color' => FALSE, + 'verbose' => FALSE, + 'keep-results' => FALSE, + 'keep-results-table' => FALSE, + 'test_names' => [], + 'repeat' => 1, + 'die-on-fail' => FALSE, + 'suppress-deprecations' => FALSE, + 'browser' => FALSE, + // Used internally. + 'test-id' => 0, + 'execute-test' => '', + 'xml' => '', + 'non-html' => FALSE, + ]; + + // Override with set values. + $args['script'] = basename(array_shift($_SERVER['argv'])); + + $count = 0; + while ($arg = array_shift($_SERVER['argv'])) { + if (preg_match('/--(\S+)/', $arg, $matches)) { + // Argument found. + if (array_key_exists($matches[1], $args)) { + // Argument found in list. + $previous_arg = $matches[1]; + if (is_bool($args[$previous_arg])) { + $args[$matches[1]] = TRUE; + } + elseif (is_array($args[$previous_arg])) { + $value = array_shift($_SERVER['argv']); + $args[$matches[1]] = array_map('trim', explode(',', $value)); + } + else { + $args[$matches[1]] = array_shift($_SERVER['argv']); + } + // Clear extraneous values. + $args['test_names'] = []; + $count++; + } + else { + // Argument not found in list. + simpletest_script_print_error("Unknown argument '$arg'."); + exit(SIMPLETEST_SCRIPT_EXIT_FAILURE); + } + } + else { + // Values found without an argument should be test names. + $args['test_names'] += explode(',', $arg); + $count++; + } + } + + // Validate the concurrency argument. + if (!is_numeric($args['concurrency']) || $args['concurrency'] <= 0) { + simpletest_script_print_error("--concurrency must be a strictly positive integer."); + exit(SIMPLETEST_SCRIPT_EXIT_FAILURE); + } + + if ($args['browser']) { + $args['keep-results'] = TRUE; + } + return [$args, $count]; +} + +/** + * Initialize script variables and perform general setup requirements. + */ +function simpletest_script_init() { + global $args, $php; + + $host = 'localhost'; + $path = ''; + $port = '80'; + + // Determine location of php command automatically, unless a command line + // argument is supplied. + if (!empty($args['php'])) { + $php = $args['php']; + } + elseif ($php_env = getenv('_')) { + // '_' is an environment variable set by the shell. It contains the command + // that was executed. + $php = $php_env; + } + elseif ($sudo = getenv('SUDO_COMMAND')) { + // 'SUDO_COMMAND' is an environment variable set by the sudo program. + // Extract only the PHP interpreter, not the rest of the command. + list($php) = explode(' ', $sudo, 2); + } + else { + simpletest_script_print_error('Unable to automatically determine the path to the PHP interpreter. Supply the --php command line argument.'); + simpletest_script_help(); + exit(SIMPLETEST_SCRIPT_EXIT_FAILURE); + } + + $autoloader = require_once __DIR__ . '/../../autoload.php'; + + // Get URL from arguments. + if (!empty($args['url'])) { + $parsed_url = parse_url($args['url']); + $host = $parsed_url['host'] . (isset($parsed_url['port']) ? ':' . $parsed_url['port'] : ''); + $path = isset($parsed_url['path']) ? rtrim(rtrim($parsed_url['path']), '/') : ''; + $port = (isset($parsed_url['port']) ? $parsed_url['port'] : $port); + if ($path == '/') { + $path = ''; + } + // If the passed URL schema is 'https' then setup the $_SERVER variables + // properly so that testing will run under HTTPS. + if ($parsed_url['scheme'] == 'https') { + $_SERVER['HTTPS'] = 'on'; + } + } + + if (isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] === 'on') { + $base_url = 'https://'; + } + else { + $base_url = 'http://'; + } + $base_url .= $host; + if ($path !== '') { + $base_url .= $path; + } + putenv('SIMPLETEST_BASE_URL=' . $base_url); + $_SERVER['HTTP_HOST'] = $host; + $_SERVER['REMOTE_ADDR'] = '127.0.0.1'; + $_SERVER['SERVER_ADDR'] = '127.0.0.1'; + $_SERVER['SERVER_PORT'] = $port; + $_SERVER['SERVER_SOFTWARE'] = NULL; + $_SERVER['SERVER_NAME'] = 'localhost'; + $_SERVER['REQUEST_URI'] = $path . '/'; + $_SERVER['REQUEST_METHOD'] = 'GET'; + $_SERVER['SCRIPT_NAME'] = $path . '/index.php'; + $_SERVER['SCRIPT_FILENAME'] = $path . '/index.php'; + $_SERVER['PHP_SELF'] = $path . '/index.php'; + $_SERVER['HTTP_USER_AGENT'] = 'Drupal command line'; + + if ($args['concurrency'] > 1) { + $directory = FileSystem::getOsTemporaryDirectory(); + $test_symlink = @symlink(__FILE__, $directory . '/test_symlink'); + if (!$test_symlink) { + throw new \RuntimeException('In order to use a concurrency higher than 1 the test system needs to be able to create symlinks in ' . $directory); + } + unlink($directory . '/test_symlink'); + putenv('RUN_TESTS_CONCURRENCY=' . $args['concurrency']); + } + + if (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] == 'on') { + // Ensure that any and all environment variables are changed to https://. + foreach ($_SERVER as $key => $value) { + $_SERVER[$key] = str_replace('http://', 'https://', $_SERVER[$key]); + } + } + + chdir(realpath(__DIR__ . '/../..')); + + // Prepare the kernel. + try { + $request = Request::createFromGlobals(); + $kernel = TestRunnerKernel::createFromRequest($request, $autoloader); + $kernel->prepareLegacyRequest($request); + } + catch (Exception $e) { + echo (string) $e; + exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION); + } +} + +/** + * Sets up database connection info for running tests. + * + * If this script is executed from within a real Drupal installation, then this + * function essentially performs nothing (unless the --sqlite or --dburl + * parameters were passed). + * + * Otherwise, there are three database connections of concern: + * - --sqlite: The test runner connection, providing access to Simpletest + * database tables for recording test IDs and assertion results. + * - --dburl: A database connection that is used as base connection info for all + * tests; i.e., every test will spawn from this connection. In case this + * connection uses e.g. SQLite, then all tests will run against SQLite. This + * is exposed as $databases['default']['default'] to Drupal. + * - The actual database connection used within a test. This is the same as + * --dburl, but uses an additional database table prefix. This is + * $databases['default']['default'] within a test environment. The original + * connection is retained in + * $databases['simpletest_original_default']['default'] and restored after + * each test. + * + * @param bool $new + * Whether this process is a run-tests.sh master process. If TRUE, the SQLite + * database file specified by --sqlite (if any) is set up. Otherwise, database + * connections are prepared only. + */ +function simpletest_script_setup_database($new = FALSE) { + global $args; + + // If there is an existing Drupal installation that contains a database + // connection info in settings.php, then $databases['default']['default'] will + // hold the default database connection already. This connection is assumed to + // be valid, and this connection will be used in tests, so that they run + // against e.g. MySQL instead of SQLite. + // However, in case no Drupal installation exists, this default database + // connection can be set and/or overridden with the --dburl parameter. + if (!empty($args['dburl'])) { + // Remove a possibly existing default connection (from settings.php). + Database::removeConnection('default'); + try { + $databases['default']['default'] = Database::convertDbUrlToConnectionInfo($args['dburl'], DRUPAL_ROOT); + } + catch (\InvalidArgumentException $e) { + simpletest_script_print_error('Invalid --dburl. Reason: ' . $e->getMessage()); + exit(SIMPLETEST_SCRIPT_EXIT_FAILURE); + } + } + // Otherwise, use the default database connection from settings.php. + else { + $databases['default'] = Database::getConnectionInfo('default'); + } + + // If there is no default database connection for tests, we cannot continue. + if (!isset($databases['default']['default'])) { + simpletest_script_print_error('Missing default database connection for tests. Use --dburl to specify one.'); + exit(SIMPLETEST_SCRIPT_EXIT_FAILURE); + } + Database::addConnectionInfo('default', 'default', $databases['default']['default']); + + // If no --sqlite parameter has been passed, then Simpletest module is assumed + // to be installed, so the test runner database connection is the default + // database connection. + if (empty($args['sqlite'])) { + $sqlite = FALSE; + $databases['test-runner']['default'] = $databases['default']['default']; + } + // Otherwise, set up a SQLite connection for the test runner. + else { + if ($args['sqlite'][0] === '/') { + $sqlite = $args['sqlite']; + } + else { + $sqlite = DRUPAL_ROOT . '/' . $args['sqlite']; + } + $databases['test-runner']['default'] = [ + 'driver' => 'sqlite', + 'database' => $sqlite, + 'prefix' => [ + 'default' => '', + ], + ]; + // Create the test runner SQLite database, unless it exists already. + if ($new && !file_exists($sqlite)) { + if (!is_dir(dirname($sqlite))) { + mkdir(dirname($sqlite)); + } + touch($sqlite); + } + } + + // Add the test runner database connection. + Database::addConnectionInfo('test-runner', 'default', $databases['test-runner']['default']); + + // Create the Simpletest schema. + try { + $connection = Database::getConnection('default', 'test-runner'); + $schema = $connection->schema(); + } + catch (\PDOException $e) { + simpletest_script_print_error($databases['test-runner']['default']['driver'] . ': ' . $e->getMessage()); + exit(SIMPLETEST_SCRIPT_EXIT_FAILURE); + } + if ($new && $sqlite) { + require_once DRUPAL_ROOT . '/' . drupal_get_path('module', 'simpletest') . '/simpletest.install'; + foreach (simpletest_schema() as $name => $table_spec) { + try { + $table_exists = $schema->tableExists($name); + if (empty($args['keep-results-table']) && $table_exists) { + $connection->truncate($name)->execute(); + } + if (!$table_exists) { + $schema->createTable($name, $table_spec); + } + } + catch (Exception $e) { + echo (string) $e; + exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION); + } + } + } + // Verify that the Simpletest database schema exists by checking one table. + try { + if (!$schema->tableExists('simpletest')) { + simpletest_script_print_error('Missing Simpletest database schema. Either install Simpletest module or use the --sqlite parameter.'); + exit(SIMPLETEST_SCRIPT_EXIT_FAILURE); + } + } + catch (Exception $e) { + echo (string) $e; + exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION); + } +} + +/** + * Execute a batch of tests. + */ +function simpletest_script_execute_batch($test_classes) { + global $args, $test_ids; + + $total_status = SIMPLETEST_SCRIPT_EXIT_SUCCESS; + + // Multi-process execution. + $children = []; + while (!empty($test_classes) || !empty($children)) { + while (count($children) < $args['concurrency']) { + if (empty($test_classes)) { + break; + } + + try { + $test_id = Database::getConnection('default', 'test-runner') + ->insert('simpletest_test_id') + ->useDefaults(['test_id']) + ->execute(); + } + catch (Exception $e) { + echo (string) $e; + exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION); + } + $test_ids[] = $test_id; + + $test_class = array_shift($test_classes); + // Fork a child process. + $command = simpletest_script_command($test_id, $test_class); + $process = proc_open($command, [], $pipes, NULL, NULL, ['bypass_shell' => TRUE]); + + if (!is_resource($process)) { + echo "Unable to fork test process. Aborting.\n"; + exit(SIMPLETEST_SCRIPT_EXIT_SUCCESS); + } + + // Register our new child. + $children[] = [ + 'process' => $process, + 'test_id' => $test_id, + 'class' => $test_class, + 'pipes' => $pipes, + ]; + } + + // Wait for children every 200ms. + usleep(200000); + + // Check if some children finished. + foreach ($children as $cid => $child) { + $status = proc_get_status($child['process']); + if (empty($status['running'])) { + // The child exited, unregister it. + proc_close($child['process']); + if ($status['exitcode'] === SIMPLETEST_SCRIPT_EXIT_FAILURE) { + $total_status = max($status['exitcode'], $total_status); + } + elseif ($status['exitcode']) { + $message = 'FATAL ' . $child['class'] . ': test runner returned a non-zero error code (' . $status['exitcode'] . ').'; + echo $message . "\n"; + // @todo Return SIMPLETEST_SCRIPT_EXIT_EXCEPTION instead, when + // DrupalCI supports this. + // @see https://www.drupal.org/node/2780087 + $total_status = max(SIMPLETEST_SCRIPT_EXIT_FAILURE, $total_status); + // Insert a fail for xml results. + simpletest_insert_assert($child['test_id'], $child['class'], FALSE, $message, 'run-tests.sh check'); + // Ensure that an error line is displayed for the class. + simpletest_script_reporter_display_summary( + $child['class'], + ['#pass' => 0, '#fail' => 1, '#exception' => 0, '#debug' => 0] + ); + if ($args['die-on-fail']) { + list($db_prefix) = simpletest_last_test_get($child['test_id']); + $test_db = new TestDatabase($db_prefix); + $test_directory = $test_db->getTestSitePath(); + echo 'Simpletest database and files kept and test exited immediately on fail so should be reproducible if you change settings.php to use the database prefix ' . $db_prefix . ' and config directories in ' . $test_directory . "\n"; + $args['keep-results'] = TRUE; + // Exit repeat loop immediately. + $args['repeat'] = -1; + } + } + // Free-up space by removing any potentially created resources. + if (!$args['keep-results']) { + simpletest_script_cleanup($child['test_id'], $child['class'], $status['exitcode']); + } + + // Remove this child. + unset($children[$cid]); + } + } + } + return $total_status; +} + +/** + * Run a PHPUnit-based test. + */ +function simpletest_script_run_phpunit($test_id, $class) { + $reflection = new \ReflectionClass($class); + if ($reflection->hasProperty('runLimit')) { + set_time_limit($reflection->getStaticPropertyValue('runLimit')); + } + + $results = simpletest_run_phpunit_tests($test_id, [$class], $status); + simpletest_process_phpunit_results($results); + + // Map phpunit results to a data structure we can pass to + // simpletest_script_reporter_display_summary. + $summaries = simpletest_summarize_phpunit_result($results); + foreach ($summaries as $class => $summary) { + simpletest_script_reporter_display_summary($class, $summary); + } + return $status; +} + +/** + * Run a single test, bootstrapping Drupal if needed. + */ +function simpletest_script_run_one_test($test_id, $test_class) { + global $args; + + try { + if (strpos($test_class, '::') > 0) { + list($class_name, $method) = explode('::', $test_class, 2); + $methods = [$method]; + } + else { + $class_name = $test_class; + // Use empty array to run all the test methods. + $methods = []; + } + $test = new $class_name($test_id); + if ($args['suppress-deprecations']) { + putenv('SYMFONY_DEPRECATIONS_HELPER=disabled'); + } + if (is_subclass_of($test_class, TestCase::class)) { + $status = simpletest_script_run_phpunit($test_id, $test_class); + } + else { + $test->dieOnFail = (bool) $args['die-on-fail']; + $test->verbose = (bool) $args['verbose']; + $test->run($methods); + simpletest_script_reporter_display_summary($test_class, $test->results); + + $status = SIMPLETEST_SCRIPT_EXIT_SUCCESS; + // Finished, kill this runner. + if ($test->results['#fail'] || $test->results['#exception']) { + $status = SIMPLETEST_SCRIPT_EXIT_FAILURE; + } + } + + exit($status); + } + // DrupalTestCase::run() catches exceptions already, so this is only reached + // when an exception is thrown in the wrapping test runner environment. + catch (Exception $e) { + echo (string) $e; + exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION); + } +} + +/** + * Return a command used to run a test in a separate process. + * + * @param int $test_id + * The current test ID. + * @param string $test_class + * The name of the test class to run. + * + * @return string + * The assembled command string. + */ +function simpletest_script_command($test_id, $test_class) { + global $args, $php; + + $command = escapeshellarg($php) . ' ' . escapeshellarg('./core/scripts/' . $args['script']); + $command .= ' --url ' . escapeshellarg($args['url']); + if (!empty($args['sqlite'])) { + $command .= ' --sqlite ' . escapeshellarg($args['sqlite']); + } + if (!empty($args['dburl'])) { + $command .= ' --dburl ' . escapeshellarg($args['dburl']); + } + $command .= ' --php ' . escapeshellarg($php); + $command .= " --test-id $test_id"; + foreach (['verbose', 'keep-results', 'color', 'die-on-fail', 'suppress-deprecations'] as $arg) { + if ($args[$arg]) { + $command .= ' --' . $arg; + } + } + // --execute-test and class name needs to come last. + $command .= ' --execute-test ' . escapeshellarg($test_class); + return $command; +} + +/** + * Removes all remnants of a test runner. + * + * In case a (e.g., fatal) error occurs after the test site has been fully setup + * and the error happens in many tests, the environment that executes the tests + * can easily run out of memory or disk space. This function ensures that all + * created resources are properly cleaned up after every executed test. + * + * This clean-up only exists in this script, since SimpleTest module itself does + * not use isolated sub-processes for each test being run, so a fatal error + * halts not only the test, but also the test runner (i.e., the parent site). + * + * @param int $test_id + * The test ID of the test run. + * @param string $test_class + * The class name of the test run. + * @param int $exitcode + * The exit code of the test runner. + * + * @see simpletest_script_run_one_test() + */ +function simpletest_script_cleanup($test_id, $test_class, $exitcode) { + if (is_subclass_of($test_class, TestCase::class)) { + // PHPUnit test, move on. + return; + } + // Retrieve the last database prefix used for testing. + try { + list($db_prefix) = simpletest_last_test_get($test_id); + } + catch (Exception $e) { + echo (string) $e; + exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION); + } + + // If no database prefix was found, then the test was not set up correctly. + if (empty($db_prefix)) { + echo "\nFATAL $test_class: Found no database prefix for test ID $test_id. (Check whether setUp() is invoked correctly.)"; + return; + } + + // Do not output verbose cleanup messages in case of a positive exitcode. + $output = !empty($exitcode); + $messages = []; + + $messages[] = "- Found database prefix '$db_prefix' for test ID $test_id."; + + // Read the log file in case any fatal errors caused the test to crash. + try { + simpletest_log_read($test_id, $db_prefix, $test_class); + } + catch (Exception $e) { + echo (string) $e; + exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION); + } + + // Check whether a test site directory was setup already. + // @see \Drupal\simpletest\TestBase::prepareEnvironment() + $test_db = new TestDatabase($db_prefix); + $test_directory = DRUPAL_ROOT . '/' . $test_db->getTestSitePath(); + if (is_dir($test_directory)) { + // Output the error_log. + if (is_file($test_directory . '/error.log')) { + if ($errors = file_get_contents($test_directory . '/error.log')) { + $output = TRUE; + $messages[] = $errors; + } + } + // Delete the test site directory. + // simpletest_clean_temporary_directories() cannot be used here, since it + // would also delete file directories of other tests that are potentially + // running concurrently. + try { + \Drupal::service('file_system')->deleteRecursive($test_directory, ['\Drupal\Tests\BrowserTestBase', 'filePreDeleteCallback']); + $messages[] = "- Removed test site directory."; + } + catch (FileException $e) { + // Ignore failed deletes. + } + } + + // Clear out all database tables from the test. + try { + $schema = Database::getConnection('default', 'default')->schema(); + $count = 0; + foreach ($schema->findTables($db_prefix . '%') as $table) { + $schema->dropTable($table); + $count++; + } + } + catch (Exception $e) { + echo (string) $e; + exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION); + } + + if ($count) { + $messages[] = "- Removed $count leftover tables."; + } + + if ($output) { + echo implode("\n", $messages); + echo "\n"; + } +} + +/** + * Get list of tests based on arguments. + * + * If --all specified then return all available tests, otherwise reads list of + * tests. + * + * @return array + * List of tests. + */ +function simpletest_script_get_test_list() { + global $args; + + /** $test_discovery \Drupal\simpletest\TestDiscovery */ + $test_discovery = \Drupal::service('test_discovery'); + $types_processed = empty($args['types']); + $test_list = []; + if ($args['all'] || $args['module']) { + try { + $groups = $test_discovery->getTestClasses($args['module'], $args['types']); + $types_processed = TRUE; + } + catch (Exception $e) { + echo (string) $e; + exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION); + } + $all_tests = []; + foreach ($groups as $group => $tests) { + $all_tests = array_merge($all_tests, array_keys($tests)); + } + $test_list = array_unique($all_tests); + } + else { + if ($args['class']) { + $test_list = []; + foreach ($args['test_names'] as $test_class) { + list($class_name) = explode('::', $test_class, 2); + if (class_exists($class_name)) { + $test_list[] = $test_class; + } + else { + try { + $groups = $test_discovery->getTestClasses(NULL, $args['types']); + } + catch (Exception $e) { + echo (string) $e; + exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION); + } + $all_classes = []; + foreach ($groups as $group) { + $all_classes = array_merge($all_classes, array_keys($group)); + } + simpletest_script_print_error('Test class not found: ' . $class_name); + simpletest_script_print_alternatives($class_name, $all_classes, 6); + exit(SIMPLETEST_SCRIPT_EXIT_FAILURE); + } + } + } + elseif ($args['file']) { + // Extract test case class names from specified files. + foreach ($args['test_names'] as $file) { + if (!file_exists($file)) { + simpletest_script_print_error('File not found: ' . $file); + exit(SIMPLETEST_SCRIPT_EXIT_FAILURE); + } + $content = file_get_contents($file); + // Extract a potential namespace. + $namespace = FALSE; + if (preg_match('@^namespace ([^ ;]+)@m', $content, $matches)) { + $namespace = $matches[1]; + } + // Extract all class names. + // Abstract classes are excluded on purpose. + preg_match_all('@^class ([^ ]+)@m', $content, $matches); + if (!$namespace) { + $test_list = array_merge($test_list, $matches[1]); + } + else { + foreach ($matches[1] as $class_name) { + $namespace_class = $namespace . '\\' . $class_name; + if (is_subclass_of($namespace_class, '\Drupal\simpletest\TestBase') || is_subclass_of($namespace_class, TestCase::class)) { + $test_list[] = $namespace_class; + } + } + } + } + } + elseif ($args['directory']) { + // Extract test case class names from specified directory. + // Find all tests in the PSR-X structure; Drupal\$extension\Tests\*.php + // Since we do not want to hard-code too many structural file/directory + // assumptions about PSR-4 files and directories, we check for the + // minimal conditions only; i.e., a '*.php' file that has '/Tests/' in + // its path. + // Ignore anything from third party vendors. + $ignore = ['.', '..', 'vendor']; + $files = []; + if ($args['directory'][0] === '/') { + $directory = $args['directory']; + } + else { + $directory = DRUPAL_ROOT . "/" . $args['directory']; + } + foreach (file_scan_directory($directory, '/\.php$/', $ignore) as $file) { + // '/Tests/' can be contained anywhere in the file's path (there can be + // sub-directories below /Tests), but must be contained literally. + // Case-insensitive to match all Simpletest and PHPUnit tests: + // ./lib/Drupal/foo/Tests/Bar/Baz.php + // ./foo/src/Tests/Bar/Baz.php + // ./foo/tests/Drupal/foo/Tests/FooTest.php + // ./foo/tests/src/FooTest.php + // $file->filename doesn't give us a directory, so we use $file->uri + // Strip the drupal root directory and trailing slash off the URI. + $filename = substr($file->uri, strlen(DRUPAL_ROOT) + 1); + if (stripos($filename, '/Tests/')) { + $files[$filename] = $filename; + } + } + foreach ($files as $file) { + $content = file_get_contents($file); + // Extract a potential namespace. + $namespace = FALSE; + if (preg_match('@^\s*namespace ([^ ;]+)@m', $content, $matches)) { + $namespace = $matches[1]; + } + // Extract all class names. + // Abstract classes are excluded on purpose. + preg_match_all('@^\s*class ([^ ]+)@m', $content, $matches); + if (!$namespace) { + $test_list = array_merge($test_list, $matches[1]); + } + else { + foreach ($matches[1] as $class_name) { + $namespace_class = $namespace . '\\' . $class_name; + if (is_subclass_of($namespace_class, '\Drupal\simpletest\TestBase') || is_subclass_of($namespace_class, TestCase::class)) { + $test_list[] = $namespace_class; + } + } + } + } + } + else { + try { + $groups = $test_discovery->getTestClasses(NULL, $args['types']); + $types_processed = TRUE; + } + catch (Exception $e) { + echo (string) $e; + exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION); + } + // Store all the groups so we can suggest alternatives if we need to. + $all_groups = array_keys($groups); + // Verify that the groups exist. + if (!empty($unknown_groups = array_diff($args['test_names'], $all_groups))) { + $first_group = reset($unknown_groups); + simpletest_script_print_error('Test group not found: ' . $first_group); + simpletest_script_print_alternatives($first_group, $all_groups); + exit(SIMPLETEST_SCRIPT_EXIT_FAILURE); + } + // Ensure our list of tests contains only one entry for each test. + foreach ($args['test_names'] as $group_name) { + $test_list = array_merge($test_list, array_flip(array_keys($groups[$group_name]))); + } + $test_list = array_flip($test_list); + } + } + + // If the test list creation does not automatically limit by test type then + // we need to do so here. + if (!$types_processed) { + $test_list = array_filter($test_list, function ($test_class) use ($args) { + $test_info = TestDiscovery::getTestInfo($test_class); + return in_array($test_info['type'], $args['types'], TRUE); + }); + } + + if (empty($test_list)) { + simpletest_script_print_error('No valid tests were specified.'); + exit(SIMPLETEST_SCRIPT_EXIT_FAILURE); + } + return $test_list; +} + +/** + * Initialize the reporter. + */ +function simpletest_script_reporter_init() { + global $args, $test_list, $results_map; + + $results_map = [ + 'pass' => 'Pass', + 'fail' => 'Fail', + 'exception' => 'Exception', + ]; + + echo "\n"; + echo "Drupal test run\n"; + echo "---------------\n"; + echo "\n"; + + // Tell the user about what tests are to be run. + if ($args['all']) { + echo "All tests will run.\n\n"; + } + else { + echo "Tests to be run:\n"; + foreach ($test_list as $class_name) { + echo " - $class_name\n"; + } + echo "\n"; + } + + echo "Test run started:\n"; + echo " " . date('l, F j, Y - H:i', $_SERVER['REQUEST_TIME']) . "\n"; + Timer::start('run-tests'); + echo "\n"; + + echo "Test summary\n"; + echo "------------\n"; + echo "\n"; +} + +/** + * Displays the assertion result summary for a single test class. + * + * @param string $class + * The test class name that was run. + * @param array $results + * The assertion results using #pass, #fail, #exception, #debug array keys. + */ +function simpletest_script_reporter_display_summary($class, $results) { + // Output all test results vertically aligned. + // Cut off the class name after 60 chars, and pad each group with 3 digits + // by default (more than 999 assertions are rare). + $output = vsprintf('%-60.60s %10s %9s %14s %12s', [ + $class, + $results['#pass'] . ' passes', + !$results['#fail'] ? '' : $results['#fail'] . ' fails', + !$results['#exception'] ? '' : $results['#exception'] . ' exceptions', + !$results['#debug'] ? '' : $results['#debug'] . ' messages', + ]); + + $status = ($results['#fail'] || $results['#exception'] ? 'fail' : 'pass'); + simpletest_script_print($output . "\n", simpletest_script_color_code($status)); +} + +/** + * Display jUnit XML test results. + */ +function simpletest_script_reporter_write_xml_results() { + global $args, $test_ids, $results_map; + + try { + $results = simpletest_script_load_messages_by_test_id($test_ids); + } + catch (Exception $e) { + echo (string) $e; + exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION); + } + + $test_class = ''; + $xml_files = []; + + foreach ($results as $result) { + if (isset($results_map[$result->status])) { + if ($result->test_class != $test_class) { + // We've moved onto a new class, so write the last classes results to a + // file: + if (isset($xml_files[$test_class])) { + file_put_contents($args['xml'] . '/' . str_replace('\\', '_', $test_class) . '.xml', $xml_files[$test_class]['doc']->saveXML()); + unset($xml_files[$test_class]); + } + $test_class = $result->test_class; + if (!isset($xml_files[$test_class])) { + $doc = new DomDocument('1.0'); + $root = $doc->createElement('testsuite'); + $root = $doc->appendChild($root); + $xml_files[$test_class] = ['doc' => $doc, 'suite' => $root]; + } + } + + // For convenience: + $dom_document = &$xml_files[$test_class]['doc']; + + // Create the XML element for this test case: + $case = $dom_document->createElement('testcase'); + $case->setAttribute('classname', $test_class); + if (strpos($result->function, '->') !== FALSE) { + list($class, $name) = explode('->', $result->function, 2); + } + else { + $name = $result->function; + } + $case->setAttribute('name', $name); + + // Passes get no further attention, but failures and exceptions get to add + // more detail: + if ($result->status == 'fail') { + $fail = $dom_document->createElement('failure'); + $fail->setAttribute('type', 'failure'); + $fail->setAttribute('message', $result->message_group); + $text = $dom_document->createTextNode($result->message); + $fail->appendChild($text); + $case->appendChild($fail); + } + elseif ($result->status == 'exception') { + // In the case of an exception the $result->function may not be a class + // method so we record the full function name: + $case->setAttribute('name', $result->function); + + $fail = $dom_document->createElement('error'); + $fail->setAttribute('type', 'exception'); + $fail->setAttribute('message', $result->message_group); + $full_message = $result->message . "\n\nline: " . $result->line . "\nfile: " . $result->file; + $text = $dom_document->createTextNode($full_message); + $fail->appendChild($text); + $case->appendChild($fail); + } + // Append the test case XML to the test suite: + $xml_files[$test_class]['suite']->appendChild($case); + } + } + // The last test case hasn't been saved to a file yet, so do that now: + if (isset($xml_files[$test_class])) { + file_put_contents($args['xml'] . '/' . str_replace('\\', '_', $test_class) . '.xml', $xml_files[$test_class]['doc']->saveXML()); + unset($xml_files[$test_class]); + } +} + +/** + * Stop the test timer. + */ +function simpletest_script_reporter_timer_stop() { + echo "\n"; + $end = Timer::stop('run-tests'); + echo "Test run duration: " . \Drupal::service('date.formatter')->formatInterval($end['time'] / 1000); + echo "\n\n"; +} + +/** + * Display test results. + */ +function simpletest_script_reporter_display_results() { + global $args, $test_ids, $results_map; + + if ($args['verbose']) { + // Report results. + echo "Detailed test results\n"; + echo "---------------------\n"; + + try { + $results = simpletest_script_load_messages_by_test_id($test_ids); + } + catch (Exception $e) { + echo (string) $e; + exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION); + } + $test_class = ''; + foreach ($results as $result) { + if (isset($results_map[$result->status])) { + if ($result->test_class != $test_class) { + // Display test class every time results are for new test class. + echo "\n\n---- $result->test_class ----\n\n\n"; + $test_class = $result->test_class; + + // Print table header. + echo "Status Group Filename Line Function \n"; + echo "--------------------------------------------------------------------------------\n"; + } + + simpletest_script_format_result($result); + } + } + } +} + +/** + * Format the result so that it fits within 80 characters. + * + * @param object $result + * The result object to format. + */ +function simpletest_script_format_result($result) { + global $args, $results_map, $color; + + $summary = sprintf("%-9.9s %-10.10s %-17.17s %4.4s %-35.35s\n", + $results_map[$result->status], $result->message_group, basename($result->file), $result->line, $result->function); + + simpletest_script_print($summary, simpletest_script_color_code($result->status)); + + $message = trim(strip_tags($result->message)); + if ($args['non-html']) { + $message = Html::decodeEntities($message, ENT_QUOTES, 'UTF-8'); + } + $lines = explode("\n", wordwrap($message), 76); + foreach ($lines as $line) { + echo " $line\n"; + } +} + +/** + * Print error messages so the user will notice them. + * + * Print error message prefixed with " ERROR: " and displayed in fail color if + * color output is enabled. + * + * @param string $message + * The message to print. + */ +function simpletest_script_print_error($message) { + simpletest_script_print(" ERROR: $message\n", SIMPLETEST_SCRIPT_COLOR_FAIL); +} + +/** + * Print a message to the console, using a color. + * + * @param string $message + * The message to print. + * @param int $color_code + * The color code to use for coloring. + */ +function simpletest_script_print($message, $color_code) { + global $args; + if ($args['color']) { + echo "\033[" . $color_code . "m" . $message . "\033[0m"; + } + else { + echo $message; + } +} + +/** + * Get the color code associated with the specified status. + * + * @param string $status + * The status string to get code for. Special cases are: 'pass', 'fail', or + * 'exception'. + * + * @return int + * Color code. Returns 0 for default case. + */ +function simpletest_script_color_code($status) { + switch ($status) { + case 'pass': + return SIMPLETEST_SCRIPT_COLOR_PASS; + + case 'fail': + return SIMPLETEST_SCRIPT_COLOR_FAIL; + + case 'exception': + return SIMPLETEST_SCRIPT_COLOR_EXCEPTION; + } + // Default formatting. + return 0; +} + +/** + * Prints alternative test names. + * + * Searches the provided array of string values for close matches based on the + * Levenshtein algorithm. + * + * @param string $string + * A string to test. + * @param array $array + * A list of strings to search. + * @param int $degree + * The matching strictness. Higher values return fewer matches. A value of + * 4 means that the function will return strings from $array if the candidate + * string in $array would be identical to $string by changing 1/4 or fewer of + * its characters. + * + * @see http://php.net/manual/function.levenshtein.php + */ +function simpletest_script_print_alternatives($string, $array, $degree = 4) { + $alternatives = []; + foreach ($array as $item) { + $lev = levenshtein($string, $item); + if ($lev <= strlen($item) / $degree || FALSE !== strpos($string, $item)) { + $alternatives[] = $item; + } + } + if (!empty($alternatives)) { + simpletest_script_print(" Did you mean?\n", SIMPLETEST_SCRIPT_COLOR_FAIL); + foreach ($alternatives as $alternative) { + simpletest_script_print(" - $alternative\n", SIMPLETEST_SCRIPT_COLOR_FAIL); + } + } +} + +/** + * Loads the simpletest messages from the database. + * + * Messages are ordered by test class and message id. + * + * @param array $test_ids + * Array of test IDs of the messages to be loaded. + * + * @return array + * Array of simpletest messages from the database. + */ +function simpletest_script_load_messages_by_test_id($test_ids) { + global $args; + $results = []; + + // Sqlite has a maximum number of variables per query. If required, the + // database query is split into chunks. + if (count($test_ids) > SIMPLETEST_SCRIPT_SQLITE_VARIABLE_LIMIT && !empty($args['sqlite'])) { + $test_id_chunks = array_chunk($test_ids, SIMPLETEST_SCRIPT_SQLITE_VARIABLE_LIMIT); + } + else { + $test_id_chunks = [$test_ids]; + } + + foreach ($test_id_chunks as $test_id_chunk) { + try { + $result_chunk = Database::getConnection('default', 'test-runner') + ->query("SELECT * FROM {simpletest} WHERE test_id IN ( :test_ids[] ) ORDER BY test_class, message_id", [ + ':test_ids[]' => $test_id_chunk, + ])->fetchAll(); + } + catch (Exception $e) { + echo (string) $e; + exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION); + } + if ($result_chunk) { + $results = array_merge($results, $result_chunk); + } + } + + return $results; +} + +/** + * Display test results. + */ +function simpletest_script_open_browser() { + global $test_ids; + + try { + $connection = Database::getConnection('default', 'test-runner'); + $results = $connection->select('simpletest') + ->fields('simpletest') + ->condition('test_id', $test_ids, 'IN') + ->orderBy('test_class') + ->orderBy('message_id') + ->execute() + ->fetchAll(); + } + catch (Exception $e) { + echo (string) $e; + exit(SIMPLETEST_SCRIPT_EXIT_EXCEPTION); + } + + // Get the results form. + $form = []; + TestingUiResultsForm::addResultForm($form, $results); + + // Get the assets to make the details element collapsible and theme the result + // form. + $assets = new AttachedAssets(); + $assets->setLibraries([ + 'core/drupal.collapse', + 'system/admin', + 'testing_ui/drupal.testing_ui', + ]); + $resolver = \Drupal::service('asset.resolver'); + list($js_assets_header, $js_assets_footer) = $resolver->getJsAssets($assets, FALSE); + $js_collection_renderer = \Drupal::service('asset.js.collection_renderer'); + $js_assets_header = $js_collection_renderer->render($js_assets_header); + $js_assets_footer = $js_collection_renderer->render($js_assets_footer); + $css_assets = \Drupal::service('asset.css.collection_renderer')->render($resolver->getCssAssets($assets, FALSE)); + + // Make the html page to write to disk. + $render_service = \Drupal::service('renderer'); + $html = '' . $render_service->renderPlain($js_assets_header) . $render_service->renderPlain($css_assets) . '' . $render_service->renderPlain($form) . $render_service->renderPlain($js_assets_footer) . ''; + + // Ensure we have assets verbose directory - tests with no verbose output will + // not have created one. + $directory = PublicStream::basePath() . '/simpletest/verbose'; + \Drupal::service('file_system')->prepareDirectory($directory, FileSystemInterface::CREATE_DIRECTORY | FileSystemInterface::MODIFY_PERMISSIONS); + $php = new Php(); + $uuid = $php->generate(); + $filename = $directory . '/results-' . $uuid . '.html'; + $base_url = getenv('SIMPLETEST_BASE_URL'); + if (empty($base_url)) { + simpletest_script_print_error("--browser needs argument --url."); + } + $url = $base_url . '/' . PublicStream::basePath() . '/simpletest/verbose/results-' . $uuid . '.html'; + file_put_contents($filename, $html); + + // See if we can find an OS helper to open URLs in default browser. + $browser = FALSE; + if (shell_exec('which xdg-open')) { + $browser = 'xdg-open'; + } + elseif (shell_exec('which open')) { + $browser = 'open'; + } + elseif (substr(PHP_OS, 0, 3) == 'WIN') { + $browser = 'start'; + } + + if ($browser) { + shell_exec($browser . ' ' . escapeshellarg($url)); + } + else { + // Can't find assets valid browser. + print 'Open file://' . realpath($filename) . ' in your browser to see the verbose output.'; + } +} diff --git a/core/scripts/run-tests.sh b/core/scripts/run-tests.sh index f08956e61f..94da3cde5c 100755 --- a/core/scripts/run-tests.sh +++ b/core/scripts/run-tests.sh @@ -18,7 +18,7 @@ use Drupal\Core\Test\TestRunnerKernel; use Drupal\simpletest\Form\SimpletestResultsForm; use Drupal\simpletest\TestBase; -use Drupal\simpletest\TestDiscovery; +use Drupal\Core\Test\TestDiscovery; use PHPUnit\Framework\TestCase; use PHPUnit\Runner\Version; use Symfony\Component\HttpFoundation\Request; @@ -65,6 +65,8 @@ echo "\nAvailable test groups & classes\n"; echo "-------------------------------\n\n"; try { + // @todo Use \Drupal\Core\Test\TestDiscovery when we no longer need BC for + // hook_simpletest_alter(). $groups = \Drupal::service('test_discovery')->getTestClasses($args['module']); } catch (Exception $e) { @@ -95,6 +97,8 @@ // List all files which could be run as tests. $test_discovery = NULL; try { + // @todo Use \Drupal\Core\Test\TestDiscovery when we no longer need BC for + // hook_simpletest_alter(). $test_discovery = \Drupal::service('test_discovery'); } catch (Exception $e) { @@ -994,6 +998,8 @@ function simpletest_script_cleanup($test_id, $test_class, $exitcode) { function simpletest_script_get_test_list() { global $args; + // @todo Use \Drupal\Core\Test\TestDiscovery when we no longer need BC for + // hook_simpletest_alter(). /** $test_discovery \Drupal\simpletest\TestDiscovery */ $test_discovery = \Drupal::service('test_discovery'); $types_processed = empty($args['types']); diff --git a/core/tests/Drupal/Tests/Core/Test/TestDiscoveryTest.php b/core/tests/Drupal/Tests/Core/Test/TestDiscoveryTest.php new file mode 100644 index 0000000000..8d1b3d4fe6 --- /dev/null +++ b/core/tests/Drupal/Tests/Core/Test/TestDiscoveryTest.php @@ -0,0 +1,568 @@ +assertEquals($expected, $info); + } + + public function infoParserProvider() { + // A module provided unit test. + $tests[] = [ + // Expected result. + [ + 'name' => static::class, + 'group' => 'Test', + 'groups' => [ + 'Test', + 'simpletest', + ], + 'description' => 'Tests \Drupal\Core\Test\TestDiscovery.', + 'type' => 'PHPUnit-Unit', + ], + // Classname. + static::class, + ]; + + // A core unit test. + $tests[] = [ + // Expected result. + [ + 'name' => 'Drupal\Tests\Core\DrupalTest', + 'group' => 'DrupalTest', + 'groups' => ['DrupalTest'], + 'description' => 'Tests \Drupal.', + 'type' => 'PHPUnit-Unit', + ], + // Classname. + 'Drupal\Tests\Core\DrupalTest', + ]; + + // Functional PHPUnit test. + $tests[] = [ + // Expected result. + [ + 'name' => 'Drupal\FunctionalTests\BrowserTestBaseTest', + 'group' => 'browsertestbase', + 'groups' => ['browsertestbase'], + 'description' => 'Tests BrowserTestBase functionality.', + 'type' => 'PHPUnit-Functional', + ], + // Classname. + 'Drupal\FunctionalTests\BrowserTestBaseTest', + ]; + + // kernel PHPUnit test. + $tests['phpunit-kernel'] = [ + // Expected result. + [ + 'name' => '\Drupal\Tests\file\Kernel\FileItemValidationTest', + 'group' => 'file', + 'groups' => ['file'], + 'description' => 'Tests that files referenced in file and image fields are always validated.', + 'type' => 'PHPUnit-Kernel', + ], + // Classname. + '\Drupal\Tests\file\Kernel\FileItemValidationTest', + ]; + + // Simpletest classes can not be autoloaded in a PHPUnit test, therefore + // provide a docblock. + $tests[] = [ + // Expected result. + [ + 'name' => 'Drupal\simpletest\Tests\ExampleSimpleTest', + 'group' => 'simpletest', + 'groups' => ['simpletest'], + 'description' => 'Tests the Simpletest UI internal browser.', + 'type' => 'Simpletest', + ], + // Classname. + 'Drupal\simpletest\Tests\ExampleSimpleTest', + // Doc block. + "/** + * Tests the Simpletest UI internal browser. + * + * @group simpletest + */ + ", + ]; + + // Test with a different amount of leading spaces. + $tests[] = [ + // Expected result. + [ + 'name' => 'Drupal\simpletest\Tests\ExampleSimpleTest', + 'group' => 'simpletest', + 'groups' => ['simpletest'], + 'description' => 'Tests the Simpletest UI internal browser.', + 'type' => 'Simpletest', + ], + // Classname. + 'Drupal\simpletest\Tests\ExampleSimpleTest', + // Doc block. + "/** + * Tests the Simpletest UI internal browser. + * + * @group simpletest + */ + */ + ", + ]; + + // Make sure that a "* @" inside a string does not get parsed as an + // annotation. + $tests[] = [ + // Expected result. + [ + 'name' => 'Drupal\simpletest\Tests\ExampleSimpleTest', + 'group' => 'simpletest', + 'groups' => ['simpletest'], + 'description' => 'Tests the Simpletest UI internal browser. * @', + 'type' => 'Simpletest', + ], + // Classname. + 'Drupal\simpletest\Tests\ExampleSimpleTest', + // Doc block. + "/** + * Tests the Simpletest UI internal browser. * @ + * + * @group simpletest + */ + ", + ]; + + // Multiple @group annotations. + $tests[] = [ + // Expected result. + [ + 'name' => 'Drupal\simpletest\Tests\ExampleSimpleTest', + 'group' => 'Test', + 'groups' => ['Test', 'simpletest'], + 'description' => 'Tests the Simpletest UI internal browser.', + 'type' => 'Simpletest', + ], + // Classname. + 'Drupal\simpletest\Tests\ExampleSimpleTest', + // Doc block. + "/** + * Tests the Simpletest UI internal browser. + * + * @group Test + * @group simpletest + */ + ", + ]; + + // A great number of @group annotations. + $tests['many-group-annotations'] = [ + // Expected result. + [ + 'name' => 'Drupal\simpletest\Tests\ExampleSimpleTest', + 'group' => 'Test', + 'groups' => ['Test', 'simpletest', 'another', 'more', 'many', 'enough', 'whoa'], + 'description' => 'Tests the Simpletest UI internal browser.', + 'type' => 'Simpletest', + ], + // Classname. + 'Drupal\simpletest\Tests\ExampleSimpleTest', + // Doc block. + "/** + * Tests the Simpletest UI internal browser. + * + * @group Test + * @group simpletest + * @group another + * @group more + * @group many + * @group enough + * @group whoa + */ + ", + ]; + + // @dependencies annotation. + $tests[] = [ + // Expected result. + [ + 'name' => 'Drupal\simpletest\Tests\ExampleSimpleTest', + 'description' => 'Tests the Simpletest UI internal browser.', + 'type' => 'Simpletest', + 'requires' => ['module' => ['test']], + 'group' => 'simpletest', + 'groups' => ['simpletest'], + ], + // Classname. + 'Drupal\simpletest\Tests\ExampleSimpleTest', + // Doc block. + "/** + * Tests the Simpletest UI internal browser. + * + * @dependencies test + * @group simpletest + */ + ", + ]; + + // Multiple @dependencies annotation. + $tests[] = [ + // Expected result. + [ + 'name' => 'Drupal\simpletest\Tests\ExampleSimpleTest', + 'description' => 'Tests the Simpletest UI internal browser.', + 'type' => 'Simpletest', + 'requires' => ['module' => ['test', 'test1', 'test2']], + 'group' => 'simpletest', + 'groups' => ['simpletest'], + ], + // Classname. + 'Drupal\simpletest\Tests\ExampleSimpleTest', + // Doc block. + "/** + * Tests the Simpletest UI internal browser. + * + * @dependencies test, test1, test2 + * @group simpletest + */ + ", + ]; + + // Multi-line summary line. + $tests[] = [ + // Expected result. + [ + 'name' => 'Drupal\simpletest\Tests\ExampleSimpleTest', + 'description' => 'Tests the Simpletest UI internal browser. And the summary line continues an there is no gap to the annotation.', + 'type' => 'Simpletest', + 'group' => 'simpletest', + 'groups' => ['simpletest'], + ], + // Classname. + 'Drupal\simpletest\Tests\ExampleSimpleTest', + // Doc block. + "/** + * Tests the Simpletest UI internal browser. And the summary line continues an + * there is no gap to the annotation. + * + * @group simpletest + */ + ", + ]; + return $tests; + } + + /** + * @covers ::getTestInfo + */ + public function testTestInfoParserMissingGroup() { + $classname = 'Drupal\KernelTests\field\BulkDeleteTest'; + $doc_comment = <<expectException(MissingGroupException::class); + $this->expectExceptionMessage('Missing @group annotation in Drupal\KernelTests\field\BulkDeleteTest'); + TestDiscovery::getTestInfo($classname, $doc_comment); + } + + /** + * @covers ::getTestInfo + */ + public function testTestInfoParserMissingSummary() { + $classname = 'Drupal\KernelTests\field\BulkDeleteTest'; + $doc_comment = <<assertEmpty($info['description']); + } + + protected function setupVfsWithTestClasses() { + vfsStream::setup('drupal'); + + $test_file = << [ + 'test_module' => [ + 'tests' => [ + 'src' => [ + 'Functional' => [ + 'FunctionalExampleTest.php' => $test_file, + 'FunctionalExampleTest2.php' => str_replace(['FunctionalExampleTest', '@group example'], ['FunctionalExampleTest2', '@group example2'], $test_file), + ], + 'Kernel' => [ + 'KernelExampleTest3.php' => str_replace(['FunctionalExampleTest', '@group example'], ['KernelExampleTest3', "@group example2\n * @group kernel\n"], $test_file), + 'KernelExampleTestBase.php' => str_replace(['FunctionalExampleTest', '@group example'], ['KernelExampleTestBase', '@group example2'], $test_file), + 'KernelExampleTrait.php' => str_replace(['FunctionalExampleTest', '@group example'], ['KernelExampleTrait', '@group example2'], $test_file), + 'KernelExampleInterface.php' => str_replace(['FunctionalExampleTest', '@group example'], ['KernelExampleInterface', '@group example2'], $test_file), + ], + ], + ], + ], + ], + 'profiles' => [ + 'test_profile' => [ + 'test_profile.info.yml' => $test_profile_info, + 'modules' => [ + 'test_profile_module' => [ + 'test_profile_module.info.yml' => $test_module_info, + 'tests' => [ + 'src' => [ + 'Kernel' => [ + 'KernelExampleTest4.php' => str_replace(['FunctionalExampleTest', '@group example'], ['KernelExampleTest4', '@group example3'], $test_file), + ], + ], + ], + ], + ], + ], + ], + ]); + } + + /** + * @covers ::getTestClasses + */ + public function testGetTestClasses() { + $this->setupVfsWithTestClasses(); + $extensions = [ + 'test_module' => new Extension('vfs://drupal', 'module', 'modules/test_module/test_module.info.yml'), + ]; + $test_discovery = $this->getTestDiscoveryMock('vfs://drupal', $extensions); + + $result = $test_discovery->getTestClasses(); + $this->assertCount(3, $result); + $this->assertEquals([ + 'example' => [ + 'Drupal\Tests\test_module\Functional\FunctionalExampleTest' => [ + 'name' => 'Drupal\Tests\test_module\Functional\FunctionalExampleTest', + 'description' => 'Test description', + 'group' => 'example', + 'groups' => ['example'], + 'type' => 'PHPUnit-Functional', + ], + ], + 'example2' => [ + 'Drupal\Tests\test_module\Functional\FunctionalExampleTest2' => [ + 'name' => 'Drupal\Tests\test_module\Functional\FunctionalExampleTest2', + 'description' => 'Test description', + 'group' => 'example2', + 'groups' => ['example2'], + 'type' => 'PHPUnit-Functional', + ], + 'Drupal\Tests\test_module\Kernel\KernelExampleTest3' => [ + 'name' => 'Drupal\Tests\test_module\Kernel\KernelExampleTest3', + 'description' => 'Test description', + 'group' => 'example2', + 'groups' => ['example2', 'kernel'], + 'type' => 'PHPUnit-Kernel', + ], + ], + 'kernel' => [ + 'Drupal\Tests\test_module\Kernel\KernelExampleTest3' => [ + 'name' => 'Drupal\Tests\test_module\Kernel\KernelExampleTest3', + 'description' => 'Test description', + 'group' => 'example2', + 'groups' => ['example2', 'kernel'], + 'type' => 'PHPUnit-Kernel', + ], + ], + ], $result); + } + + /** + * Mock a TestDiscovery object to return specific extension values. + */ + protected function getTestDiscoveryMock($app_root, $extensions) { + $class_loader = $this->prophesize(ClassLoader::class); + $module_handler = $this->prophesize(ModuleHandlerInterface::class); + + $test_discovery = $this->getMockBuilder(TestDiscovery::class) + ->setConstructorArgs([$app_root, $class_loader->reveal(), $module_handler->reveal()]) + ->setMethods(['getExtensions']) + ->getMock(); + + $test_discovery->expects($this->any()) + ->method('getExtensions') + ->willReturn($extensions); + + return $test_discovery; + } + + /** + * @covers ::getTestClasses + */ + public function testGetTestClassesWithSelectedTypes() { + $this->setupVfsWithTestClasses(); + $extensions = [ + 'test_module' => new Extension('vfs://drupal', 'module', 'modules/test_module/test_module.info.yml'), + 'test_profile_module' => new Extension('vfs://drupal', 'profile', 'profiles/test_profile/modules/test_profile_module/test_profile_module.info.yml'), + ]; + $test_discovery = $this->getTestDiscoveryMock('vfs://drupal', $extensions); + + $result = $test_discovery->getTestClasses(NULL, ['PHPUnit-Kernel']); + $this->assertCount(4, $result); + $this->assertEquals([ + 'example' => [], + 'example2' => [ + 'Drupal\Tests\test_module\Kernel\KernelExampleTest3' => [ + 'name' => 'Drupal\Tests\test_module\Kernel\KernelExampleTest3', + 'description' => 'Test description', + 'group' => 'example2', + 'groups' => ['example2', 'kernel'], + 'type' => 'PHPUnit-Kernel', + ], + ], + 'kernel' => [ + 'Drupal\Tests\test_module\Kernel\KernelExampleTest3' => [ + 'name' => 'Drupal\Tests\test_module\Kernel\KernelExampleTest3', + 'description' => 'Test description', + 'group' => 'example2', + 'groups' => ['example2', 'kernel'], + 'type' => 'PHPUnit-Kernel', + ], + ], + 'example3' => [ + 'Drupal\Tests\test_profile_module\Kernel\KernelExampleTest4' => [ + 'name' => 'Drupal\Tests\test_profile_module\Kernel\KernelExampleTest4', + 'description' => 'Test description', + 'group' => 'example3', + 'groups' => ['example3'], + 'type' => 'PHPUnit-Kernel', + ], + ], + ], $result); + } + + /** + * @covers ::getTestClasses + */ + public function testGetTestsInProfiles() { + $this->setupVfsWithTestClasses(); + $class_loader = $this->prophesize(ClassLoader::class); + $module_handler = $this->prophesize(ModuleHandlerInterface::class); + + $container = new Container(); + $container->set('kernel', new DrupalKernel('prod', new ClassLoader())); + $container->set('site.path', 'sites/default'); + \Drupal::setContainer($container); + + $test_discovery = new TestDiscovery('vfs://drupal', $class_loader->reveal(), $module_handler->reveal()); + + $result = $test_discovery->getTestClasses(NULL, ['PHPUnit-Kernel']); + $expected = [ + 'example3' => [ + 'Drupal\Tests\test_profile_module\Kernel\KernelExampleTest4' => [ + 'name' => 'Drupal\Tests\test_profile_module\Kernel\KernelExampleTest4', + 'description' => 'Test description', + 'group' => 'example3', + 'groups' => ['example3'], + 'type' => 'PHPUnit-Kernel', + ], + ], + ]; + $this->assertEquals($expected, $result); + } + + /** + * @covers ::getPhpunitTestSuite + * @dataProvider providerTestGetPhpunitTestSuite + */ + public function testGetPhpunitTestSuite($classname, $expected) { + $this->assertEquals($expected, TestDiscovery::getPhpunitTestSuite($classname)); + } + + public function providerTestGetPhpunitTestSuite() { + $data = []; + $data['simpletest-webtest'] = ['\Drupal\rest\Tests\NodeTest', FALSE]; + $data['simpletest-kerneltest'] = ['\Drupal\hal\Tests\FileNormalizeTest', FALSE]; + $data['module-unittest'] = [static::class, 'Unit']; + $data['module-kerneltest'] = ['\Drupal\KernelTests\Core\Theme\TwigMarkupInterfaceTest', 'Kernel']; + $data['module-functionaltest'] = ['\Drupal\FunctionalTests\BrowserTestBaseTest', 'Functional']; + $data['module-functionaljavascripttest'] = ['\Drupal\Tests\toolbar\FunctionalJavascript\ToolbarIntegrationTest', 'FunctionalJavascript']; + $data['core-unittest'] = ['\Drupal\Tests\ComposerIntegrationTest', 'Unit']; + $data['core-unittest2'] = ['Drupal\Tests\Core\DrupalTest', 'Unit']; + $data['core-kerneltest'] = ['\Drupal\KernelTests\KernelTestBaseTest', 'Kernel']; + $data['core-functionaltest'] = ['\Drupal\FunctionalTests\ExampleTest', 'Functional']; + $data['core-functionaljavascripttest'] = ['\Drupal\FunctionalJavascriptTests\ExampleTest', 'FunctionalJavascript']; + + return $data; + } + + /** + * Ensure that classes are not reflected when the docblock is empty. + * + * @covers ::getTestInfo + */ + public function testGetTestInfoEmptyDocblock() { + // If getTestInfo() performed reflection, it won't be able to find the + // class we asked it to analyze, so it will throw a ReflectionException. + // We want to make sure it didn't do that, because we already did some + // analysis and already have an empty docblock. getTestInfo() will throw + // MissingGroupException because the annotation is empty. + $this->expectException(MissingGroupException::class); + TestDiscovery::getTestInfo('Drupal\Tests\simpletest\ThisTestDoesNotExistTest', ''); + } + + /** + * Ensure TestDiscovery::scanDirectory() ignores certain abstract file types. + * + * @covers ::scanDirectory + */ + public function testScanDirectoryNoAbstract() { + $this->setupVfsWithTestClasses(); + $files = TestDiscovery::scanDirectory('Drupal\\Tests\\test_module\\Kernel\\', vfsStream::url('drupal/modules/test_module/tests/src/Kernel')); + $this->assertNotEmpty($files); + $this->assertArrayNotHasKey('Drupal\Tests\test_module\Kernel\KernelExampleTestBase', $files); + $this->assertArrayNotHasKey('Drupal\Tests\test_module\Kernel\KernelExampleTrait', $files); + $this->assertArrayNotHasKey('Drupal\Tests\test_module\Kernel\KernelExampleInterface', $files); + $this->assertArrayHasKey('Drupal\Tests\test_module\Kernel\KernelExampleTest3', $files); + } + +} diff --git a/core/tests/TestSuites/TestSuiteBase.php b/core/tests/TestSuites/TestSuiteBase.php index 41ed61622b..06cfc537e9 100644 --- a/core/tests/TestSuites/TestSuiteBase.php +++ b/core/tests/TestSuites/TestSuiteBase.php @@ -2,7 +2,7 @@ namespace Drupal\Tests\TestSuites; -use Drupal\simpletest\TestDiscovery; +use Drupal\Core\Test\TestDiscovery; use PHPUnit\Framework\TestSuite; /**