Add ShouldHaveAttribute assertion

docs/documentation/assertions.md

@@ -34,6 +34,9 @@ It asserts that the selected classes **do not depend** on the target classes.
 ## shouldNotConstruct()
 It asserts that the selected classes **do not use the constructor** of the target classes.
 
+## shouldHaveAttribute()
+It asserts that the selected classes **apply** the target attributes.
+
 ## canOnlyDependOn()
 It asserts that the selected classes **do not depend** on anything else than the target classes.
 

extension.neon

@@ -218,6 +218,12 @@ services:
 		tags:
 			- phpstan.rules.rule
 
+	# ShouldHaveAttribute rules
+	-
+		class: PHPat\Rule\Assertion\Relation\ShouldHaveAttribute\ClassAttributeRule
+		tags:
+			- phpstan.rules.rule
+
 parametersSchema:
 	phpat: structure([
 		ignore_doc_comments: bool(),

src/Rule/Assertion/Relation/RelationAssertion.php

@@ -5,6 +5,7 @@
 use PHPat\Configuration;
 use PHPat\Rule\Assertion\Assertion;
 use PHPat\Rule\Assertion\Relation\ShouldExtend\ShouldExtend;
+use PHPat\Rule\Assertion\Relation\ShouldHaveAttribute\ShouldHaveAttribute;
 use PHPat\Rule\Assertion\Relation\ShouldImplement\ShouldImplement;
 use PHPat\Selector\Classname;
 use PHPat\Selector\SelectorInterface;
@@ -97,8 +98,8 @@ protected function ruleApplies(Scope $scope, array $nodes): bool
             return false;
         }
 
-        // Can not skip if the rule is a ShouldExtend or ShouldImplement rule
-        if (is_a($this, ShouldExtend::class) || is_a($this, ShouldImplement::class)) {
+        // Can not skip if the rule is a ShouldExtend, ShouldImplement or ShouldHaveAttribute rule
+        if (is_a($this, ShouldExtend::class) || is_a($this, ShouldImplement::class) || is_a($this, ShouldHaveAttribute::class)) {
             return true;
         }
 

src/Rule/Assertion/Relation/ShouldHaveAttribute/ClassAttributeRule.php

@@ -0,0 +1,15 @@
+<?php declare(strict_types=1);
+
+namespace PHPat\Rule\Assertion\Relation\ShouldHaveAttribute;
+
+use PHPat\Rule\Extractor\Relation\ClassAttributeExtractor;
+use PHPStan\Node\InClassNode;
+use PHPStan\Rules\Rule;
+
+/**
+ * @implements Rule<InClassNode>
+ */
+final class ClassAttributeRule extends ShouldHaveAttribute implements Rule
+{
+    use ClassAttributeExtractor;
+}

src/Rule/Assertion/Relation/ShouldHaveAttribute/ShouldHaveAttribute.php

@@ -0,0 +1,50 @@
+<?php declare(strict_types=1);
+
+namespace PHPat\Rule\Assertion\Relation\ShouldHaveAttribute;
+
+use PHPat\Configuration;
+use PHPat\Rule\Assertion\Relation\RelationAssertion;
+use PHPat\Rule\Assertion\Relation\ValidationTrait;
+use PHPat\Statement\Builder\StatementBuilderFactory;
+use PHPStan\Reflection\ClassReflection;
+use PHPStan\Reflection\ReflectionProvider;
+use PHPStan\Type\FileTypeMapper;
+
+abstract class ShouldHaveAttribute extends RelationAssertion
+{
+    use ValidationTrait;
+
+    public function __construct(
+        StatementBuilderFactory $statementBuilderFactory,
+        Configuration $configuration,
+        ReflectionProvider $reflectionProvider,
+        FileTypeMapper $fileTypeMapper
+    ) {
+        parent::__construct(
+            __CLASS__,
+            $statementBuilderFactory,
+            $configuration,
+            $reflectionProvider,
+            $fileTypeMapper
+        );
+    }
+
+    protected function applyValidation(
+        string $ruleName,
+        ClassReflection $subject,
+        array $targets,
+        array $targetExcludes,
+        array $nodes,
+        array $tips
+    ): array {
+        return $this->applyShould($ruleName, $subject, $targets, $targetExcludes, $nodes, $tips);
+    }
+
+    protected function getMessage(string $ruleName, string $subject, string $target): string
+    {
+        return $this->prepareMessage(
+            $ruleName,
+            sprintf('%s should have attribute %s', $subject, $target),
+        );
+    }
+}

src/Test/Builder/AssertionStep.php

@@ -10,6 +10,7 @@
 use PHPat\Rule\Assertion\Declaration\ShouldNotBeFinal\ShouldNotBeFinal;
 use PHPat\Rule\Assertion\Relation\CanOnlyDepend\CanOnlyDepend;
 use PHPat\Rule\Assertion\Relation\ShouldExtend\ShouldExtend;
+use PHPat\Rule\Assertion\Relation\ShouldHaveAttribute\ShouldHaveAttribute;
 use PHPat\Rule\Assertion\Relation\ShouldImplement\ShouldImplement;
 use PHPat\Rule\Assertion\Relation\ShouldNotConstruct\ShouldNotConstruct;
 use PHPat\Rule\Assertion\Relation\ShouldNotDepend\ShouldNotDepend;
@@ -108,4 +109,11 @@ public function shouldHaveOnlyOnePublicMethod(): Rule
 
         return new BuildStep($this->rule);
     }
+
+    public function shouldHaveAttribute(): TargetStep
+    {
+        $this->rule->assertion = ShouldHaveAttribute::class;
+
+        return new TargetStep($this->rule);
+    }
 }

