Add validation rule for Start with and end with.

Author: webhkp

src/Rules/EndWith.php

@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Webhkp\Pvalidate\Rules;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_PROPERTY)]
+class EndWith extends ValidationRule {
+    public function __construct(
+        readonly private ?string $checkStr = null,
+        readonly private ?bool $ignoreCase = false,
+    ) {
+
+    }
+
+    public function isValid(): bool {
+        if (!$this->checkStr) {
+            return true;
+        }
+
+        if ($this->ignoreCase) {
+            return str_ends_with(strtolower($this->value), strtolower($this->checkStr));
+        }
+
+        return str_ends_with($this->value, $this->checkStr);
+    }
+
+    public function getErrors(): array {
+        $errors = [];
+
+        if (!$this->isValid()) {
+            $errors['endWith'] = "({$this->value}) does not end with ({$this->checkStr})";
+        }
+
+        return $errors;
+    }
+}

src/Rules/StartWith.php

@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Webhkp\Pvalidate\Rules;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_PROPERTY)]
+class StartWith extends ValidationRule {
+    public function __construct(
+        readonly private ?string $checkStr = null,
+        readonly private ?bool $ignoreCase = false,
+    ) {
+
+    }
+
+    public function isValid(): bool {
+        if (!$this->checkStr) {
+            return true;
+        }
+
+        if ($this->ignoreCase) {
+            return str_starts_with(strtolower($this->value), strtolower($this->checkStr));
+        }
+
+        return str_starts_with($this->value, $this->checkStr);
+    }
+
+    public function getErrors(): array {
+        $errors = [];
+
+        if (!$this->isValid()) {
+            $errors['startWith'] = "({$this->value}) does not start with ({$this->checkStr})";
+        }
+
+        return $errors;
+    }
+}

tests/Feature/StartEndWithTest.php

@@ -0,0 +1,95 @@
+<?php
+
+use Webhkp\Pvalidate\Rules\EndWith;
+use Webhkp\Pvalidate\Rules\StartWith;
+use Webhkp\Pvalidate\ValidationBuilder;
+use Webhkp\Pvalidate\Validator;
+
+beforeEach(function () {
+    $this->testObj = new class {
+        public function __construct(
+        ) {
+    
+        }
+    
+        #[StartWith('my')]
+        public string $firstString = 'my first string';    
+        
+        #[StartWith('my')]
+        public string $secondString = 'My second string';    
+        
+        #[StartWith('MY', true)]
+        public string $thirdString = 'My third string';    
+        
+        #[EndWith('string')]
+        public string $fourthString = 'my fourth string';    
+        
+        #[EndWith('STRING')]
+        public string $fifthString = 'My fifth StrinG';    
+        
+        #[EndWith('string', true)]
+        public string $sixthString = 'My sixth String';    
+    
+        #[StartWith('MY')]
+        #[EndWith('string')]
+        public string $seventhString = 'My seventh String';    
+    
+        #[StartWith('MY', true)]
+        #[EndWith('STRING', true)]
+        public string $eighthString = 'My eighth String';    
+    };
+});
+
+describe("Start with Validation", function () {
+    describe("Object attribute validation", function () {
+        it('Should be valid', function () {
+            $this->testObj->firstString = "my test string";
+            $this->testObj->secondString = "my test string";
+            $this->testObj->thirdString = "MY TEST string";
+            $this->testObj->fourthString = "my test string";
+            $this->testObj->fifthString = "my test STRING";
+            $this->testObj->sixthString = "my test STRING";
+            $this->testObj->seventhString = "MY test string";
+            $this->testObj->eighthString = "my test STRING";
+
+            $validationResponse = Validator::validate($this->testObj);
+
+            expect($validationResponse->isValid())->toBeTrue();
+            expect($validationResponse->getErrors())->toBeEmpty();
+        });
+
+        it('Should return errors', function () {
+            $validationResponse = Validator::validate($this->testObj);
+
+            expect($validationResponse->isValid())->toBeFalse();
+            expect($validationResponse->getErrors())->toHaveKeys(['secondString', 'fifthString', 'seventhString']);
+        });
+    });
+
+    describe("Validation builder parsing", function () {
+        it('Should return error for startwith violation', function () {
+            $validation = ValidationBuilder::startWith("wrong wrong")->safeParse('quick brown fox jumps over the lazy dog');
+
+            expect($validation->isValid())->toBeFalse();
+            expect($validation->getErrors())->toHaveKeys(['startWith.errors.startWith']);
+        });
+
+        it('Should return error for endWtith violation', function () {
+            $validation = ValidationBuilder::endWith('wrong')->safeParse('quick brown fox jumps over the lazy dog');
+
+            expect($validation->isValid())->toBeFalse();
+            expect($validation->getErrors())->toHaveKeys(['endWith.errors.endWith']);
+        });
+
+        it('Should return error for both startWith and endWith violation', function () {
+            $validation = ValidationBuilder::startWith("wrong")->endWith('Something else');
+
+            $validationResult = $validation->safeParse('abc');
+
+            expect($validationResult->isValid())->toBeFalse();
+            expect($validationResult->getErrors())->toHaveKeys(['startWith.errors.startWith', 'endWith.errors.endWith']);
+        });
+    });
+});
+
+

