add test for ClassConstantResultAnalyser, fix regex message

src/Command/PrivatizeConstantsCommand.php

@@ -85,11 +85,11 @@ protected function execute(InputInterface $input, OutputInterface $output): int
         }
 
         // make public first, to avoid override to protected
-        foreach ($publicAndProtectedClassConstants->getPublicClassConstMatch() as $publicClassConstMatch) {
+        foreach ($publicAndProtectedClassConstants->getPublicClassConstMatches() as $publicClassConstMatch) {
             $this->replacePrivateConstWith($publicClassConstMatch, 'public const');
         }
 
-        foreach ($publicAndProtectedClassConstants->getProtectedClassConstMatch() as $publicClassConstMatch) {
+        foreach ($publicAndProtectedClassConstants->getProtectedClassConstMatches() as $publicClassConstMatch) {
             $this->replacePrivateConstWith($publicClassConstMatch, 'protected const');
         }
 

src/PHPStan/ClassConstantResultAnalyser.php

@@ -7,7 +7,11 @@
 use Nette\Utils\Strings;
 use Rector\SwissKnife\ValueObject\ClassConstMatch;
 use Rector\SwissKnife\ValueObject\PublicAndProtectedClassConstants;
+use Webmozart\Assert\Assert;
 
+/**
+ * @see \Rector\SwissKnife\Tests\PHPStan\ClassConstantResultAnalyserTest
+ */
 final class ClassConstantResultAnalyser
 {
     /**
@@ -18,9 +22,9 @@ final class ClassConstantResultAnalyser
 
     /**
      * @var string
-     * @see https://regex101.com/r/pRzdnw/1
+     * @see https://regex101.com/r/V1QOPN/1
      */
-    private const PROTECTED_CONSTANT_MESSAGE_REGEX = '#Access to undefined constant (?<class_name>[\w\\\\]+)::(?<constant_name>.*?)#';
+    private const PROTECTED_CONSTANT_MESSAGE_REGEX = '#Access to undefined constant (?<class_name>[\w\\\\]+)::(?<constant_name>[\w\_]+)#';
 
     /**
      * @param mixed[] $phpstanResult
@@ -30,8 +34,14 @@ public function analyseResult(array $phpstanResult): PublicAndProtectedClassCons
         $publicClassConstMatches = [];
         $protectedClassConstMatches = [];
 
+        Assert::keyExists($phpstanResult, 'files');
+
         foreach ($phpstanResult['files'] as $fileDetail) {
+            Assert::keyExists($fileDetail, 'messages');
+
             foreach ($fileDetail['messages'] as $messageError) {
+                Assert::keyExists($messageError, 'message');
+
                 $publicClassConstMatch = $this->matchPublicClassConstMatch($messageError['message']);
                 if ($publicClassConstMatch instanceof ClassConstMatch) {
                     $publicClassConstMatches[] = $publicClassConstMatch;

src/ValueObject/ClassConstMatch.php

@@ -6,6 +6,7 @@
 
 use ReflectionClass;
 use Stringable;
+use Webmozart\Assert\Assert;
 
 final readonly class ClassConstMatch implements Stringable
 {
@@ -16,6 +17,8 @@ public function __construct(
         private string $className,
         private string $constantName
     ) {
+        Assert::notEmpty($constantName);
+        Assert::notEmpty($className);
     }
 
     /**

src/ValueObject/PublicAndProtectedClassConstants.php

@@ -7,43 +7,43 @@
 final readonly class PublicAndProtectedClassConstants
 {
     /**
-     * @param ClassConstMatch[] $publicClassConstMatch
-     * @param ClassConstMatch[] $protectedClassConstMatch
+     * @param ClassConstMatch[] $publicClassConstMatches
+     * @param ClassConstMatch[] $protectedClassConstMatches
      */
     public function __construct(
-        private array $publicClassConstMatch,
-        private array $protectedClassConstMatch
+        private array $publicClassConstMatches,
+        private array $protectedClassConstMatches
     ) {
     }
 
     /**
      * @return ClassConstMatch[]
      */
-    public function getPublicClassConstMatch(): array
+    public function getPublicClassConstMatches(): array
     {
-        return $this->publicClassConstMatch;
+        return $this->publicClassConstMatches;
     }
 
     /**
      * @return ClassConstMatch[]
      */
-    public function getProtectedClassConstMatch(): array
+    public function getProtectedClassConstMatches(): array
     {
-        return $this->protectedClassConstMatch;
+        return $this->protectedClassConstMatches;
     }
 
     public function getProtectedCount(): int
     {
-        return count($this->protectedClassConstMatch);
+        return count($this->protectedClassConstMatches);
     }
 
     public function getPublicCount(): int
     {
-        return count($this->publicClassConstMatch);
+        return count($this->publicClassConstMatches);
     }
 
     public function isEmpty(): bool
     {
-        return $this->publicClassConstMatch === [] && $this->protectedClassConstMatch === [];
+        return $this->publicClassConstMatches === [] && $this->protectedClassConstMatches === [];
     }
 }

tests/PHPStan/ClassConstantResultAnalyserTest.php

@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\SwissKnife\Tests\PHPStan;
+
+use PHPUnit\Framework\TestCase;
+use Rector\SwissKnife\PHPStan\ClassConstantResultAnalyser;
+use Rector\SwissKnife\ValueObject\ClassConstMatch;
+
+final class ClassConstantResultAnalyserTest extends TestCase
+{
+    private ClassConstantResultAnalyser $classConstantResultAnalyser;
+
+    protected function setUp(): void
+    {
+        $this->classConstantResultAnalyser = new ClassConstantResultAnalyser();
+    }
+
+    public function test(): void
+    {
+        $phpstanResult = [
+            'files' => [
+                'some_file_path.php' => [
+                    'messages' => [
+                        [
+                            'line' => 10,
+                            'message' => 'Access to undefined constant App\\SomeClass::SOME_CONSTANT',
+                        ],
+                    ],
+                ],
+            ],
+        ];
+
+        $publicAndProtectedClassConstants = $this->classConstantResultAnalyser->analyseResult($phpstanResult);
+
+        $this->assertFalse($publicAndProtectedClassConstants->isEmpty());
+        $this->assertSame(0, $publicAndProtectedClassConstants->getPublicCount());
+        $this->assertSame(1, $publicAndProtectedClassConstants->getProtectedCount());
+
+        $onlyProtectedClassConstMatch = $publicAndProtectedClassConstants->getProtectedClassConstMatches()[0];
+        $this->assertInstanceOf(ClassConstMatch::class, $onlyProtectedClassConstMatch);
+
+        // $this->assertSame('SOME_CONST', $onlyProtectedClassConstMatch->getConstantName());
+        $this->assertSame('App\SomeClass', $onlyProtectedClassConstMatch->getClassName());
+    }
+}