986 lines
19 KiB
PHP
986 lines
19 KiB
PHP
|
<?php
|
||
|
|
|
||
|
|
namespace alveolata\test;
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
function _fatal_error(
|
||
|
|
string $message
|
||
|
|
) : void
|
||
|
|
{
|
||
|
|
// throw (new \Exception($message));
|
||
|
|
error_log(sprintf('FATAL ERROR: %s', $message));
|
||
|
|
exit(1);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
function _string_coin(
|
||
|
|
string $template,
|
||
|
|
array $arguments = []
|
||
|
|
) : string
|
||
|
|
{
|
||
|
|
$result = $template;
|
||
|
|
foreach ($arguments as $key => $value) {
|
||
|
|
$pattern = sprintf('{{%s}}', $key);
|
||
|
|
$replacement = strval($value);
|
||
|
|
$result = str_replace($pattern, $replacement, $result);
|
||
|
|
}
|
||
|
|
return $result;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
function _list_filter(
|
||
|
|
array $list,
|
||
|
|
\Closure $predicate
|
||
|
|
) : array
|
||
|
|
{
|
||
|
|
return array_values(array_filter($list, $predicate));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
function _colorize(
|
||
|
|
string $string,
|
||
|
|
string $color,
|
||
|
|
string $mode = 'foreground'
|
||
|
|
) : string
|
||
|
|
{
|
||
|
|
$map = [
|
||
|
|
'foreground' => [
|
||
|
|
'blue' => '34',
|
||
|
|
'green' => '32',
|
||
|
|
'purple' => '35',
|
||
|
|
'red' => '31',
|
||
|
|
'white' => '37',
|
||
|
|
'yellow' => '33',
|
||
|
|
],
|
||
|
|
'background' => [
|
||
|
|
'blue' => '44',
|
||
|
|
'green' => '42',
|
||
|
|
'purple' => '45',
|
||
|
|
'red' => '41',
|
||
|
|
'white' => '47',
|
||
|
|
'yellow' => '43',
|
||
|
|
],
|
||
|
|
];
|
||
|
|
return _string_coin(
|
||
|
|
"\033[{{colorcode}}m{{string}}\033[0m",
|
||
|
|
[
|
||
|
|
'colorcode' => $map[$mode][$color],
|
||
|
|
'string' => $string,
|
||
|
|
]
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
function _log(
|
||
|
|
int $level,
|
||
|
|
string $message
|
||
|
|
) : void
|
||
|
|
{
|
||
|
|
error_log(
|
||
|
|
_string_coin(
|
||
|
|
'{{indentation}}{{message}}',
|
||
|
|
[
|
||
|
|
'indentation' => str_repeat(" ", $level-1),
|
||
|
|
'message' => $message,
|
||
|
|
]
|
||
|
|
)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
class struct_case
|
||
|
|
{
|
||
|
|
public $name;
|
||
|
|
public $active;
|
||
|
|
public $procedure;
|
||
|
|
public function __construct(
|
||
|
|
string $name,
|
||
|
|
bool $active,
|
||
|
|
\Closure $procedure
|
||
|
|
)
|
||
|
|
{
|
||
|
|
$this->name = $name;
|
||
|
|
$this->active = $active;
|
||
|
|
$this->procedure = $procedure;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
class struct_section
|
||
|
|
{
|
||
|
|
public $name;
|
||
|
|
public $active;
|
||
|
|
public $setup;
|
||
|
|
public $cleanup;
|
||
|
|
public $subsections;
|
||
|
|
public $cases;
|
||
|
|
public function __construct(
|
||
|
|
string $name,
|
||
|
|
bool $active,
|
||
|
|
\Closure $setup,
|
||
|
|
\Closure $cleanup,
|
||
|
|
array $subsections,
|
||
|
|
array $cases
|
||
|
|
)
|
||
|
|
{
|
||
|
|
$this->name = $name;
|
||
|
|
$this->active = $active;
|
||
|
|
$this->setup = $setup;
|
||
|
|
$this->cleanup = $cleanup;
|
||
|
|
$this->subsections = $subsections;
|
||
|
|
$this->cases = $cases;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
class struct_state
|
||
|
|
{
|
||
|
|
public $name;
|
||
|
|
public $sign;
|
||
|
|
public $color;
|
||
|
|
public function __construct(
|
||
|
|
$name,
|
||
|
|
$sign,
|
||
|
|
$color
|
||
|
|
)
|
||
|
|
{
|
||
|
|
$this->name = $name;
|
||
|
|
$this->sign = $sign;
|
||
|
|
$this->color = $color;
|
||
|
|
}
|
||
|
|
public static $skipped = null;
|
||
|
|
public static $aborted = null;
|
||
|
|
public static $failed = null;
|
||
|
|
public static $passed = null;
|
||
|
|
public static function init(
|
||
|
|
) : void
|
||
|
|
{
|
||
|
|
self::$skipped = new static('skipped', 'o', 'yellow');
|
||
|
|
self::$aborted = new static('aborted', '!', 'purple');
|
||
|
|
self::$failed = new static('failed', 'x', 'red');
|
||
|
|
self::$passed = new static('passed', '+', 'green');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
struct_state::init();
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
class struct_report
|
||
|
|
{
|
||
|
|
public /*array */$path;
|
||
|
|
public /*struct_state */$state;
|
||
|
|
public /*string */$messages;
|
||
|
|
public function __construct(
|
||
|
|
array $path,
|
||
|
|
struct_state $state,
|
||
|
|
array $messages
|
||
|
|
)
|
||
|
|
{
|
||
|
|
$this->path = $path;
|
||
|
|
$this->state = $state;
|
||
|
|
$this->messages = $messages;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
class class_assertion
|
||
|
|
{
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @var function<~string,void>
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
private $finalize;
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
public function __construct(
|
||
|
|
\Closure $finalize
|
||
|
|
)
|
||
|
|
{
|
||
|
|
$this->finalize = $finalize;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
public function not(
|
||
|
|
) : class_assertion
|
||
|
|
{
|
||
|
|
return (
|
||
|
|
new class_assertion(
|
||
|
|
function (/*?string */$message) : void {
|
||
|
|
if (is_null($message)) {
|
||
|
|
($this->finalize)('should NOT be');
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
($this->finalize)(null);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* unspecific explicit fail
|
||
|
|
*
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
public function fail(
|
||
|
|
$reason = null
|
||
|
|
)
|
||
|
|
{
|
||
|
|
$message = ($reason ?: '(unexplained fail)');
|
||
|
|
($this->finalize)($message);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* unspecific generic test
|
||
|
|
*
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
public function is(
|
||
|
|
bool $value
|
||
|
|
)
|
||
|
|
{
|
||
|
|
$message = ($value ? null : 'condition not met');
|
||
|
|
($this->finalize)($message);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* tests whether the piece of code runs without throwing an error
|
||
|
|
*
|
||
|
|
* @param \Closure $procedure
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
public function runs(
|
||
|
|
\Closure $procedure
|
||
|
|
)
|
||
|
|
{
|
||
|
|
try {
|
||
|
|
$procedure();
|
||
|
|
$message = null;
|
||
|
|
}
|
||
|
|
catch (\Throwable $throwable) {
|
||
|
|
$message = _string_coin(
|
||
|
|
'does not run; reason: {{reason}}',
|
||
|
|
[
|
||
|
|
'reason' => $throwable->getMessage(),
|
||
|
|
]
|
||
|
|
);
|
||
|
|
}
|
||
|
|
($this->finalize)($message);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* tests whether the piece of code runs with throwing an error
|
||
|
|
*
|
||
|
|
* @param \Closure $procedure
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
public function crashes(
|
||
|
|
\Closure $procedure,
|
||
|
|
?string $throwable_class = null
|
||
|
|
)
|
||
|
|
{
|
||
|
|
try {
|
||
|
|
$procedure();
|
||
|
|
$message = _string_coin(
|
||
|
|
'does run though it is not supposed to do',
|
||
|
|
[
|
||
|
|
]
|
||
|
|
);
|
||
|
|
}
|
||
|
|
catch (\Throwable $throwable) {
|
||
|
|
if (
|
||
|
|
(is_null($throwable_class))
|
||
|
|
||
|
||
|
|
(get_class($throwable) === $throwable_class)
|
||
|
|
) {
|
||
|
|
$message = null;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
$message = _string_coin(
|
||
|
|
'wrong throwable class: [actual] {{actual}}; [expected] {{expected}}',
|
||
|
|
[
|
||
|
|
'actual' => get_class($throwable),
|
||
|
|
'expected' => $throwable_class,
|
||
|
|
]
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
($this->finalize)($message);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* tests whether two values are equal
|
||
|
|
*
|
||
|
|
* @param any $value_actual
|
||
|
|
* @param any $value_expected
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
public function equal(
|
||
|
|
$value_actual,
|
||
|
|
$value_expected
|
||
|
|
)
|
||
|
|
{
|
||
|
|
if ($value_actual === $value_expected) {
|
||
|
|
$message = null;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
$message = _string_coin(
|
||
|
|
'[actual] {{actual}}; [expected] {{expected}}',
|
||
|
|
[
|
||
|
|
'actual' => json_encode($value_actual),
|
||
|
|
'expected' => json_encode($value_expected),
|
||
|
|
]
|
||
|
|
);
|
||
|
|
}
|
||
|
|
($this->finalize)($message);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @var struct_section
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
$_root = null;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* merges two sections
|
||
|
|
*
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
function _merge(
|
||
|
|
struct_section $section1,
|
||
|
|
struct_section $section2
|
||
|
|
) : struct_section
|
||
|
|
{
|
||
|
|
if (! ($section1->name === $section2->name)) {
|
||
|
|
throw (new \Exception('sections with different names may not be merged'));
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
if (! ($section1->active === $section2->active)) {
|
||
|
|
throw (new \Exception('sections with different active states may not be merged'));
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
$subsections = [];
|
||
|
|
foreach ([$section1, $section2] as $section) {
|
||
|
|
foreach ($section->subsections as $subsection_name => $subsection) {
|
||
|
|
if (! array_key_exists($subsection_name, $subsections)) {
|
||
|
|
$subsections[$subsection_name] = $subsection;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
$subsections[$subsection_name] = _merge(
|
||
|
|
$subsections[$subsection_name],
|
||
|
|
$subsection
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
$section_merged = (
|
||
|
|
new struct_section(
|
||
|
|
$section1->name,
|
||
|
|
$section1->active,
|
||
|
|
// TODO: subenvironments?
|
||
|
|
function (&$environment) use ($section1, $section2) : void {
|
||
|
|
($section1->setup)($environment);
|
||
|
|
($section2->setup)($environment);
|
||
|
|
},
|
||
|
|
function (&$environment) use ($section1, $section2) : void {
|
||
|
|
($section1->cleanup)($environment);
|
||
|
|
($section2->cleanup)($environment);
|
||
|
|
},
|
||
|
|
$subsections,
|
||
|
|
array_merge(
|
||
|
|
$section1->cases,
|
||
|
|
$section2->cases
|
||
|
|
)
|
||
|
|
)
|
||
|
|
);
|
||
|
|
return $section_merged;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* adds a regular test definition
|
||
|
|
*
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
function _add(
|
||
|
|
struct_section &$section_parent,
|
||
|
|
array $section_raw_given
|
||
|
|
)
|
||
|
|
{
|
||
|
|
$section_raw_default = [
|
||
|
|
'name' => '?',
|
||
|
|
'active' => true,
|
||
|
|
'setup' => (function (&$environment) {}),
|
||
|
|
'cleanup' => (function (&$environment) {}),
|
||
|
|
'sections' => [],
|
||
|
|
'cases' => [],
|
||
|
|
];
|
||
|
|
$section_raw = array_merge(
|
||
|
|
$section_raw_default,
|
||
|
|
$section_raw_given
|
||
|
|
);
|
||
|
|
$section = new struct_section(
|
||
|
|
$section_raw['name'],
|
||
|
|
$section_raw['active'],
|
||
|
|
$section_raw['setup'],
|
||
|
|
$section_raw['cleanup'],
|
||
|
|
[],
|
||
|
|
[]
|
||
|
|
);
|
||
|
|
// sections
|
||
|
|
{
|
||
|
|
foreach ($section_raw['sections'] as $section_sub_raw) {
|
||
|
|
_add($section, $section_sub_raw);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// cases
|
||
|
|
{
|
||
|
|
foreach ($section_raw['cases'] as $case_raw_given) {
|
||
|
|
$case_raw_default = [
|
||
|
|
'name' => '?',
|
||
|
|
'active' => true,
|
||
|
|
'procedure' => function ($assert, &$environment) {
|
||
|
|
$assert->fail('not implemented');
|
||
|
|
},
|
||
|
|
];
|
||
|
|
$case_raw = array_merge($case_raw_default, $case_raw_given);
|
||
|
|
$case = new struct_case(
|
||
|
|
$case_raw['name'],
|
||
|
|
$case_raw['active'],
|
||
|
|
$case_raw['procedure']
|
||
|
|
);
|
||
|
|
array_push($section->cases, $case);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// array_push($section_parent->subsections, $section);
|
||
|
|
{
|
||
|
|
if (array_key_exists($section->name, $section_parent->subsections)) {
|
||
|
|
$section_parent->subsections[$section->name] = _merge(
|
||
|
|
$section_parent->subsections[$section->name],
|
||
|
|
$section
|
||
|
|
);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
$section_parent->subsections[$section->name] = $section;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* adds a json based test definition
|
||
|
|
*
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
function _adapt(
|
||
|
|
string $spec_path
|
||
|
|
)
|
||
|
|
{
|
||
|
|
global $_root;
|
||
|
|
$steps = explode('/', $spec_path);
|
||
|
|
$paths_to_try = [
|
||
|
|
sprintf('%s/%s.php', implode('/', array_slice($steps, 0, count($steps)-1)), $steps[count($steps)-1]),
|
||
|
|
sprintf('%s/functions.php', implode('/', array_slice($steps, 0, count($steps)-1))),
|
||
|
|
];
|
||
|
|
foreach ($paths_to_try as $path) {
|
||
|
|
if (file_exists($path)) {
|
||
|
|
require_once($path);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
$spec = json_decode(file_get_contents(sprintf('%s.spec.json', $spec_path)), true);
|
||
|
|
if (empty($spec)) {
|
||
|
|
$message = _string_coin(
|
||
|
|
'json based test definition "{{path}}" malformed',
|
||
|
|
[
|
||
|
|
'path' => $spec_path,
|
||
|
|
]
|
||
|
|
);
|
||
|
|
throw (new \Exception($message));
|
||
|
|
}
|
||
|
|
_add(
|
||
|
|
$_root,
|
||
|
|
[
|
||
|
|
'name' => $spec_path,
|
||
|
|
'active' => $spec['active'],
|
||
|
|
'sections' => array_map(
|
||
|
|
function ($section_raw) {
|
||
|
|
return [
|
||
|
|
'name' => $section_raw['name'],
|
||
|
|
'active' => $section_raw['active'],
|
||
|
|
'cases' => array_map(
|
||
|
|
function ($case_raw) use ($section_raw) {
|
||
|
|
return [
|
||
|
|
'name' => $case_raw['name'],
|
||
|
|
'active' => $case_raw['active'],
|
||
|
|
'procedure' => function ($assert, $environment) use ($section_raw, $case_raw) {
|
||
|
|
$expression = _string_coin(
|
||
|
|
$section_raw['execution']['call'],
|
||
|
|
array_map(
|
||
|
|
function ($value) {
|
||
|
|
return var_export($value, true);
|
||
|
|
},
|
||
|
|
$case_raw['input']
|
||
|
|
)
|
||
|
|
);
|
||
|
|
switch ($case_raw['output']['kind']) {
|
||
|
|
case 'runs': {
|
||
|
|
$assert->runs(
|
||
|
|
function () use (&$expression) {
|
||
|
|
eval(sprintf('return %s;', $expression));
|
||
|
|
}
|
||
|
|
);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 'crashes': {
|
||
|
|
$assert->crashes(
|
||
|
|
function () use (&$expression) {
|
||
|
|
eval(sprintf('return %s;', $expression));
|
||
|
|
}
|
||
|
|
);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 'regular': {
|
||
|
|
$result_actual = eval(sprintf('return %s;', $expression));
|
||
|
|
$result_expected = $case_raw['output']['value'];
|
||
|
|
$assert->equal($result_actual, $result_expected);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default: {
|
||
|
|
$message = _string_coin(
|
||
|
|
'unhadled output kind "{{kind}}"',
|
||
|
|
[
|
||
|
|
'kind' => $case['output']['kind']
|
||
|
|
]
|
||
|
|
);
|
||
|
|
throw (new \Exception($message));
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
];
|
||
|
|
},
|
||
|
|
$section_raw['cases']
|
||
|
|
)
|
||
|
|
];
|
||
|
|
},
|
||
|
|
$spec['sections']
|
||
|
|
),
|
||
|
|
]
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @param array $path
|
||
|
|
* @return struct_section section
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
function _get(
|
||
|
|
array $path,
|
||
|
|
struct_section $section = null,
|
||
|
|
array $path_complete = null
|
||
|
|
) : ?struct_section
|
||
|
|
{
|
||
|
|
global $_root;
|
||
|
|
if ($section === null) {
|
||
|
|
$section = $_root;
|
||
|
|
}
|
||
|
|
if ($path_complete === null) {
|
||
|
|
$path_complete = $path;
|
||
|
|
}
|
||
|
|
if (count($path) === 0) {
|
||
|
|
return $section;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
$name = $path[0];
|
||
|
|
foreach ($section->subsections as $section_sub_name => $section_sub) {
|
||
|
|
if ($section_sub->name === $name) {
|
||
|
|
return _get(
|
||
|
|
array_slice($path, 1),
|
||
|
|
$section_sub,
|
||
|
|
$path_complete
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
$message = _string_coin(
|
||
|
|
'no test section "{{path}}"',
|
||
|
|
[
|
||
|
|
'path' => implode('.', $path_complete),
|
||
|
|
]
|
||
|
|
);
|
||
|
|
throw (new \Exception($message));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @param struct_section $section
|
||
|
|
* @param bool $log
|
||
|
|
* @return list<struct_report>
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
function _execute(
|
||
|
|
struct_section $section = null,
|
||
|
|
bool $log = true,
|
||
|
|
array $path = [],
|
||
|
|
&$environment = [],
|
||
|
|
$active = true
|
||
|
|
) : array
|
||
|
|
{
|
||
|
|
global $_root;
|
||
|
|
if ($section === null) {
|
||
|
|
$section = $_root;
|
||
|
|
}
|
||
|
|
if (! $active) {
|
||
|
|
return [];
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
$level = count($path);
|
||
|
|
$reports = [];
|
||
|
|
if (count($path) > 0) {
|
||
|
|
if ($log) {
|
||
|
|
_log(
|
||
|
|
$level,
|
||
|
|
_string_coin(
|
||
|
|
'<{{name}}>',
|
||
|
|
[
|
||
|
|
'name' => $section->name,
|
||
|
|
]
|
||
|
|
)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
($section->setup)($environment);
|
||
|
|
foreach ($section->subsections as $section_sub_name => &$section_sub) {
|
||
|
|
$reports_sub = _execute(
|
||
|
|
$section_sub,
|
||
|
|
$log,
|
||
|
|
array_merge($path, [$section_sub->name]),
|
||
|
|
$environment,
|
||
|
|
$active && $section_sub->active
|
||
|
|
);
|
||
|
|
$reports = array_merge($reports, $reports_sub);
|
||
|
|
}
|
||
|
|
unset($section_sub);
|
||
|
|
foreach ($section->cases as &$case) {
|
||
|
|
$messages = [];
|
||
|
|
if (!$active || !$case->active) {
|
||
|
|
$state = struct_state::$skipped;
|
||
|
|
$messages = [];
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
$state = struct_state::$passed;
|
||
|
|
$assert = new class_assertion(
|
||
|
|
function ($message) use (&$state, &$messages) {
|
||
|
|
if ($message === null) {
|
||
|
|
// do nothing
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
array_push($messages, $message);
|
||
|
|
$state = struct_state::$failed;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
);
|
||
|
|
try {
|
||
|
|
($case->procedure)($assert, $environment);
|
||
|
|
}
|
||
|
|
catch (\Throwable $throwable) {
|
||
|
|
$state = struct_state::$aborted;
|
||
|
|
$message = _string_coin(
|
||
|
|
"{{description}} in {{file}}:{{line}}",
|
||
|
|
[
|
||
|
|
'description' => $throwable->getMessage(),
|
||
|
|
'file' => $throwable->getFile(),
|
||
|
|
'line' => $throwable->getLine(),
|
||
|
|
'stacktrace' => $throwable->getTraceAsString(),
|
||
|
|
]
|
||
|
|
);
|
||
|
|
array_push($messages, $message);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
$report = new struct_report(
|
||
|
|
array_merge($path, [$case->name]),
|
||
|
|
$state,
|
||
|
|
$messages
|
||
|
|
);
|
||
|
|
if ($log) {
|
||
|
|
_log(
|
||
|
|
$level+1,
|
||
|
|
_colorize(
|
||
|
|
_string_coin(
|
||
|
|
'[{{indicator}}] {{name}}',
|
||
|
|
[
|
||
|
|
'indicator' => $state->sign,
|
||
|
|
// 'indicator' => _colorize($state->sign, $state->color),
|
||
|
|
// 'indicator' => _colorize('x', $state->color, 'background'),
|
||
|
|
// 'indicator' => _colorize('x', $state->color, 'foreground'),
|
||
|
|
'name' => $case->name,
|
||
|
|
]
|
||
|
|
),
|
||
|
|
$state->color
|
||
|
|
)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
array_push($reports, $report);
|
||
|
|
}
|
||
|
|
unset($case);
|
||
|
|
($section->cleanup)($environment);
|
||
|
|
return $reports;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* searching and adding test definitions
|
||
|
|
*
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
function _gather(
|
||
|
|
) : void
|
||
|
|
{
|
||
|
|
global $_root;
|
||
|
|
// .spec.php
|
||
|
|
{
|
||
|
|
exec(
|
||
|
|
'find . -name "*.spec.php" | cut -d "/" -f "2-"',
|
||
|
|
$paths
|
||
|
|
);
|
||
|
|
foreach ($paths as $path) {
|
||
|
|
include($path);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// .spec.json
|
||
|
|
{
|
||
|
|
exec(
|
||
|
|
'find . -name "*.spec.json" | sed -e "s:.spec.json::g" | cut -d "/" -f "2-"',
|
||
|
|
$spec_paths
|
||
|
|
);
|
||
|
|
foreach ($spec_paths as $spec_path) {
|
||
|
|
_adapt($spec_path);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @param list<struct_report>
|
||
|
|
* @return record<apt:bool,script:string>
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
function _evaluation(
|
||
|
|
array $reports
|
||
|
|
) : array
|
||
|
|
{
|
||
|
|
$counts = [
|
||
|
|
struct_state::$skipped->name => 0,
|
||
|
|
struct_state::$aborted->name => 0,
|
||
|
|
struct_state::$failed->name => 0,
|
||
|
|
struct_state::$passed->name => 0,
|
||
|
|
];
|
||
|
|
foreach ($reports as $report) {
|
||
|
|
$counts[$report->state->name] += 1;
|
||
|
|
}
|
||
|
|
$count_total = count($reports);
|
||
|
|
$apt = ($counts[struct_state::$skipped->name] + $counts[struct_state::$passed->name] === $count_total);
|
||
|
|
$script = '';
|
||
|
|
$script .= ('--------' . "\n");
|
||
|
|
{
|
||
|
|
$script .= ('# summary' . "\n");
|
||
|
|
$script .= ('' . "\n");
|
||
|
|
if ($count_total === 0) {
|
||
|
|
$script .= ('(no tests found)' . "\n");
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
$name = (struct_state::$passed)->name;
|
||
|
|
$share = (1.0 * $counts[$name] / $count_total);
|
||
|
|
$script .= (
|
||
|
|
_string_coin(
|
||
|
|
'{{count_passed}}/{{count_total}} passed ({{percentage}}%)' . "\n",
|
||
|
|
[
|
||
|
|
'count_passed' => sprintf('%d', $counts[struct_state::$passed->name]),
|
||
|
|
'count_total' => sprintf('%d', $count_total),
|
||
|
|
'percentage' => sprintf('%.2f', $share*100),
|
||
|
|
]
|
||
|
|
)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
$script .= ('' . "\n");
|
||
|
|
$script .= ('' . "\n");
|
||
|
|
}
|
||
|
|
{
|
||
|
|
$states = [
|
||
|
|
struct_state::$skipped,
|
||
|
|
struct_state::$failed,
|
||
|
|
struct_state::$aborted,
|
||
|
|
];
|
||
|
|
foreach ($states as $state) {
|
||
|
|
$reports_filtered = _list_filter(
|
||
|
|
$reports,
|
||
|
|
function ($report) use (&$state) {
|
||
|
|
return ($report->state === $state);
|
||
|
|
}
|
||
|
|
);
|
||
|
|
if (count($reports_filtered) > 0) {
|
||
|
|
$script .= (
|
||
|
|
_string_coin(
|
||
|
|
'# {{name}}' . "\n",
|
||
|
|
[
|
||
|
|
'name' => $state->name
|
||
|
|
]
|
||
|
|
)
|
||
|
|
);
|
||
|
|
$script .= ('' . "\n");
|
||
|
|
foreach ($reports_filtered as $report) {
|
||
|
|
$script .= (
|
||
|
|
_string_coin(
|
||
|
|
'- `{{path}}`' . "\n",
|
||
|
|
[
|
||
|
|
'path' => implode('.', $report->path),
|
||
|
|
]
|
||
|
|
)
|
||
|
|
);
|
||
|
|
// $script .= ('' . "\n");
|
||
|
|
foreach ($report->messages as $message) {
|
||
|
|
$script .= (
|
||
|
|
_string_coin(
|
||
|
|
"\t" . '- {{message}}' . "\n",
|
||
|
|
[
|
||
|
|
'message' => $message,
|
||
|
|
]
|
||
|
|
)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
$script .= ('' . "\n");
|
||
|
|
$script .= ('' . "\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return [
|
||
|
|
'apt' => $apt,
|
||
|
|
'script' => $script,
|
||
|
|
];
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
function get_data(
|
||
|
|
string $path = null
|
||
|
|
) : array
|
||
|
|
{
|
||
|
|
if (is_null($path)) {
|
||
|
|
$directory = dirname(debug_backtrace()[0]['file']);
|
||
|
|
$path = ($directory . '/testdata.json');
|
||
|
|
}
|
||
|
|
$content = file_get_contents($path);
|
||
|
|
if ($content === false) {
|
||
|
|
$message = sprintf('testdata file not readable: %s', $path);
|
||
|
|
_fatal_error($message);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
$data = json_decode($content, true);
|
||
|
|
if (json_last_error() !== JSON_ERROR_NONE) {
|
||
|
|
$message = sprintf('testdata json not decodable: %s', $path);
|
||
|
|
_fatal_error($message);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
return $data;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* adds a regular test definition
|
||
|
|
*
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
function add(
|
||
|
|
array $section_raw
|
||
|
|
) : void
|
||
|
|
{
|
||
|
|
global $_root;
|
||
|
|
_add($_root, $section_raw);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* searches for test definitions, executes all the tests the selected branch and writes the summary to stderr
|
||
|
|
*
|
||
|
|
* @return true if all non skipped tests have passed; false if there are aborted or failing tests
|
||
|
|
* @author Christian Fraß <frass@greenscale.de>
|
||
|
|
*/
|
||
|
|
function run(
|
||
|
|
array $path = [],
|
||
|
|
bool $log = true
|
||
|
|
) : bool
|
||
|
|
{
|
||
|
|
global $_root;
|
||
|
|
$_root = new struct_section(
|
||
|
|
'root',
|
||
|
|
true,
|
||
|
|
function () {},
|
||
|
|
function () {},
|
||
|
|
[],
|
||
|
|
[]
|
||
|
|
);
|
||
|
|
_gather();
|
||
|
|
$section = _get($path);
|
||
|
|
$reports = _execute($section, $log);
|
||
|
|
$evaluation = _evaluation($reports);
|
||
|
|
error_log($evaluation['script']);
|
||
|
|
return $evaluation['apt'];
|
||
|
|
}
|
||
|
|
|