tests/Unit/EndWithRuleTest.php

@@ -0,0 +1,43 @@
+<?php
+
+use Webhkp\Pvalidate\Exceptions\PvalidateException;
+use Webhkp\Pvalidate\Rules\EndWith;
+
+beforeEach(function () {
+    $this->rule = new EndWith('dog');
+    $this->ruleInsensitive = new EndWith('dog', true);
+});
+
+describe("End with validation", function () {
+    it('Should be valid', function () {
+        $validationResult = $this->rule->safeParse('quick brown fox jumps over the lazy dog');
+
+        expect($validationResult->isValid())->toBeTrue();
+        expect($validationResult->getErrors())->toBeEmpty();
+    });
+
+    it('Should be valid for case insensitive comparison', function () {
+        $validationResult = $this->ruleInsensitive->safeParse('quick brown fox jumps over the lazy Dog');
+
+        expect($validationResult->isValid())->toBeTrue();
+        expect($validationResult->getErrors())->toBeEmpty();
+    });
+
+    it('Should return \'endWith\' error on safeParse', function () {
+        $validationResult = $this->rule->safeParse('quick brown fox jumps over the lazy dog, blah blah');
+
+        expect($validationResult->isValid())->toBeFalse();
+        expect($validationResult->getErrors())->toHaveKey('endWith');
+    });
+
+    it('Should return \'endWith\' error on safeParse for case insensitve comparison', function () {
+        $validationResult = $this->ruleInsensitive->safeParse('quick brown fox jumps over the lazy dog, , blah blah');
+
+        expect($validationResult->isValid())->toBeFalse();
+        expect($validationResult->getErrors())->toHaveKey('endWith');
+    });
+
+    it('Should throw exception on parse', function () {
+        $this->rule->parse('jumps over');
+    })->throws(PvalidateException::class);
+});

tests/Unit/StartWithRuleTest.php

@@ -0,0 +1,43 @@
+<?php
+
+use Webhkp\Pvalidate\Exceptions\PvalidateException;
+use Webhkp\Pvalidate\Rules\StartWith;
+
+beforeEach(function () {
+    $this->rule = new StartWith('quick');
+    $this->ruleInsensitive = new StartWith('quick', true);
+});
+
+describe("Start with validation", function () {
+    it('Should be valid', function () {
+        $validationResult = $this->rule->safeParse('quick brown fox jumps over the lazy dog');
+
+        expect($validationResult->isValid())->toBeTrue();
+        expect($validationResult->getErrors())->toBeEmpty();
+    });
+
+    it('Should be valid for case insensitive comparison', function () {
+        $validationResult = $this->ruleInsensitive->safeParse('QuiCK brown fox jumps over the lazy dog');
+
+        expect($validationResult->isValid())->toBeTrue();
+        expect($validationResult->getErrors())->toBeEmpty();
+    });
+
+    it('Should return \'startWith\' error on safeParse', function () {
+        $validationResult = $this->rule->safeParse('blah blah, quick brown fox jumps over the lazy dog');
+
+        expect($validationResult->isValid())->toBeFalse();
+        expect($validationResult->getErrors())->toHaveKey('startWith');
+    });
+
+    it('Should return \'startWith\' error on safeParse for case insensitve comparison', function () {
+        $validationResult = $this->ruleInsensitive->safeParse('blah blah, quick brown fox jumps over the lazy dog');
+
+        expect($validationResult->isValid())->toBeFalse();
+        expect($validationResult->getErrors())->toHaveKey('startWith');
+    });
+
+    it('Should throw exception on parse', function () {
+        $this->rule->parse('jumps over the lazy dog');
+    })->throws(PvalidateException::class);
+});