Allow to validate ArrayObject in key-related values

Because of that, I also updated some data providers to distinguish between "values" and "types", similar to some of the rules we already have. Signed-off-by: Henrique Moody <[email protected]>
Respect · Mar 8, 2024 · fe68eab · fe68eab
1 parent 7ded68c
commit fe68eab
Show file tree

Hide file tree

Showing 10 changed files with 55 additions and 37 deletions.
diff --git a/library/Rules/KeyExists.php b/library/Rules/KeyExists.php
@@ -9,6 +9,7 @@
 
 namespace Respect\Validation\Rules;
 
+use ArrayAccess;
 use Respect\Validation\Message\Template;
 use Respect\Validation\Result;
 use Respect\Validation\Rules\Core\Standard;
@@ -34,6 +35,14 @@ public function evaluate(mixed $input): Result
 
     private function hasKey(mixed $input): bool
     {
-        return is_array($input) && array_key_exists($this->key, $input);
+        if (is_array($input)) {
+            return array_key_exists($this->key, $input);
+        }
+
+        if ($input instanceof ArrayAccess) {
+            return $input->offsetExists($this->key);
+        }
+
+        return false;
     }
 }
diff --git a/tests/library/TestCase.php b/tests/library/TestCase.php
@@ -76,25 +76,25 @@ public static function assertInvalidInput(Validatable $rule, mixed $input): void
     public static function providerForAnyValues(): array
     {
         return array_merge(
-            self::providerForStringValues(),
+            self::providerForStringTypes(),
             self::providerForNonScalarValues(),
             self::providerForEmptyIterableValues(),
             self::providerForNonEmptyIterableValues(),
-            self::providerForNonIterableValues(),
-            self::providerForIntegerValues(),
-            self::providerForBooleanValues(),
-            self::providerForFloatValues(),
+            self::providerForNonIterableTypes(),
+            self::providerForIntegerTypes(),
+            self::providerForBooleanTypes(),
+            self::providerForFloatTypes(),
         );
     }
 
     /** @return array<array{scalar}> */
     public static function providerForScalarValues(): array
     {
         return array_merge(
-            self::providerForStringValues(),
-            self::providerForIntegerValues(),
-            self::providerForBooleanValues(),
-            self::providerForFloatValues(),
+            self::providerForStringTypes(),
+            self::providerForIntegerTypes(),
+            self::providerForBooleanTypes(),
+            self::providerForFloatTypes(),
         );
     }
 
@@ -119,7 +119,7 @@ public static function providerForNonScalarValues(): array
     }
 
     /** @return array<array{mixed}> */