tests/fixtures/Simple/SimpleAttributeTwo.php

@@ -0,0 +1,6 @@
+<?php declare(strict_types=1);
+
+namespace Tests\PHPat\fixtures\Simple;
+
+#[\Attribute(\Attribute::TARGET_CLASS)]
+class SimpleAttributeTwo {}

tests/unit/rules/ShouldHaveAttribute/ClassAttributeTest.php

@@ -0,0 +1,49 @@
+<?php declare(strict_types=1);
+
+namespace Tests\PHPat\unit\rules\ShouldHaveAttribute;
+
+use PHPat\Configuration;
+use PHPat\Rule\Assertion\Relation\ShouldHaveAttribute\ClassAttributeRule;
+use PHPat\Rule\Assertion\Relation\ShouldHaveAttribute\ShouldHaveAttribute;
+use PHPat\Selector\Classname;
+use PHPat\Statement\Builder\StatementBuilderFactory;
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+use PHPStan\Type\FileTypeMapper;
+use Tests\PHPat\fixtures\FixtureClass;
+use Tests\PHPat\fixtures\Simple\SimpleAttributeTwo;
+use Tests\PHPat\unit\FakeTestParser;
+
+/**
+ * @extends RuleTestCase<ClassAttributeRule>
+ * @internal
+ * @coversNothing
+ */
+class ClassAttributeTest extends RuleTestCase
+{
+    public const RULE_NAME = 'test_FixtureClassShouldHaveSimpleAttributeTwo';
+
+    public function testRule(): void
+    {
+        $this->analyse(['tests/fixtures/FixtureClass.php'], [
+            [sprintf('%s should have attribute %s', FixtureClass::class, SimpleAttributeTwo::class), 29],
+        ]);
+    }
+
+    protected function getRule(): Rule
+    {
+        $testParser = FakeTestParser::create(
+            self::RULE_NAME,
+            ShouldHaveAttribute::class,
+            [new Classname(FixtureClass::class, false)],
+            [new Classname(SimpleAttributeTwo::class, false)]
+        );
+
+        return new ClassAttributeRule(
+            new StatementBuilderFactory($testParser),
+            new Configuration(false, true, false),
+            $this->createReflectionProvider(),
+            self::getContainer()->getByType(FileTypeMapper::class)
+        );
+    }
+}

tests/unit/rules/ShouldHaveAttribute/SimpleClassAttributeTest.php

@@ -0,0 +1,49 @@
+<?php declare(strict_types=1);
+
+namespace Tests\PHPat\unit\rules\ShouldHaveAttribute;
+
+use PHPat\Configuration;
+use PHPat\Rule\Assertion\Relation\ShouldHaveAttribute\ClassAttributeRule;
+use PHPat\Rule\Assertion\Relation\ShouldHaveAttribute\ShouldHaveAttribute;
+use PHPat\Selector\Classname;
+use PHPat\Statement\Builder\StatementBuilderFactory;
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+use PHPStan\Type\FileTypeMapper;
+use Tests\PHPat\fixtures\Simple\SimpleAttribute;
+use Tests\PHPat\fixtures\Simple\SimpleClass;
+use Tests\PHPat\unit\FakeTestParser;
+
+/**
+ * @extends RuleTestCase<ClassAttributeRule>
+ * @internal
+ * @coversNothing
+ */
+class SimpleClassAttributeTest extends RuleTestCase
+{
+    public const RULE_NAME = 'test_SimpleClassShouldHaveSimpleAttribute';
+
+    public function testRule(): void
+    {
+        $this->analyse(['tests/fixtures/Simple/SimpleClass.php'], [
+            [sprintf('%s should have attribute %s', SimpleClass::class, SimpleAttribute::class), 5],
+        ]);
+    }
+
+    protected function getRule(): Rule
+    {
+        $testParser = FakeTestParser::create(
+            self::RULE_NAME,
+            ShouldHaveAttribute::class,
+            [new Classname(SimpleClass::class, false)],
+            [new Classname(SimpleAttribute::class, false)]
+        );
+
+        return new ClassAttributeRule(
+            new StatementBuilderFactory($testParser),
+            new Configuration(false, true, false),
+            $this->createReflectionProvider(),
+            self::getContainer()->getByType(FileTypeMapper::class)
+        );
+    }
+}