Differential D13579 Diff 32820 src/unit/engine/ArcanistConfigurationDrivenTestEngine.php

Changeset View

Standalone View

src/unit/engine/ArcanistConfigurationDrivenTestEngine.php

This file was added.

				<?php

				final class ArcanistConfigurationDrivenTestEngine
				extends ArcanistUnitTestEngine {

				protected function supportsRunAllTests() {
				return true;
				epriestleyUnsubmitted Done Inline Actions Maybe only `true` if at least one configured engine supports `--everything`. epriestley: Maybe only `true` if at least one configured engine supports `--everything`.
				}

				public function buildTestEngines() {
				$working_copy = $this->getWorkingCopy();
				$config_path = $working_copy->getProjectPath('.arcunit');

				if (!Filesystem::pathExists($config_path)) {
				throw new ArcanistUsageException(
				pht(
				"Unable to find '%s' file to configure test engines. Create an ".
				"'%s' file in the root directory of the working copy.",
				'.arcunit',
				'.arcunit'));
				}

				$data = Filesystem::readFile($config_path);
				$config = null;
				try {
				$config = phutil_json_decode($data);
				} catch (PhutilJSONParserException $ex) {
				throw new PhutilProxyException(
				pht(
				"Expected '%s' file to be a valid JSON file, but ".
				"failed to decode '%s'.",
				'.arcunit',
				$config_path),
				$ex);
				}

				$test_engines = $this->loadAvailableTestEngines();

				try {
				PhutilTypeSpec::checkMap(
				$config,
				array(
				'engines' => 'map<string, map<string, wild>>',
				));
				} catch (PhutilTypeCheckException $ex) {
				throw new PhutilProxyException(
				pht("Error in parsing '%s' file.", $config_path),
				$ex);
				}

				$built_test_engines = array();
				$all_paths = $this->getPaths();

				foreach ($config['engines'] as $name => $spec) {
				$type = idx($spec, 'type');

				if ($type !== null) {
				if (empty($test_engines[$type])) {
				throw new ArcanistUsageException(
				pht(
				"Test engine '%s' specifies invalid type '%s'. ".
				"Available test engines are: %s.",
				$name,
				$type,
				implode(', ', array_keys($test_engines))));
				}

				$test_engine = clone $test_engines[$type];
				} else {
				// We'll raise an error below about the invalid "type" key.
				$test_engine = null;
				}
				epriestleyUnsubmitted Done Inline Actions Could we just do the type check first, and simplify this a bit? epriestley: Could we just do the type check first, and simplify this a bit?

				try {
				PhutilTypeSpec::checkMap(
				$spec,
				array(
				'type' => 'string',
				'include' => 'optional regex \| list<regex>',
				'exclude' => 'optional regex \| list<regex>',
				));
				} catch (PhutilTypeCheckException $ex) {
				throw new PhutilProxyException(
				pht(
				"Error in parsing '%s' file, for test engine '%s'.",
				'.arcunit',
				$name),
				$ex);
				}

				$include = (array)idx($spec, 'include', array());
				$exclude = (array)idx($spec, 'exclude', array());
				$paths = $this->matchPaths(
				$all_paths,
				$include,
				$exclude);

				$test_engine->setPaths($paths);
				$built_test_engines[] = $test_engine;
				}

				return $built_test_engines;
				}

				public function run() {
				$paths = $this->getPaths();

				// If we are running with `--everything` then `$paths` will be `null`.
				if (!$paths) {
				$paths = array();
				}

				$engines = $this->buildTestEngines();
				$results = array();
				$exceptions = array();

				foreach ($engines as $engine) {
				$engine
				->setWorkingCopy($this->getWorkingCopy())
				->setEnableAsyncTests($this->getEnableAsyncTests())
				epriestleyUnsubmitted Done Inline Actions I think we should move away from support for this (and "postponed" linters) -- these models never really made sense, and Harbormaster is on the horizon now. Fine to maintain support if it's "free", but feel free to just drop it if it's non-free, too. epriestley: I think we should move away from support for this (and "postponed" linters) -- these models…
				->setEnableCoverage($this->getEnableCoverage());

				if ($engine->supportsRunAllTests()) {
				$engine->setRunAllTests($this->getRunAllTests());
				}
				epriestleyUnsubmitted Not Done Inline Actions At some point, maybe we should emit a warning here if an engine doesn't support `--everything`, to reduce surprise when `--everything` does not really mean `--everything`. epriestley: At some point, maybe we should emit a warning here if an engine doesn't support `--everything`…

				try {
				$results[] = $engine->run();
				epriestleyUnsubmitted Not Done Inline Actions Consider type checking the results, similar to D13486, to place blame on bad engines more clearly. epriestley: Consider type checking the results, similar to D13486, to place blame on bad engines more…
				} catch (ArcanistNoEffectException $ex) {
				$exceptions[] = $ex;
				}
				}

				if (!$results) {
				// If all engines throw an `ArcanistNoEffectException`, then we should
				// preserve this behavior.
				throw new ArcanistNoEffectException(pht('No tests to run.'));
				}

				return array_mergev($results);
				}

				private function loadAvailableTestEngines() {
				return id(new PhutilClassMapQuery())
				->setAncestorClass('ArcanistUnitTestEngine')
				->setUniqueMethod('getEngineConfigurationName', true)
				->execute();
				}

				private function matchPaths(array $paths, array $include, array $exclude) {
				epriestleyUnsubmitted Not Done Inline Actions (Is this essentially identical to something in the Lint engine?) epriestley: (Is this essentially identical to something in the Lint engine?)
				$match = array();

				foreach ($paths as $path) {
				$keep = false;
				if (!$include) {
				$keep = true;
				} else {
				foreach ($include as $rule) {
				if (preg_match($rule, $path)) {
				$keep = true;
				break;
				}
				}
				}

				if (!$keep) {
				continue;
				}

				if ($exclude) {
				foreach ($exclude as $rule) {
				if (preg_match($rule, $path)) {
				continue 2;
				}
				}
				}

				$match[] = $path;
				}

				return $match;
				}

				}