Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
111 changes: 111 additions & 0 deletions src/Rules/PHPUnit/ClassCoversExistsRule.php
Original file line number Diff line number Diff line change
Expand Up @@ -3,15 +3,19 @@
namespace PHPStan\Rules\PHPUnit;

use PhpParser\Node;
use PhpParser\Node\Name;
use PHPStan\Analyser\Scope;
use PHPStan\Node\InClassNode;
use PHPStan\Reflection\ClassReflection;
use PHPStan\Reflection\ReflectionProvider;
use PHPStan\Rules\IdentifierRuleError;
use PHPStan\Rules\Rule;
use PHPStan\Rules\RuleErrorBuilder;
use PHPUnit\Framework\TestCase;
use function array_merge;
use function array_shift;
use function count;
use function is_string;
use function sprintf;

/**
Expand Down Expand Up @@ -85,7 +89,114 @@ public function processNode(Node $node, Scope $scope): array
);
}

return array_merge($errors, $this->processCoversAttributes($classReflection));
}

/**
* Checks the #[CoversClass], #[CoversTrait], #[CoversMethod] and #[CoversFunction] attributes.
*
* @return list<IdentifierRuleError>
*/
private function processCoversAttributes(ClassReflection $classReflection): array
{
$betterReflection = $classReflection->getNativeReflection()->getBetterReflection();
$errors = [];

foreach ($betterReflection->getAttributesByName('PHPUnit\Framework\Attributes\CoversClass') as $attribute) {
$className = $this->getStringArgument($attribute->getArguments(), 0, 'className');
if ($className === null) {
continue;
}

if (!$this->reflectionProvider->hasClass($className)) {
$errors[] = RuleErrorBuilder::message(sprintf(
'#[CoversClass] value %s references an invalid class.',
$className,
))->identifier('phpunit.coversClass')->build();
continue;
}

if (!$this->reflectionProvider->getClass($className)->isInterface()) {
continue;
}

$errors[] = RuleErrorBuilder::message(sprintf(
'#[CoversClass] value %s references an interface.',
$className,
))->identifier('phpunit.coversInterface')->build();
}

foreach ($betterReflection->getAttributesByName('PHPUnit\Framework\Attributes\CoversTrait') as $attribute) {
$traitName = $this->getStringArgument($attribute->getArguments(), 0, 'traitName');
if ($traitName === null) {
continue;
}

if ($this->reflectionProvider->hasClass($traitName) && $this->reflectionProvider->getClass($traitName)->isTrait()) {
continue;
}

$errors[] = RuleErrorBuilder::message(sprintf(
'#[CoversTrait] value %s references an invalid trait.',
$traitName,
))->identifier('phpunit.coversTrait')->build();
}

foreach ($betterReflection->getAttributesByName('PHPUnit\Framework\Attributes\CoversMethod') as $attribute) {
$arguments = $attribute->getArguments();
$className = $this->getStringArgument($arguments, 0, 'className');
$methodName = $this->getStringArgument($arguments, 1, 'methodName');
if ($className === null || $methodName === null) {
continue;
}

if (!$this->reflectionProvider->hasClass($className)) {
$errors[] = RuleErrorBuilder::message(sprintf(
'#[CoversMethod] value %s::%s references an invalid class.',
$className,
$methodName,
))->identifier('phpunit.coversMethod')->build();
continue;
}

if ($this->reflectionProvider->getClass($className)->hasMethod($methodName)) {
continue;
}

$errors[] = RuleErrorBuilder::message(sprintf(
'#[CoversMethod] value %s::%s references an invalid method.',
$className,
$methodName,
))->identifier('phpunit.coversMethod')->build();
}

foreach ($betterReflection->getAttributesByName('PHPUnit\Framework\Attributes\CoversFunction') as $attribute) {
$functionName = $this->getStringArgument($attribute->getArguments(), 0, 'functionName');
if ($functionName === null) {
continue;
}

if ($this->reflectionProvider->hasFunction(new Name($functionName), null)) {
continue;
}

$errors[] = RuleErrorBuilder::message(sprintf(
'#[CoversFunction] value %s references an invalid function.',
$functionName,
))->identifier('phpunit.coversFunction')->build();
}

return $errors;
}

/**
* @param array<int|string, mixed> $arguments
*/
private function getStringArgument(array $arguments, int $position, string $name): ?string
{
$value = $arguments[$position] ?? $arguments[$name] ?? null;

return is_string($value) && $value !== '' ? $value : null;
}

}
33 changes: 33 additions & 0 deletions tests/Rules/PHPUnit/ClassCoversExistsRuleTest.php
Original file line number Diff line number Diff line change
Expand Up @@ -52,6 +52,39 @@ public function testRule(): void
]);
}

/**
* @requires PHP 8.0
*/
public function testAttributes(): void
{
$this->analyse([__DIR__ . '/data/class-coverage-attributes.php'], [
[
'#[CoversClass] value Not\\A\\Klass references an invalid class.',
37,
],
[
'#[CoversClass] value DateTimeInterface references an interface.',
37,
],
[
'#[CoversTrait] value ClassCoverageAttributes\\Covered references an invalid trait.',
37,
],
[
'#[CoversMethod] value ClassCoverageAttributes\\Covered::missing references an invalid method.',
37,
],
[
'#[CoversMethod] value Not\\A\\Klass::covered references an invalid class.',
37,
],
[
'#[CoversFunction] value ClassCoverageAttributes\\missingFunction references an invalid function.',
37,
],
]);
}

/**
* @return string[]
*/
Expand Down
50 changes: 50 additions & 0 deletions tests/Rules/PHPUnit/data/class-coverage-attributes.php
Original file line number Diff line number Diff line change
@@ -0,0 +1,50 @@
<?php declare(strict_types = 1);

namespace ClassCoverageAttributes;

use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\CoversFunction;
use PHPUnit\Framework\Attributes\CoversMethod;
use PHPUnit\Framework\Attributes\CoversTrait;

class Covered
{

public function covered(): void
{
}

}

trait CoveredTrait
{
}

function coveredFunction(): void
{
}

#[CoversClass(Covered::class)]
#[CoversClass(className: Covered::class)]
#[CoversTrait(CoveredTrait::class)]
#[CoversMethod(Covered::class, 'covered')]
#[CoversFunction('ClassCoverageAttributes\coveredFunction')]
#[CoversFunction('str_replace')]
class ValidCoversAttributes extends \PHPUnit\Framework\TestCase
{
}

#[CoversClass(\Not\A\Klass::class)]
#[CoversClass(\DateTimeInterface::class)]
#[CoversTrait(Covered::class)]
#[CoversMethod(Covered::class, 'missing')]
#[CoversMethod(\Not\A\Klass::class, 'covered')]
#[CoversFunction('ClassCoverageAttributes\missingFunction')]
class InvalidCoversAttributes extends \PHPUnit\Framework\TestCase
{
}

#[CoversClass(\Not\A\Klass::class)]
class NotATestCase
{
}