* fix not reset keys of reordered array for value of unique param `po…

…stTypes` @ `addDefaultParamsThenValidate()`

* inline field `$currentPostTypes` as param of method `validate4000(3|4)()`
@ `ParamsValidator`

* now will throw exception when passing an array with numeric as its first key
* mark public field `$name` as readonly
@ `QueryParam`

* lower the visibility of field `$params` from `protected` to `private` @ `QueryParams`
@ `App\Http\PostsQuery`

* move data from test into provider methods @ `BaseQueryTest` & `CursorCodecTest`
@ `Tests\Feature\App\Http\PostsQuery`
@ be

be/app/Http/Controllers/PostsQuery.php

@@ -50,7 +50,7 @@ public function query(\Illuminate\Http\Request $request): array
         $isSearchQuery = !$isIndexQuery;
         Helper::abortAPIIf(40002, $isSearchQuery && $isFidParamNull);
 
-        $validator->addDefaultParamsThenValidate($isIndexQuery);
+        $validator->addDefaultParamsThenValidate(shouldSkip40003: $isIndexQuery);
 
         $queryClass = $isIndexQuery ? IndexQuery::class : SearchQuery::class;
         $this->debugbar->startMeasure('$queryClass->query()');

be/app/Http/PostsQuery/ParamsValidator.php

@@ -13,7 +13,6 @@ class ParamsValidator
 
     public QueryParams $params;
 
-    protected array $currentPostTypes;
 
     /** @param array[] $params */
     public function __construct(private readonly Factory $validator, array $params)
@@ -29,12 +28,13 @@ public function addDefaultParamsThenValidate(bool $shouldSkip40003): void
         $this->params->addDefaultValueOnParams();
         $this->params->addDefaultValueOnUniqueParams();
         // sort here to prevent further sort while validating
-        $this->params->setUniqueParamValue('postTypes', Arr::sort($this->params->getUniqueParamValue('postTypes')));
-        $this->currentPostTypes = (array) $this->params->getUniqueParamValue('postTypes');
+        $sortedPostTypes = collect($this->params->getUniqueParamValue('postTypes'))->sort()->values()->all();
+        $this->params->setUniqueParamValue('postTypes', $sortedPostTypes);
+        $currentPostTypes = (array) $this->params->getUniqueParamValue('postTypes');
         if (!$shouldSkip40003) {
-            $this->validate40003();
+            $this->validate40003($currentPostTypes);
         }
-        $this->validate40004();
+        $this->validate40004($currentPostTypes);
     }
 
     private function validateParamsValue(array $params): void
@@ -106,7 +106,7 @@ private static function isRequiredPostTypes(array $current, array $required): bo
             : $current === $required[1];
     }
 
-    private function validate40003(): void
+    private function validate40003(array $currentPostTypes): void
     {
         $paramsRequiredPostTypes = [
             'pid' => ['SUB', ['reply', 'subReply']],
@@ -127,12 +127,12 @@ private function validate40003(): void
         ];
         foreach ($paramsRequiredPostTypes as $paramName => $requiredPostTypes) {
             if ($this->params->pick($paramName) !== []) {
-                Helper::abortAPIIfNot(40003, self::isRequiredPostTypes($this->currentPostTypes, $requiredPostTypes));
+                Helper::abortAPIIfNot(40003, self::isRequiredPostTypes($currentPostTypes, $requiredPostTypes));
             }
         }
     }
 
