Merge pull request #6 from netsells/feature/laravel-11-support

Add support for Laravel 11

Author: bensherred

.github/workflows/tests.yaml

@@ -11,8 +11,8 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        php: ['8.1', '8.2']
-        laravel: ['^9.1', '^10.0']
+        php: ['8.2', '8.3']
+        laravel: ['^10.0', '^11.0']
 
     steps:
       - name: Checkout the repo

composer.json

@@ -22,12 +22,15 @@
         }
     ],
     "require": {
-        "php": "^8.1",
-        "hashids/hashids": "^4.1",
-        "laravel/framework": "^9.1 || ^10.0"
+        "php": "^8.2",
+        "hashids/hashids": "^5.0",
+        "illuminate/contracts": "^10.0|^11.0",
+        "illuminate/database": "^10.0|^11.0",
+        "illuminate/support": "^10.0|^11.0",
+        "illuminate/validation": "^10.0|^11.0"
     },
     "require-dev": {
-        "orchestra/testbench": "^7.1 || ^8.0"
+        "orchestra/testbench": "^8.0|^9.0"
     },
     "autoload": {
         "psr-4": {

src/ExistsWithHashedIdRule.php

@@ -2,7 +2,8 @@
 
 namespace Netsells\HashModelIds;
 
-use Illuminate\Contracts\Validation\Rule;
+use Closure;
+use Illuminate\Contracts\Validation\ValidationRule;
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Support\Traits\ForwardsCalls;
@@ -11,7 +12,7 @@
 /**
  * @mixin \Illuminate\Database\Eloquent\Builder
  */
-class ExistsWithHashedIdRule implements Rule
+class ExistsWithHashedIdRule implements ValidationRule
 {
     use ForwardsCalls;
 
@@ -52,33 +53,41 @@ public function __construct(string $class)
     }
 
     /**
-     * Determine if the validation rule passes.
+     * Run the validation rule.
      *
-     * @param  string  $attribute
+     * @param  string|null  $attribute
      * @param  mixed  $value
-     * @return bool
+     * @param  \Closure(string): \Illuminate\Translation\PotentiallyTranslatedString  $fail
+     * @return void
      */
-    public function passes($attribute, $value): bool
+    public function validate(?string $attribute, mixed $value, Closure $fail): void
     {
         if (! is_string($value) || empty($value)) {
-            return false;
+            $this->fail($fail);
+
+            return;
         }
 
-        return $this->class::whereHashedId($value)
+        $doesntExist = $this->class::whereHashedId($value)
             ->tap(function (Builder $query) {
                 $this->applyConstraints($query);
             })
-            ->exists();
+            ->doesntExist();
+
+        if ($doesntExist) {
+            $this->fail($fail);
+        }
     }
 
     /**
-     * Get the validation error message.
+     * Fail the validation.
      *
-     * @return string
+     * @param  \Closure(string): \Illuminate\Translation\PotentiallyTranslatedString  $fail
+     * @return void
      */
-    public function message(): string
+    public function fail(Closure $fail): void
     {
-        return __('hashModelIds::validation.model_not_exist_for_hashed_id', [
+        $fail('hashModelIds::validation.model_not_exist_for_hashed_id')->translate([
             'name' => class_basename($this->class),
         ]);
     }

tests/Integration/ExistsWithHashedIdRuleTest.php

@@ -3,6 +3,9 @@
 namespace Netsells\HashModelIds\Tests\Integration;
 
 use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Translation\Translator;
+use Illuminate\Validation\InvokableValidationRule;
+use Illuminate\Validation\Validator;
 use InvalidArgumentException;
 use Netsells\HashModelIds\ExistsWithHashedIdRule;
 use Netsells\HashModelIds\Tests\Integration\Fixtures\Models;
@@ -25,7 +28,9 @@ public function testRuleExpectsHashingModels(): void
 
     public function testRuleHandlesExpectedValueTypes(): void
     {
-        $rule = new ExistsWithHashedIdRule(Models\Foo::class);
+        $rule = InvokableValidationRule::make(
+            invokable: new ExistsWithHashedIdRule(Models\Foo::class),
+        )->setValidator(validator: $this->getValidator());
 
         $this->assertFalse($rule->passes(null, null));
         $this->assertFalse($rule->passes(null, []));
@@ -36,7 +41,9 @@ public function testRulePassesForExistingHashedId(): void
     {
         $foo = Models\Foo::create();
 
-        $rule = new ExistsWithHashedIdRule(Models\Foo::class);
+        $rule = InvokableValidationRule::make(
+            invokable: new ExistsWithHashedIdRule(Models\Foo::class),
+        )->setValidator(validator: $this->getValidator());
 
         $this->assertTrue($rule->passes(null, $foo->hashed_id));
     }
@@ -45,7 +52,9 @@ public function testRuleFailsForNonExistentHashedId(): void
     {
         $foo = Models\Foo::create();
 
-        $rule = new ExistsWithHashedIdRule(Models\Foo::class);
+        $rule = InvokableValidationRule::make(
+            invokable: new ExistsWithHashedIdRule(Models\Foo::class),
+        )->setValidator(validator: $this->getValidator());
 
         $this->assertFalse($rule->passes(null, $foo->id));
     }
@@ -54,25 +63,32 @@ public function testRuleHandlesConstraintsFluently(): void
     {
         $foo = Models\Foo::create([]);
 
-        $rule = new ExistsWithHashedIdRule(Models\Foo::class);
-
-        $this->assertFalse(
-            $rule
+        $rule = InvokableValidationRule::make(
+            invokable: (new ExistsWithHashedIdRule(Models\Foo::class))
                 ->where(function (Builder $query) use ($foo) {
                     $query->whereId($foo->hashed_id);
-                })
-                ->passes(null, $foo->hashed_id)
-        );
+                }),
+        )->setValidator(validator: $this->getValidator());
 
-        $rule = new ExistsWithHashedIdRule(Models\Foo::class);
+        $this->assertFalse($rule->passes(null, $foo->hashed_id));
 
-        $this->assertTrue(
-            $rule
+        $rule = InvokableValidationRule::make(
+            invokable: (new ExistsWithHashedIdRule(Models\Foo::class))
                 ->where(function (Builder $query) use ($foo) {
                     $query->whereId($foo->id);
                 })
-                ->whereNotNull('created_at')
-                ->passes(null, $foo->hashed_id)
+                ->whereNotNull('created_at'),
+        )->setValidator(validator: $this->getValidator());
+
+        $this->assertTrue($rule->passes(null, $foo->hashed_id));
+    }
+
+    private function getValidator(): Validator
+    {
+        return new Validator(
+            translator: $this->app->make(abstract: Translator::class),
+            data: [],
+            rules: [],
         );
     }
 }

tests/Unit/ModelIdHasherTest.php

@@ -2,7 +2,6 @@
 
 namespace Netsells\HashModelIds\Tests\Unit;
 
-use Illuminate\Database\Eloquent\Model;
 use InvalidArgumentException;
 use Netsells\HashModelIds\ModelIdHasher;
 use Netsells\HashModelIds\Tests\Unit\Fixtures\Models;
@@ -27,8 +26,7 @@ public function testHasherCanEncodeAndDecode(): void
     {
         $idHasher = $this->getNewModelIdHasher();
 
-        /** @var Model|MockObject $model */
-        $model = $this->getMockForAbstractClass(Model::class);
+        $model = new Models\Foo();
 
         $hash = $idHasher->encode($model, 1);
 
@@ -39,11 +37,11 @@ public function testHashesDifferForModelsWithSameId(): void
     {
         $idHasher = $this->getNewModelIdHasher();
 
-        /** @var Model|MockObject $foo */
-        $foo = $this->getMockForAbstractClass(Models\Foo::class);
+        /** @var \Illuminate\Database\Eloquent\Model|\PHPUnit\Framework\MockObject\MockObject $foo */
+        $foo = $this->createMock(Models\Foo::class);
 
-        /** @var Model|MockObject $bar */
-        $bar = $this->getMockForAbstractClass(Models\Bar::class);
+        /** @var \Illuminate\Database\Eloquent\Model|\PHPUnit\Framework\MockObject\MockObject $bar */
+        $bar = $this->createMock(Models\Bar::class);
 
         $this->assertNotSame($idHasher->encode($foo, 1), $idHasher->encode($bar, 1));
     }