mirror of
https://github.com/pestphp/pest.git
synced 2026-03-06 07:47:22 +01:00
298 lines
9.1 KiB
PHP
298 lines
9.1 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace Pest\Logging;
|
|
|
|
use Pest\Concerns\Logging\WritesToConsole;
|
|
use Pest\Concerns\Testable;
|
|
use Pest\Support\ExceptionTrace;
|
|
use PHPUnit\Framework\AssertionFailedError;
|
|
use PHPUnit\Framework\Test;
|
|
use PHPUnit\Framework\TestCase;
|
|
use PHPUnit\Framework\TestResult;
|
|
use PHPUnit\Framework\TestSuite;
|
|
use PHPUnit\Framework\Warning;
|
|
use PHPUnit\TextUI\DefaultResultPrinter;
|
|
use Throwable;
|
|
|
|
use function getmypid;
|
|
use function Pest\version;
|
|
use function round;
|
|
use function str_replace;
|
|
use function strlen;
|
|
|
|
final class TeamCity extends DefaultResultPrinter
|
|
{
|
|
use WritesToConsole;
|
|
private const PROTOCOL = 'pest_qn://';
|
|
private const NAME = 'name';
|
|
private const LOCATION_HINT = 'locationHint';
|
|
private const DURATION = 'duration';
|
|
private const TEST_SUITE_STARTED = 'testSuiteStarted';
|
|
private const TEST_SUITE_FINISHED = 'testSuiteFinished';
|
|
private const TEST_COUNT = 'testCount';
|
|
private const TEST_STARTED = 'testStarted';
|
|
private const TEST_FINISHED = 'testFinished';
|
|
|
|
/** @var int */
|
|
private $flowId;
|
|
|
|
/** @var bool */
|
|
private $isSummaryTestCountPrinted = false;
|
|
|
|
/** @var \PHPUnit\Util\Log\TeamCity */
|
|
private $phpunitTeamCity;
|
|
|
|
/**
|
|
* @param resource|string|null $out
|
|
*/
|
|
public function __construct($out, bool $verbose, string $colors)
|
|
{
|
|
parent::__construct($out, $verbose, $colors);
|
|
$this->phpunitTeamCity = new \PHPUnit\Util\Log\TeamCity($out, $verbose, $colors);
|
|
|
|
$this->logo();
|
|
}
|
|
|
|
private function logo(): void
|
|
{
|
|
$this->writeNewLine();
|
|
$this->write('Pest ' . version());
|
|
$this->writeNewLine();
|
|
}
|
|
|
|
public function printResult(TestResult $result): void
|
|
{
|
|
$this->write('Tests: ');
|
|
|
|
$results = [
|
|
'failed' => ['count' => $result->errorCount() + $result->failureCount(), 'color' => 'fg-red'],
|
|
'skipped' => ['count' => $result->skippedCount(), 'color' => 'fg-yellow'],
|
|
'warned' => ['count' => $result->warningCount(), 'color' => 'fg-yellow'],
|
|
'risked' => ['count' => $result->riskyCount(), 'color' => 'fg-yellow'],
|
|
'incomplete' => ['count' => $result->notImplementedCount(), 'color' => 'fg-yellow'],
|
|
'passed' => ['count' => $this->successfulTestCount($result), 'color' => 'fg-green'],
|
|
];
|
|
|
|
$filteredResults = array_filter($results, function ($item): bool {
|
|
return $item['count'] > 0;
|
|
});
|
|
|
|
foreach ($filteredResults as $key => $info) {
|
|
$this->writeWithColor($info['color'], $info['count'] . " $key", false);
|
|
|
|
/* @phpstan-ignore-next-line */
|
|
if ($key !== array_reverse(array_keys($filteredResults))[0]) {
|
|
$this->write(', ');
|
|
}
|
|
}
|
|
|
|
$this->writeNewLine();
|
|
$this->write("Assertions: $this->numAssertions");
|
|
|
|
$this->writeNewLine();
|
|
$this->write("Time: {$result->time()}s");
|
|
|
|
$this->writeNewLine();
|
|
}
|
|
|
|
private function successfulTestCount(TestResult $result): int
|
|
{
|
|
return $result->count()
|
|
- $result->failureCount()
|
|
- $result->errorCount()
|
|
- $result->skippedCount()
|
|
- $result->warningCount()
|
|
- $result->notImplementedCount()
|
|
- $result->riskyCount();
|
|
}
|
|
|
|
public function startTestSuite(TestSuite $suite): void
|
|
{
|
|
$suiteName = $suite->getName();
|
|
|
|
if (static::isCompoundTestSuite($suite)) {
|
|
$this->writeWithColor('bold', ' ' . $suiteName);
|
|
} elseif (static::isPestTestSuite($suite)) {
|
|
$this->writeWithColor('fg-white, bold', ' ' . substr_replace($suiteName, '', 0, 2) . ' ');
|
|
} else {
|
|
$this->writeWithColor('fg-white, bold', ' ' . $suiteName);
|
|
}
|
|
|
|
$this->writeNewLine();
|
|
|
|
$this->flowId = (int) getmypid();
|
|
|
|
if (!$this->isSummaryTestCountPrinted) {
|
|
$this->printEvent(self::TEST_COUNT, [
|
|
'count' => $suite->count(),
|
|
]);
|
|
$this->isSummaryTestCountPrinted = true;
|
|
}
|
|
|
|
$this->printEvent(self::TEST_SUITE_STARTED, [
|
|
self::NAME => static::isCompoundTestSuite($suite) ? $suiteName : substr($suiteName, 2),
|
|
self::LOCATION_HINT => self::PROTOCOL . (static::isCompoundTestSuite($suite) ? $suiteName : $suiteName::__getFileName()),
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* @param array<string, string|int> $params
|
|
*/
|
|
private function printEvent(string $eventName, array $params = []): void
|
|
{
|
|
$this->write("##teamcity[{$eventName}");
|
|
|
|
if ($this->flowId !== 0) {
|
|
$params['flowId'] = $this->flowId;
|
|
}
|
|
|
|
foreach ($params as $key => $value) {
|
|
$escapedValue = self::escapeValue((string) $value);
|
|
$this->write(" {$key}='{$escapedValue}'");
|
|
}
|
|
|
|
$this->write("]\n");
|
|
}
|
|
|
|
private static function escapeValue(string $text): string
|
|
{
|
|
return str_replace(
|
|
['|', "'", "\n", "\r", ']', '['],
|
|
['||', "|'", '|n', '|r', '|]', '|['],
|
|
$text
|
|
);
|
|
}
|
|
|
|
public function endTestSuite(TestSuite $suite): void
|
|
{
|
|
$suiteName = $suite->getName();
|
|
|
|
$this->writeNewLine();
|
|
$this->writeNewLine();
|
|
|
|
$this->printEvent(self::TEST_SUITE_FINISHED, [
|
|
self::NAME => static::isCompoundTestSuite($suite) ? $suiteName : substr($suiteName, 2),
|
|
self::LOCATION_HINT => self::PROTOCOL . (static::isCompoundTestSuite($suite) ? $suiteName : $suiteName::__getFileName()),
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* @param Test|Testable $test
|
|
*/
|
|
public function startTest(Test $test): void
|
|
{
|
|
if (!TeamCity::isPestTest($test)) {
|
|
$this->phpunitTeamCity->startTest($test);
|
|
|
|
return;
|
|
}
|
|
|
|
$this->printEvent(self::TEST_STARTED, [
|
|
self::NAME => $test->getName(),
|
|
// @phpstan-ignore-next-line
|
|
self::LOCATION_HINT => self::PROTOCOL . $test->toString(),
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* Verify that the given test suite is a valid Pest suite.
|
|
*
|
|
* @param TestSuite<Test> $suite
|
|
*/
|
|
private static function isPestTestSuite(TestSuite $suite): bool
|
|
{
|
|
return strncmp($suite->getName(), 'P\\', strlen('P\\')) === 0;
|
|
}
|
|
|
|
/**
|
|
* Determine if the test suite is made up of multiple smaller test suites.
|
|
*
|
|
* @param TestSuite<Test> $suite
|
|
*/
|
|
private static function isCompoundTestSuite(TestSuite $suite): bool
|
|
{
|
|
return file_exists($suite->getName()) || !method_exists($suite->getName(), '__getFileName');
|
|
}
|
|
|
|
public static function isPestTest(Test $test): bool
|
|
{
|
|
/** @var array<string, string> $uses */
|
|
$uses = class_uses($test);
|
|
|
|
return in_array(Testable::class, $uses, true);
|
|
}
|
|
|
|
/**
|
|
* @param Test|Testable $test
|
|
*/
|
|
public function endTest(Test $test, float $time): void
|
|
{
|
|
$this->printEvent(self::TEST_FINISHED, [
|
|
self::NAME => $test->getName(),
|
|
self::DURATION => self::toMilliseconds($time),
|
|
]);
|
|
|
|
if (!$this->lastTestFailed) {
|
|
$this->writeSuccess($test->getName());
|
|
}
|
|
|
|
$this->numAssertions += $test instanceof TestCase ? $test->getNumAssertions() : 1;
|
|
$this->lastTestFailed = false;
|
|
}
|
|
|
|
private static function toMilliseconds(float $time): int
|
|
{
|
|
return (int) round($time * 1000);
|
|
}
|
|
|
|
public function addError(Test $test, Throwable $t, float $time): void
|
|
{
|
|
$this->markAsFailure($t);
|
|
$this->writeError($test->getName());
|
|
$this->phpunitTeamCity->addError($test, $t, $time);
|
|
}
|
|
|
|
public function addFailure(Test $test, AssertionFailedError $e, float $time): void
|
|
{
|
|
$this->markAsFailure($e);
|
|
$this->writeError($test->getName());
|
|
$this->phpunitTeamCity->addFailure($test, $e, $time);
|
|
}
|
|
|
|
public function addWarning(Test $test, Warning $e, float $time): void
|
|
{
|
|
$this->markAsFailure($e);
|
|
$this->writeWarning($test->getName());
|
|
$this->phpunitTeamCity->addWarning($test, $e, $time);
|
|
}
|
|
|
|
public function addIncompleteTest(Test $test, Throwable $t, float $time): void
|
|
{
|
|
$this->markAsFailure($t);
|
|
$this->writeWarning($test->getName());
|
|
$this->phpunitTeamCity->addIncompleteTest($test, $t, $time);
|
|
}
|
|
|
|
public function addRiskyTest(Test $test, Throwable $t, float $time): void
|
|
{
|
|
$this->markAsFailure($t);
|
|
$this->writeWarning($test->getName());
|
|
$this->phpunitTeamCity->addRiskyTest($test, $t, $time);
|
|
}
|
|
|
|
public function addSkippedTest(Test $test, Throwable $t, float $time): void
|
|
{
|
|
$this->markAsFailure($t);
|
|
$this->writeWarning($test->getName());
|
|
$this->phpunitTeamCity->printIgnoredTest($test->getName(), $t, $time);
|
|
}
|
|
|
|
private function markAsFailure(Throwable $t): void
|
|
{
|
|
$this->lastTestFailed = true;
|
|
ExceptionTrace::removePestReferences($t);
|
|
}
|
|
}
|