-    private function validate40004(): void
+    private function validate40004(array $currentPostTypes): void
     {
         $orderByRequiredPostTypes = [
             'pid' => ['SUB', ['reply', 'subReply']],
@@ -142,7 +142,7 @@ private function validate40004(): void
         if (\array_key_exists($currentOrderBy, $orderByRequiredPostTypes)) {
             Helper::abortAPIIfNot(
                 40004,
-                self::isRequiredPostTypes($this->currentPostTypes, $orderByRequiredPostTypes[$currentOrderBy]),
+                self::isRequiredPostTypes($currentPostTypes, $orderByRequiredPostTypes[$currentOrderBy]),
             );
         }
     }

be/app/Http/PostsQuery/QueryParam.php

@@ -4,7 +4,7 @@
 
 class QueryParam
 {
-    public string $name;
+    public readonly string $name;
 
     public array|string|int $value;
 
@@ -13,6 +13,9 @@ class QueryParam
     public function __construct(array $param)
     {
         $this->name = (string) array_keys($param)[0];
+        if (is_numeric($this->name)) {
+            throw new \InvalidArgumentException();
+        }
         $this->value = $param[$this->name];
         array_shift($param);
         $this->subParams = $param;

be/app/Http/PostsQuery/QueryParams.php

@@ -7,12 +7,12 @@
 class QueryParams
 {
     /** @var QueryParam[] */
-    protected array $params;
+    private array $params;
 
     /** @param array[] $params */
     public function __construct(array $params)
     {
-        $this->params = array_map(static fn($p) => new QueryParam($p), $params);
+        $this->params = array_map(static fn(array $p) => new QueryParam($p), $params);
     }
 
     /** @psalm-return int<0, max> */

be/tests/Feature/App/Http/PostsQuery/BaseQueryTest.php

@@ -11,7 +11,6 @@
 use Barryvdh\Debugbar\LaravelDebugbar;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\DataProvider;
-use PHPUnit\Framework\Attributes\Test;
 use Tests\TestCase;
 
 #[CoversClass(BaseQuery::class)]
@@ -35,10 +34,9 @@ public function testPerPageItemsDefaultValue(): void
         self::assertEquals(50, $prop->getValue($this->sut));
     }
 
-    #[Test]
-    #[DataProvider('reOrderNestedPostsDataProvider')]
+    #[DataProvider('provideReOrderNestedPostsData')]
     /** @backupStaticAttributes enabled */
-    public function reOrderNestedPosts(
+    public function testReOrderNestedPosts(
         array $input,
         bool $orderByDesc,
         array $expected,
@@ -50,11 +48,11 @@ public function reOrderNestedPosts(
         if ($shouldRemoveSortingKey) { // make https://infection.github.io/guide/mutators.html#TrueValue happy
             self::assertEquals($expected, $this->sut->reOrderNestedPosts($input));
         } else {
-            self::assertEquals($expected, $this->sut->reOrderNestedPosts($input, false));
+            self::assertEquals($expected, $this->sut->reOrderNestedPosts($input, shouldRemoveSortingKey: false));
         }
     }
 
-    public static function reOrderNestedPostsDataProvider(): array
+    public static function provideReOrderNestedPostsData(): array
     {
         $input = [
             [
@@ -223,24 +221,36 @@ public static function reOrderNestedPostsDataProvider(): array
         ];
     }
 
-    #[Test]
+    #[DataProvider('provideNestPostsWithParent')]
     /** @backupStaticAttributes enabled */
-    public function nestPostsWithParent(): void
+    public function testNestPostsWithParent(array $input, array $expected): void
+    {
+        self::assertEquals(
+            collect($expected)->recursive(),
+            $this->sut->nestPostsWithParent(...array_map('collect', $input)),
+        );
+    }
+
+    public static function provideNestPostsWithParent(): array
     {
         (new \ReflectionClass(Post::class))->setStaticPropertyValue('unguarded', true);
-        $input = array_map('collect', [
-            'threads' => [new Thread(['tid' => 1])],
-            'replies' => [new Reply(['tid' => 1, 'pid' => 2])],
-            'subReplies' => [new SubReply(['tid' => 1, 'pid' => 2, 'spid' => 3])],
-        ]);
-        $expected = collect([[
-            'tid' => 1,
-            'replies' => [[
+        $ret = [[
+            [
+                'threads' => [new Thread(['tid' => 1])],
+                'replies' => [new Reply(['tid' => 1, 'pid' => 2])],
+                'subReplies' => [new SubReply(['tid' => 1, 'pid' => 2, 'spid' => 3])],
+            ],
+            [[
                 'tid' => 1,
-                'pid' => 2,
-                'subReplies' => [['tid' => 1, 'pid' => 2, 'spid' => 3]],
+                'replies' => [[
+                    'tid' => 1,
+                    'pid' => 2,
+                    'subReplies' => [['tid' => 1, 'pid' => 2, 'spid' => 3]],
+                ]],
             ]],
-        ]])->recursive();
-        self::assertEquals($expected, $this->sut->nestPostsWithParent(...$input));
+        ]];
+        // https://github.com/sebastianbergmann/phpunit/issues/5103
+        (new \ReflectionClass(Post::class))->setStaticPropertyValue('unguarded', false);
+        return $ret;
     }
 }

be/tests/Feature/App/Http/PostsQuery/CursorCodecTest.php

@@ -1,14 +1,15 @@
 <?php
 
-namespace App\Http\PostsQuery;
+namespace Tests\Feature\App\Http\PostsQuery;
 
 use App\Eloquent\Model\Post\Post;
 use App\Eloquent\Model\Post\Reply;
 use App\Eloquent\Model\Post\SubReply;
 use App\Eloquent\Model\Post\Thread;
+use App\Http\PostsQuery\CursorCodec;
 use Illuminate\Pagination\Cursor;
 use PHPUnit\Framework\Attributes\CoversClass;
-use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\Attributes\DataProvider;
 use Tests\TestCase;
 
 #[CoversClass(CursorCodec::class)]
@@ -22,34 +23,50 @@ protected function setUp(): void
         $this->sut = new CursorCodec();
     }
 
-    #[Test]
-    /** @backupStaticAttributes enabled */
-    public function encodeNextCursor(): void
+    #[DataProvider('provideEncodeNextCursor')]
+    public function testEncodeNextCursor(string $cursor, array $input): void
+    {
+        self::assertEquals($cursor, $this->sut->encodeNextCursor(collect($input)->recursive(maxDepth: 0), 'postedAt'));
+    }
+
+    public static function provideEncodeNextCursor(): array
     {
         (new \ReflectionClass(Post::class))->setStaticPropertyValue('unguarded', true);
-        $input = collect([
-            'threads' => [new Thread(['tid' => 1, 'postedAt' => 0])],
-            'replies' => [new Reply(['pid' => 2, 'postedAt' => -2147483649])],
-            'subReplies' => [new SubReply(['spid' => 3, 'postedAt' => 'test'])],
-        ])->recursive(maxDepth: 0);
-        self::assertEquals('AQ,0,Ag,-:____fw,Aw,S:test', $this->sut->encodeNextCursor($input, 'postedAt'));
+        $ret = [[
+            'AQ,0,Ag,-:____fw,Aw,S:test',
+            [
+                'threads' => [new Thread(['tid' => 1, 'postedAt' => 0])],
+                'replies' => [new Reply(['pid' => 2, 'postedAt' => -2147483649])],
+                'subReplies' => [new SubReply(['spid' => 3, 'postedAt' => 'test'])],
+            ],
+        ]];
+        // https://github.com/sebastianbergmann/phpunit/issues/5103
+        (new \ReflectionClass(Post::class))->setStaticPropertyValue('unguarded', false);
+        return $ret;
+    }
+
+    #[DataProvider('provideDecodeCursor')]
+    public function testDecodeCursor(string $cursor, array $expected): void
+    {
+        self::assertEquals(collect($expected), $this->sut->decodeCursor($cursor, 'postedAt'));
     }
 
-    #[Test]
-    public function decodeCursor(): void
+    public static function provideDecodeCursor(): array
     {
-        $expected = collect([
-            'thread' => new Cursor(['tid' => 1, 'postedAt' => 0]),
-            'reply' => new Cursor(['pid' => 2, 'postedAt' => -2147483649]),
-            'subReply' => new Cursor(['spid' => 3, 'postedAt' => 'test']),
-        ]);
-        self::assertEquals($expected, $this->sut->decodeCursor('AQ,0,Ag,-:____fw,Aw,S:test', 'postedAt'));
-
-        $expected = collect([
-            'thread' => new Cursor(['tid' => 0, 'postedAt' => 0]),
-            'reply' => new Cursor(['pid' => 0, 'postedAt' => 0]),
-            'subReply' => new Cursor(['spid' => 0, 'postedAt' => 0]),
-        ]);
-        self::assertEquals($expected, $this->sut->decodeCursor(',,,,0,0', 'postedAt'));
+        return [[
+            'AQ,0,Ag,-:____fw,Aw,S:test',
+            [
+                'thread' => new Cursor(['tid' => 1, 'postedAt' => 0]),
+                'reply' => new Cursor(['pid' => 2, 'postedAt' => -2147483649]),
+                'subReply' => new Cursor(['spid' => 3, 'postedAt' => 'test']),
+            ],
+        ], [
+            ',,,,0,0',
+            [
+                'thread' => new Cursor(['tid' => 0, 'postedAt' => 0]),
+                'reply' => new Cursor(['pid' => 0, 'postedAt' => 0]),
+                'subReply' => new Cursor(['spid' => 0, 'postedAt' => 0]),
+            ],
+        ]];
     }
 }