test: incorrect calls to validators

Author: midesweb

src/AssociativeArrayValidator.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Escuelait\MagnificValidator;
+
+class AssociativeArrayValidator implements Validator
+{
+    public static function isRuleMatched($rule): bool
+    {
+        return $rule === 'associative_array';
+    }
+
+    public function validate(mixed $value): array
+    {
+        if(!is_array($value)) {
+            return ['The input is not an array'];
+        }
+
+        if ([] === $value) {
+            return ['The input has not keys'];
+        }
+
+        return array_keys($value) !== range(0, count($value) - 1)
+            ? []
+            : ['The input is not an associative array'];
+    }
+}

src/FieldValidator.php

@@ -10,6 +10,8 @@ class FieldValidator implements Validator {
 
   public function __construct($rules)
   {
+    assert(count((new StringsArrayValidator())->validate($rules)) === 0, 'Not valid rules for FieldValidator');
+
     $this->rules = $rules;
   }
 

src/FormValidator.php

@@ -4,6 +4,8 @@
 
 namespace Escuelait\MagnificValidator;
 
+use InvalidArgumentException;
+
 class FormValidator implements Validator
 {
     private $rules;
@@ -15,6 +17,10 @@ public function __construct(array $rules)
 
     public function validate($values): array
     {
+        if(count((new AssociativeArrayValidator())->validate($values)) > 0) {
+            throw(new InvalidArgumentException('Not valid form values'));
+        }
+        
         $formErrors = [];
         foreach ($this->rules as $fieldName => $ruleNames) {
             $fieldErrors = $this->validateValue($values[$fieldName], $ruleNames);

src/StringsArrayValidator.php

@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Escuelait\MagnificValidator;
+
+class StringsArrayValidator implements Validator
+{
+    public static function isRuleMatched($rule): bool
+    {
+        return $rule === 'strings_array';
+    }
+
+    public function validate(mixed $array): array
+    {
+        if(!is_array($array)) {
+            return ['Input is not an array'];
+        }
+
+        // Verifica que las claves sean numéricas consecutivas
+        if (array_keys($array) !== range(0, count($array) - 1)) {
+            return ['Input is not a numeric array'];
+        }
+
+        // Verifica que todos los valores sean strings
+        foreach ($array as $string) {
+            if (!is_string($string)) {
+                return ['Not array values are strings'];
+            }
+        }
+
+        return [];
+    }
+}

src/ValidatorsFactory.php

@@ -4,10 +4,15 @@
 
 namespace Escuelait\MagnificValidator;
 
+use InvalidArgumentException;
+
 class ValidatorsFactory
 {
 
     public function create(mixed $rules) {
+        if(!is_string($rules) && !$this->isAssociativeArray($rules) && !$this->isNumericArrayOfStrings($rules)) {
+            throw(new InvalidArgumentException("Not valid input to create a validator"));
+        }
         if(is_string($rules)) {
             $validatorStrategyFactory = new ValidatorsStrategyFactory();
             return new($validatorStrategyFactory->matchedValidator($rules))($rules);
@@ -20,29 +25,15 @@ public function create(mixed $rules) {
         }
     }
 
-    private function isAssociativeArray(array $array): bool
+    private function isAssociativeArray($rules): bool
     {
-        if ([] === $array) {
-            return false;
-        }
-
-        return array_keys($array) !== range(0, count($array) - 1);
+        $associativeArrayValidator = new AssociativeArrayValidator();
+        return count($associativeArrayValidator->validate($rules)) === 0;
     }
 
-    private function isNumericArrayOfStrings(array $array): bool
+    private function isNumericArrayOfStrings($rules): bool
     {
-        // Verifica que las claves sean numéricas consecutivas
-        if (array_keys($array) !== range(0, count($array) - 1)) {
-            return false;
-        }
-
-        // Verifica que todos los valores sean strings
-        foreach ($array as $value) {
-            if (!is_string($value)) {
-                return false;
-            }
-        }
-
-        return true;
+        $stringsArrayValidator = new StringsArrayValidator();
+        return count($stringsArrayValidator->validate($rules)) === 0;
     }
 }

tests/FieldValidatorTest.php

@@ -0,0 +1,60 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Escuelait\Tests\MagnificValidator;
+
+use AssertionError;
+use PHPUnit\Framework\TestCase;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\Attributes\DataProvider;
+use Escuelait\MagnificValidator\FieldValidator;
+
+class FieldValidatorTest extends TestCase
+{
+
+    public static function validValuesDataProvider() {
+        return [
+            [
+                ['required', 'email'],
+                'mik@escuela.it',
+            ],
+            [
+                ['required'],
+                'escuela.it',
+            ],
+        ];
+    }
+
+    #[Test]
+    #[DataProvider('validValuesDataProvider')]
+    public function itRecivesAnExceptionWhenValidatingWithIncorrectInput($rules, $values)
+    {
+        $validator =  new FieldValidator($rules);
+        $errors = $validator->validate($values);
+        $this->assertEmpty($errors);
+    }
+
+    public static function invalidValuesDataProvider() {
+        return [
+            [['something', 'foo']],
+            [null],
+        ];
+    }
+
+    #[Test]
+    #[DataProvider('invalidValuesDataProvider')]
+    public function itDontValidates($values)
+    {
+        $validator =  new FieldValidator(['required', 'email']);
+        $errors = $validator->validate($values);
+        $this->assertNotEmpty($errors);
+    }
+
+    // #[Test]
+    // public function itCantCreateFieldValidatorWithInvalidRules() {
+    //     $this->expectException(AssertionError::class);
+    //     new FieldValidator(344);
+    // }
+
+}

tests/FormValidatorTest.php

@@ -219,6 +219,25 @@ public function itRecivesAnExceptionWhenRuleIsNotReal()
         $validator->validate(['comment' => 'something']);
     }
 
+    public static function invalidFormValuesDataProvider() {
+        return [
+            [2],
+            ['something'],
+            [['something', 'foo']],
+            [null],
+        ];
+    }
+
+    #[Test]
+    #[DataProvider('invalidFormValuesDataProvider')]
+    public function itRecivesAnExceptionWhenValidatingWithIncorrectInput($values)
+    {
+        $validator =  new FormValidator(['comment' => ['required', 'not_a_real_rule']]);
+        $this->expectException(\InvalidArgumentException::class);
+        $this->expectExceptionMessage("Not valid form values");
+        $validator->validate($values);
+    }
+
     #[Test]
     public function itInformsValidationErrors()
     {

tests/ValidatorsFactoryTest.php

@@ -11,6 +11,24 @@
 
 class ValidatorsFactoryTest extends TestCase {
 
+  public static function notValidInputProvider() {
+    return [
+      [5],
+      [true],
+      [5.09],
+      [null],
+    ];
+  }
+
+  #[Test]
+  #[DataProvider('notValidInputProvider')]
+  public function itThrowsAnErrorWhenTryToCreateValidatorWithInvalidData($input) {
+    $validatorFactory = new ValidatorsFactory();
+    $this->expectException(\InvalidArgumentException::class);
+    $this->expectExceptionMessage("Not valid input to create a validator");
+    $validatorFactory->create($input);
+  }
+
   #[Test]
   public function itValidatesAForm() {
     $validatorFactory = new ValidatorsFactory();