SavinMikhail\EnforceAaaPatternRector\EnforceAaaPatternRector

Complexity

Total Complexity

40

Size/Duplication

Total Lines	193
Duplicated Lines	0 %

Test Coverage

Coverage

79.27%

Importance

Changes	6
Bugs	2	Features	2

11 Methods

Rating	Name	Duplication	Size	Complexity
A	addAaaComment()	0	5	1
A	isTestMethod()	0	10	3
A	findFirstAssert()	0	9	4
A	isAssertStatement()	0	3	2
C	refactor()	0	50	12
A	getRuleDefinition()	0	18	1
A	isAaaComment()	0	7	1
A	findLastNonAssert()	0	10	3
A	removeAaaComments()	0	10	3
A	getNodeTypes()	0	3	1
B	isAssertCall()	0	21	9

<?php

declare(strict_types=1);

namespace SavinMikhail\EnforceAaaPatternRector;

use PhpParser\Comment;
use PhpParser\Node;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\StaticCall;
use PhpParser\Node\Stmt;
use PhpParser\Node\Stmt\ClassMethod;
use PhpParser\Node\Stmt\Expression;
use Rector\Rector\AbstractRector;
use Symplify\RuleDocGenerator\Exception\PoorDocumentationException;
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;

use function in_array;

final class EnforceAaaPatternRector extends AbstractRector
{
    /**
     * @throws PoorDocumentationException
     */
    public function getRuleDefinition(): RuleDefinition
    {
        return new RuleDefinition(
            description: 'Enforce AAA (Arrange-Act-Assert) pattern in PHPUnit test methods',
            codeSamples: [
                new CodeSample(
                    badCode: <<<'PHP_WRAP'
                        final class FooTest extends PHPUnit\Framework\TestCase
                        {
                            public function testFoo(): void
                            {
                                $date = new DateTimeImmutable('2025-01-01');
                                $formatted = $date->format('Y-m-d');
                                $this->assertEquals('2025-01-01', $formatted);
                            }
                        }
                        PHP_WRAP,
                    goodCode: <<<'PHP_WRAP'
                        final class FooTest extends PHPUnit\Framework\TestCase
                        {
                            public function testFoo(): void
                            {
                                // Arrange
                                $date = new DateTimeImmutable('2025-01-01');
                                // Act
                                $formatted = $date->format('Y-m-d');
                                // Assert
                                $this->assertEquals('2025-01-01', $formatted);
                            }
                        }
                        PHP_WRAP,
                ),
            ],
        );
    }

    public function getNodeTypes(): array
    {
        return [ClassMethod::class];
    }

    private function isTestMethod(ClassMethod $classMethod): bool
    {
        $name = $this->getName(node: $classMethod);
        if (str_starts_with(haystack: $name, needle: 'test')) {

It seems like $name can also be of type null; however, parameter $haystack of str_starts_with() does only seem to accept string, maybe add an additional type check?

            return true;
        }

        $docComment = $classMethod->getDocComment();

        return $docComment !== null && str_contains(haystack: strtolower(string: $docComment->getText()), needle: '@test');
    }

    private function isAaaComment(Comment $comment): bool
    {
        $text = trim(string: $comment->getText());
        $coreText = trim(string: (string) preg_replace(pattern: '/^\/\/\s*|^\/\*\s*|\s*\*\/$/', replacement: '', subject: $text));
        $coreTextLower = strtolower(string: $coreText);

        return in_array(needle: $coreTextLower, haystack: ['arrange', 'act', 'assert'], strict: true);
    }

    private function removeAaaComments(Node $stmt): void
    {
        $filteredComments = [];
        foreach ($stmt->getComments() as $comment) {
            if (! $this->isAaaComment(comment: $comment)) {
                $filteredComments[] = $comment;
            }
        }

        $stmt->setAttribute('comments', $filteredComments);
    }

    private function addAaaComment(Node $stmt, string $aaaComment): void
    {
        $existing = $stmt->getComments();
        $aaa = new Comment(text: '// ' . $aaaComment);
        $stmt->setAttribute('comments', array_merge([$aaa], $existing));
    }

    private function isAssertCall(Node\Expr $expr): bool
    {
        if ($expr instanceof MethodCall
            && $expr->var instanceof Node\Expr\Variable
            && $this->isName(node: $expr->var, name: 'this')
        ) {
            $methodName = $this->getName(node: $expr->name);

            return $methodName !== null && str_starts_with(haystack: $methodName, needle: 'assert');
        }

        if ($expr instanceof StaticCall
            && $expr->class instanceof Node\Name
            && $this->isName(node: $expr->class, name: 'self')
        ) {
            $methodName = $this->getName(node: $expr->name);

            return $methodName !== null && str_starts_with(haystack: $methodName, needle: 'assert');
        }

        return false;
    }

    /**
     * @param Stmt[] $stmts
     */
    private function findFirstAssert(array $stmts): ?int
    {
        foreach ($stmts as $i => $stmt) {
            if ($stmt instanceof Expression && $this->isAssertCall(expr: $stmt->expr)) {
                return $i;
            }
        }

        return null;
    }

    /**
     * @param Stmt[] $stmts
     */
    private function findLastNonAssert(array $stmts, int $firstAssertIndex): int
    {
        // Find the last statement before the first assert that is not an assert
        for ($i = $firstAssertIndex - 1; $i >= 0; --$i) {
            if (! $this->isAssertStatement(stmt: $stmts[$i])) {
                return $i;
            }
        }

        return $firstAssertIndex - 1; // fallback
    }

    private function isAssertStatement(Stmt $stmt): bool
    {
        return $stmt instanceof Expression && $this->isAssertCall(expr: $stmt->expr);
    }

    public function refactor(Node $node): ?Node
    {
        if (! $node instanceof ClassMethod) {
            return null;
        }

        if (! $this->isTestMethod(classMethod: $node)) {
            return null;
        }

        if ($node->stmts === null || $node->stmts === []) {
            return null;
        }

        $stmts = $node->stmts;

        $firstAssertIndex = $this->findFirstAssert(stmts: $stmts);

        if ($firstAssertIndex === null) {
            return null;
        }

        // Remove all existing AAA comments first
        foreach ($stmts as $stmt) {
            $this->removeAaaComments(stmt: $stmt);
        }

        // Handle simple case: only one statement before assert (treat as Act only)
        if ($firstAssertIndex === 1) {
            $this->addAaaComment(stmt: $stmts[0], aaaComment: 'Act');
        } else {
            // Multiple statements before assert
            // First statement gets "Arrange"
            if (isset($stmts[0])) {
                $this->addAaaComment(stmt: $stmts[0], aaaComment: 'Arrange');
            }

            // Last non-assert statement before first assert gets "Act"
            $lastActIndex = $this->findLastNonAssert(stmts: $stmts, firstAssertIndex: $firstAssertIndex);
            if ($lastActIndex > 0 && isset($stmts[$lastActIndex])) {
                $this->addAaaComment(stmt: $stmts[$lastActIndex], aaaComment: 'Act');
            }
        }

        // First assert gets "Assert"
        if (isset($stmts[$firstAssertIndex])) {
            $this->addAaaComment(stmt: $stmts[$firstAssertIndex], aaaComment: 'Assert');
        }

        return $node;
    }
}