Merge pull request #4 from programmatordev/YAPV-11-create-lessthan-rule

andrepimpao · web-flow · commit 23d3a2a2b124 · 2023-07-31T16:17:45.000+01:00
Create LessThan rule
diff --git a/composer.json b/composer.json
@@ -12,7 +12,8 @@
         }
     ],
     "require": {
-        "php": ">=8.1"
+        "php": ">=8.1",
+        "symfony/options-resolver": "^6.3"
     },
     "require-dev": {
         "phpunit/phpunit": "^10.0",
diff --git a/src/ChainedValidatorInterface.php b/src/ChainedValidatorInterface.php
@@ -15,7 +15,9 @@ public function validate(mixed $value): bool;
 
     // --- Rules ---
 
-    public function notBlank(string $message = null): ChainedValidatorInterface;
+    public function notBlank(array $options = []): ChainedValidatorInterface;
 
-    public function greaterThan(mixed $constraint, string $message = null): ChainedValidatorInterface;
+    public function greaterThan(mixed $constraint, array $options = []): ChainedValidatorInterface;
+
+    public function lessThan(mixed $constraint, array $options = []): ChainedValidatorInterface;
 }
diff --git a/src/Exception/LessThanException.php b/src/Exception/LessThanException.php
@@ -0,0 +1,5 @@
+<?php
+
+namespace ProgrammatorDev\YetAnotherPhpValidator\Exception;
+
+class LessThanException extends ValidationException {}
diff --git a/src/Factory/Factory.php b/src/Factory/Factory.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace ProgrammatorDev\YetAnotherPhpValidator;
+namespace ProgrammatorDev\YetAnotherPhpValidator\Factory;
 
 use ProgrammatorDev\YetAnotherPhpValidator\Exception\RuleNotFoundException;
 use ProgrammatorDev\YetAnotherPhpValidator\Rule\RuleInterface;
diff --git a/src/Rule/GreaterThan.php b/src/Rule/GreaterThan.php
@@ -4,19 +4,23 @@
 
 use ProgrammatorDev\YetAnotherPhpValidator\Exception\GreaterThanException;
 use ProgrammatorDev\YetAnotherPhpValidator\Rule\Util\AssertComparableTrait;
+use Symfony\Component\OptionsResolver\OptionsResolver;
 
 class GreaterThan extends AbstractRule implements RuleInterface
 {
     use AssertComparableTrait;
 
-    private string $message;
+    private array $options;
 
-    public function __construct(
-        private readonly mixed $constraint,
-        string $message = null
-    )
+    public function __construct(private readonly mixed $constraint, array $options = [])
     {
-        $this->message = $message ?? 'The "{{ name }}" value should be greater than "{{ constraint }}", "{{ value }}" given.';
+        $resolver = new OptionsResolver();
+
+        $resolver->setDefaults(['message' => 'The "{{ name }}" value should be greater than "{{ constraint }}", "{{ value }}" given.']);
+
+        $resolver->setAllowedTypes('message', 'string');
+
+        $this->options = $resolver->resolve($options);
     }
 
     /**
@@ -29,7 +33,7 @@ public function assert(mixed $value, string $name): void
 
         if (!($value > $this->constraint)) {
             throw new GreaterThanException(
-                message: $this->message,
+                message: $this->options['message'],
                 parameters: [
                     'name' => $name,
                     'constraint' => $this->constraint,
diff --git a/src/Rule/LessThan.php b/src/Rule/LessThan.php
@@ -0,0 +1,45 @@
+<?php
+
+namespace ProgrammatorDev\YetAnotherPhpValidator\Rule;
+
+use ProgrammatorDev\YetAnotherPhpValidator\Exception\LessThanException;
+use ProgrammatorDev\YetAnotherPhpValidator\Rule\Util\AssertComparableTrait;
+use Symfony\Component\OptionsResolver\OptionsResolver;
+
+class LessThan extends AbstractRule implements RuleInterface
+{
+    use AssertComparableTrait;
+
+    private array $options;
+
+    public function __construct(private readonly mixed $constraint, array $options = [])
+    {
+        $resolver = new OptionsResolver();
+
+        $resolver->setDefaults(['message' => 'The "{{ name }}" value should be less than "{{ constraint }}", "{{ value }}" given.']);
+
+        $resolver->setAllowedTypes('message', 'string');
+
+        $this->options = $resolver->resolve($options);
+    }
+
+    /**
+     * @throws LessThanException
+     */
+    public function assert(mixed $value, string $name): void
+    {
+        // Assert if constraint and value can be compared
+        $this->assertComparable($this->constraint, $value, LessThanException::class);
+
+        if (!($value < $this->constraint)) {
+            throw new LessThanException(
+                message: $this->options['message'],
+                parameters: [
+                    'name' => $name,
+                    'constraint' => $this->constraint,
+                    'value' => $value
+                ]
+            );
+        }
+    }
+}
diff --git a/src/Rule/NotBlank.php b/src/Rule/NotBlank.php
@@ -3,14 +3,21 @@
 namespace ProgrammatorDev\YetAnotherPhpValidator\Rule;
 
 use ProgrammatorDev\YetAnotherPhpValidator\Exception\NotBlankException;