-    public static function providerForNonIterableValues(): array
+    public static function providerForNonIterableTypes(): array
     {
         return array_merge(
             self::providerForScalarValues(),
@@ -133,7 +133,7 @@ public static function providerForNonIterableValues(): array
     }
 
     /** @return array<array{iterable<mixed>}> */
-    public static function providerForIterableValues(): array
+    public static function providerForIterableTypes(): array
     {
         return array_merge(
             self::providerForNonEmptyIterableValues(),
@@ -162,7 +162,7 @@ public static function providerForEmptyIterableValues(): array
     }
 
     /** @return array<array{string}> */
-    public static function providerForStringValues(): array
+    public static function providerForStringTypes(): array
     {
         return [
             'string' => ['string'],
@@ -174,27 +174,27 @@ public static function providerForStringValues(): array
     }
 
     /** @return array<array{string}> */
-    public static function providerForNonEmptyStringValues(): array
+    public static function providerForNonEmptyStringTypes(): array
     {
-        $dataProvider = self::providerForStringValues();
+        $dataProvider = self::providerForStringTypes();
         unset($dataProvider['empty string']);
 
         return $dataProvider;
     }
 
     /** @return array<array{mixed}> */
-    public static function providerForNonStringValues(): array
+    public static function providerForNonStringTypes(): array
     {
         return array_merge(
             self::providerForNonScalarValues(),
-            self::providerForIntegerValues(),
-            self::providerForBooleanValues(),
-            self::providerForFloatValues(),
+            self::providerForIntegerTypes(),
+            self::providerForBooleanTypes(),
+            self::providerForFloatTypes(),
         );
     }
 
     /** @return array<array{int}> */
-    public static function providerForIntegerValues(): array
+    public static function providerForIntegerTypes(): array
     {
         return [
             'zero integer' => [0],
@@ -204,7 +204,7 @@ public static function providerForIntegerValues(): array
     }
 
     /** @return array<array{bool}> */
-    public static function providerForBooleanValues(): array
+    public static function providerForBooleanTypes(): array
     {
         return [
             'true' => [true],
@@ -213,7 +213,7 @@ public static function providerForBooleanValues(): array
     }
 
     /** @return array<array{float}> */
-    public static function providerForFloatValues(): array
+    public static function providerForFloatTypes(): array
     {
         return [
             'zero float' => [0.0],
@@ -223,20 +223,29 @@ public static function providerForFloatValues(): array
     }
 
     /** @return array<array{mixed}> */
-    public static function providerForNonArrayValues(): array
+    public static function providerForNonArrayTypes(): array
     {
         $scalarValues = self::providerForNonScalarValues();
         unset($scalarValues['array']);
 
         return array_merge(
-            self::providerForIntegerValues(),
-            self::providerForBooleanValues(),
-            self::providerForFloatValues(),
-            self::providerForStringValues(),
+            self::providerForIntegerTypes(),
+            self::providerForBooleanTypes(),
+            self::providerForFloatTypes(),
+            self::providerForStringTypes(),
             $scalarValues,
         );
     }
 
+    /** @return array<array{mixed}> */
+    public static function providerForNonArrayValues(): array
+    {
+        $arrayTypes = self::providerForNonArrayTypes();
+        unset($arrayTypes['ArrayObject']);
+
+        return $arrayTypes;
+    }
+
     /** @return array<string, array{string|int, array<mixed>}> */
     public static function providerForArrayWithMissingKeys(): array
     {

diff --git a/tests/unit/Message/Parameter/StringifyTest.php b/tests/unit/Message/Parameter/StringifyTest.php
@@ -22,7 +22,7 @@ final class StringifyTest extends TestCase
     public const DEFAULT_NAME = 'not_name';
 
     #[Test]
-    #[DataProvider('providerForStringValues')]
+    #[DataProvider('providerForStringTypes')]
     public function itShouldNotStringifyValueWhenNameIsNameAndValueIsString(string $value): void
     {
         $stringify = new Stringify();

diff --git a/tests/unit/Message/Parameter/TransTest.php b/tests/unit/Message/Parameter/TransTest.php
@@ -21,7 +21,7 @@ final class TransTest extends TestCase
     public const DEFAULT_NAME = 'foo';
 
     #[Test]
-    #[DataProvider('providerForStringValues')]
+    #[DataProvider('providerForStringTypes')]
     public function itShouldReturnTranslatedValueWhenModifierIsTransAndInputIsString(string $value): void
     {
         $translation = 'translated';
@@ -33,7 +33,7 @@ public function itShouldReturnTranslatedValueWhenModifierIsTransAndInputIsString
     }
 
     #[Test]
-    #[DataProvider('providerForNonStringValues')]
+    #[DataProvider('providerForNonStringTypes')]
     public function itShouldUseNextProcessorWhenModifierIsTransButInputIsNotString(mixed $value): void
     {
         $next = new TestingProcessor();

diff --git a/tests/unit/Rules/Core/FilteredNonEmptyArrayTest.php b/tests/unit/Rules/Core/FilteredNonEmptyArrayTest.php
@@ -22,7 +22,7 @@
 final class FilteredNonEmptyArrayTest extends TestCase
 {
     #[Test]
-    #[DataProvider('providerForNonIterableValues')]
+    #[DataProvider('providerForNonIterableTypes')]
     public function itShouldInvalidateNonIterableValues(mixed $input): void
     {
         $sut = new ConcreteFilteredNonEmptyArray(Stub::daze());

diff --git a/tests/unit/Rules/Core/FilteredStringTest.php b/tests/unit/Rules/Core/FilteredStringTest.php
@@ -87,7 +87,7 @@ public function itShouldPassExtraTemplateAndNonEmptyParametersWhenInputIsAnEmpty
     }
 
     #[Test]
-    #[DataProvider('providerForNonEmptyStringValues')]
+    #[DataProvider('providerForNonEmptyStringTypes')]
     public function itShouldFilterNothingWhenHasNoAdditionalCharacters(string $input): void
     {
         $rule = new ConcreteFilteredString();

diff --git a/tests/unit/Rules/DomainTest.php b/tests/unit/Rules/DomainTest.php
@@ -34,7 +34,7 @@ public function itShouldValidateDomainsWithRealTopLevelDomain(string $input): vo
     }
 
     #[Test]
-    #[DataProvider('providerForNonStringValues')]
+    #[DataProvider('providerForNonStringTypes')]
     public function itShouldInvalidWhenInputIsNotString(mixed $input): void
     {
         self::assertInvalidInput(new Domain(), $input);

diff --git a/tests/unit/Rules/IterableTypeTest.php b/tests/unit/Rules/IterableTypeTest.php
@@ -21,7 +21,7 @@ final class IterableTypeTest extends TestCase
 {
     /** @param iterable<mixed> $input */
     #[Test]
-    #[DataProvider('providerForIterableValues')]
+    #[DataProvider('providerForIterableTypes')]
     public function itShouldValidateIterableTypes(iterable $input): void
     {
         $rule = new IterableType();
@@ -30,7 +30,7 @@ public function itShouldValidateIterableTypes(iterable $input): void
     }
 
     #[Test]
-    #[DataProvider('providerForNonIterableValues')]
+    #[DataProvider('providerForNonIterableTypes')]
     public function itShouldInvalidateNonIterableTypes(mixed $input): void
     {
         $rule = new IterableType();

diff --git a/tests/unit/Rules/MaxTest.php b/tests/unit/Rules/MaxTest.php
@@ -22,7 +22,7 @@
 final class MaxTest extends TestCase
 {
     #[Test]
-    #[DataProvider('providerForNonIterableValues')]
+    #[DataProvider('providerForNonIterableTypes')]
     public function itShouldInvalidateNonIterableValues(mixed $input): void
     {
         $rule = new Max(Stub::daze());

diff --git a/tests/unit/Rules/MinTest.php b/tests/unit/Rules/MinTest.php
@@ -22,7 +22,7 @@
 final class MinTest extends TestCase
 {
     #[Test]
-    #[DataProvider('providerForNonIterableValues')]
+    #[DataProvider('providerForNonIterableTypes')]
     public function itShouldInvalidateNonIterableValues(mixed $input): void
     {
         $rule = new Min(Stub::daze());