+use Symfony\Component\OptionsResolver\OptionsResolver;
 
 class NotBlank extends AbstractRule implements RuleInterface
 {
-    private string $message;
+    private array $options;
 
-    public function __construct(string $message = null)
+    public function __construct(array $options = [])
     {
-        $this->message = $message ?? 'The "{{ name }}" value should not be blank, "{{ value }}" given.';
+        $resolver = new OptionsResolver();
+
+        $resolver->setDefaults(['message' => 'The "{{ name }}" value should not be blank, "{{ value }}" given.']);
+
+        $resolver->setAllowedTypes('message', 'string');
+
+        $this->options = $resolver->resolve($options);
     }
 
     /**
@@ -21,7 +28,7 @@ public function assert(mixed $value, string $name): void
         // Do not allow null, false, [] and ''
         if ($value === false || (empty($value) && $value != '0')) {
             throw new NotBlankException(
-                message: $this->message,
+                message: $this->options['message'],
                 parameters: [
                     'name' => $name,
                     'value' => $value
diff --git a/src/StaticValidatorInterface.php b/src/StaticValidatorInterface.php
@@ -4,7 +4,9 @@
 
 interface StaticValidatorInterface
 {
-    public static function notBlank(string $message = null): ChainedValidatorInterface;
+    public static function notBlank(array $options = []): ChainedValidatorInterface;
 
-    public static function greaterThan(mixed $constraint, string $message = null): ChainedValidatorInterface;
+    public static function greaterThan(mixed $constraint, array $options = []): ChainedValidatorInterface;
+
+    public static function lessThan(mixed $constraint, array $options = []): ChainedValidatorInterface;
 }
diff --git a/src/Validator.php b/src/Validator.php
@@ -4,6 +4,7 @@
 
 use ProgrammatorDev\YetAnotherPhpValidator\Exception\RuleNotFoundException;
 use ProgrammatorDev\YetAnotherPhpValidator\Exception\ValidationException;
+use ProgrammatorDev\YetAnotherPhpValidator\Factory\Factory;
 use ProgrammatorDev\YetAnotherPhpValidator\Rule\RuleInterface;
 
 /**
diff --git a/tests/GreaterThanTest.php b/tests/GreaterThanTest.php
@@ -52,10 +52,11 @@ public static function provideRuleSuccessConditionData(): \Generator
     public static function provideRuleCustomMessageData(): \Generator
     {
         yield 'message' => [
-            new GreaterThan(
-                constraint: 10,
-                message: 'The "{{ name }}" value "{{ value }}" is not greater than "{{ constraint }}".'
-            ), 1, 'The "test" value "1" is not greater than "10".'
+            new GreaterThan(10, [
+                'message' => 'The "{{ name }}" value "{{ value }}" is not greater than "{{ constraint }}".'
+            ]),
+            1,
+            'The "test" value "1" is not greater than "10".'
         ];
     }
 }
diff --git a/tests/LessThanTest.php b/tests/LessThanTest.php
@@ -0,0 +1,62 @@
+<?php
+
+namespace ProgrammatorDev\YetAnotherPhpValidator\Test;
+
+use ProgrammatorDev\YetAnotherPhpValidator\Exception\LessThanException;
+use ProgrammatorDev\YetAnotherPhpValidator\Rule\LessThan;
+use ProgrammatorDev\YetAnotherPhpValidator\Test\Util\TestRuleCustomMessageTrait;
+use ProgrammatorDev\YetAnotherPhpValidator\Test\Util\TestRuleFailureConditionTrait;
+use ProgrammatorDev\YetAnotherPhpValidator\Test\Util\TestRuleSuccessConditionTrait;
+
+class LessThanTest extends AbstractTest
+{
+    use TestRuleFailureConditionTrait;
+    use TestRuleSuccessConditionTrait;
+    use TestRuleCustomMessageTrait;
+
+    public static function provideRuleFailureConditionData(): \Generator
+    {
+        $exception = LessThanException::class;
+        $exceptionMessageInvalid = '/Cannot compare a type "(.*)" with a type "(.*)"/';
+        $exceptionMessageFailure = '/The "(.*)" value should be less than "(.*)", "(.*)" given./';
+
+        yield 'datetime constraint with int value' => [new LessThan(new \DateTime()), 10, $exception, $exceptionMessageInvalid];
+        yield 'datetime constraint with float value' => [new LessThan(new \DateTime()), 1.0, $exception, $exceptionMessageInvalid];
+        yield 'datetime constraint with string value' => [new LessThan(new \DateTime()), 'a', $exception, $exceptionMessageInvalid];
+        yield 'int constraint with string value' => [new LessThan(10), 'a', $exception, $exceptionMessageInvalid];
+        yield 'float constraint with string value' => [new LessThan(1.0), 'a', $exception, $exceptionMessageInvalid];
+        yield 'array constraint' => [new LessThan([10]), 10, $exception, $exceptionMessageInvalid];
+        yield 'null constraint' => [new LessThan(null), 10, $exception, $exceptionMessageInvalid];
+
+        yield 'datetime' => [new LessThan(new \DateTime('today')), new \DateTime('tomorrow'), $exception, $exceptionMessageFailure];
+        yield 'same datetime' => [new LessThan(new \DateTime('today')), new \DateTime('today'), $exception, $exceptionMessageFailure];
+        yield 'int' => [new LessThan(10), 20, $exception, $exceptionMessageFailure];
+        yield 'same int' => [new LessThan(10), 10, $exception, $exceptionMessageFailure];
+        yield 'float' => [new LessThan(10.0), 20.0, $exception, $exceptionMessageFailure];
+        yield 'same float' => [new LessThan(10.0), 10.0, $exception, $exceptionMessageFailure];
+        yield 'int with float' => [new LessThan(10), 20.0, $exception, $exceptionMessageFailure];
+        yield 'same int with float' => [new LessThan(10), 10.0, $exception, $exceptionMessageFailure];
+        yield 'string' => [new LessThan('a'), 'z', $exception, $exceptionMessageFailure];
+        yield 'same string' => [new LessThan('a'), 'a', $exception, $exceptionMessageFailure];
+    }
+
+    public static function provideRuleSuccessConditionData(): \Generator
+    {
+        yield 'datetime' => [new LessThan(new \DateTime('today')), new \DateTime('yesterday')];
+        yield 'int' => [new LessThan(10), 1];
+        yield 'float' => [new LessThan(10.0), 1.0];
+        yield 'int with float' => [new LessThan(10), 1.0];
+        yield 'string' => [new LessThan('z'), 'a'];
+    }
+
+    public static function provideRuleCustomMessageData(): \Generator
+    {
+        yield 'message' => [
+            new LessThan(10, [
+                'message' => 'The "{{ name }}" value "{{ value }}" is not less than "{{ constraint }}".'
+            ]),
+            20,
+            'The "test" value "20" is not less than "10".'
+        ];
+    }
+}
diff --git a/tests/NotBlankTest.php b/tests/NotBlankTest.php
@@ -45,9 +45,11 @@ public static function provideRuleSuccessConditionData(): \Generator
     public static function provideRuleCustomMessageData(): \Generator
     {
         yield 'message' => [
-            new NotBlank(
-                message: 'The "{{ name }}" value "{{ value }}" is not blank.'
-            ), '', 'The "test" value "" is not blank.'
+            new NotBlank([
+                'message' => 'The "{{ name }}" value "{{ value }}" is not blank.'
+            ]),
+            '',
+            'The "test" value "" is not blank.'
         ];
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,9 @@ public function validate(mixed $value): bool;`
`15`	`15`
`16`	`16`	`// --- Rules ---`
`17`	`17`
`18`		`- public function notBlank(string $message = null): ChainedValidatorInterface;`
	`18`	`+ public function notBlank(array $options = []): ChainedValidatorInterface;`
`19`	`19`
`20`		`- public function greaterThan(mixed $constraint, string $message = null): ChainedValidatorInterface;`
	`20`	`+ public function greaterThan(mixed $constraint, array $options = []): ChainedValidatorInterface;`
	`21`	`+`
	`22`	`+ public function lessThan(mixed $constraint, array $options = []): ChainedValidatorInterface;`
`21`	`23`	`}`
-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +<?php
++
 +namespace ProgrammatorDev\YetAnotherPhpValidator\Exception;
++
 +class LessThanException extends ValidationException {}
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,9 @@`
`4`	`4`
`5`	`5`	`interface StaticValidatorInterface`
`6`	`6`	`{`
`7`		`- public static function notBlank(string $message = null): ChainedValidatorInterface;`
	`7`	`+ public static function notBlank(array $options = []): ChainedValidatorInterface;`
`8`	`8`
`9`		`- public static function greaterThan(mixed $constraint, string $message = null): ChainedValidatorInterface;`
	`9`	`+ public static function greaterThan(mixed $constraint, array $options = []): ChainedValidatorInterface;`
	`10`	`+`
	`11`	`+ public static function lessThan(mixed $constraint, array $options = []): ChainedValidatorInterface;`
`10`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -52,10 +52,11 @@ public static function provideRuleSuccessConditionData(): \Generator`
`52`	`52`	`public static function provideRuleCustomMessageData(): \Generator`
`53`	`53`	`{`
`54`	`54`	`yield 'message' => [`
`55`		`- new GreaterThan(`
`56`		`- constraint: 10,`
`57`		`- message: 'The "{{ name }}" value "{{ value }}" is not greater than "{{ constraint }}".'`
`58`		`- ), 1, 'The "test" value "1" is not greater than "10".'`
	`55`	`+ new GreaterThan(10, [`
	`56`	`+ 'message' => 'The "{{ name }}" value "{{ value }}" is not greater than "{{ constraint }}".'`
	`57`	`+ ]),`
	`58`	`+ 1,`
	`59`	`+ 'The "test" value "1" is not greater than "10".'`
`59`	`60`	`];`
`60`	`61`	`}`
`61`	`62`	`}`