deblan-mirror/respect-validation
deblan-mirror/respect-validation
1
0
Fork 0
mirror of https://github.com/Respect/Validation.git synced 2024-06-07 00:02:33 +02:00
Code Issues Packages Projects Releases Wiki Activity

Method check() should not have a return value

Browse source 
One this method should throw an exception when the input is not valid,
returning `TRUE` when it succeeds is not really consistent.
This commit is contained in:
Henrique Moody 2018-01-28 16:14:00 +01:00
parent ccf60f0ee3
commit 30dc089565
No known key found for this signature in database
GPG key ID: 221E9281655813A6
64 changed files with 115 additions and 114 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
library/Rules/AbstractRelated.php
View file

@ -72,14 +72,14 @@ abstract class AbstractRelated extends AbstractRule
}
}
public function check($input)
public function check($input): void
{
$hasReference = $this->hasReference($input);
if ($this->mandatory && !$hasReference) {
throw $this->reportError($input, ['hasReference' => false]);
}
return $this->decision('check', $hasReference, $input);
$this->decision('check', $hasReference, $input);
}
public function validate($input): bool

4
library/Rules/AbstractRule.php
View file

@ -35,9 +35,9 @@ abstract class AbstractRule implements Validatable
throw $this->reportError($input);
}
public function check($input)
public function check($input): void
{
return $this->assert($input);
$this->assert($input);
}
public function getName()

4
library/Rules/AbstractWrapper.php
View file

@ -48,9 +48,9 @@ abstract class AbstractWrapper extends AbstractRule
/**
* {@inheritdoc}
*/
public function check($input)
public function check($input): void
{
return $this->validatable->check($input);
$this->validatable->check($input);
}
/**

4
library/Rules/AllOf.php
View file

@ -32,13 +32,11 @@ class AllOf extends AbstractComposite
return true;
}
public function check($input)
public function check($input): void
{
foreach ($this->getRules() as $rule) {
$rule->check($input);
}
return true;
}
public function validate($input): bool

10
library/Rules/AnyOf.php
View file

@ -41,13 +41,13 @@ class AnyOf extends AbstractComposite
return false;
}
public function check($input)
public function check($input): void
{
foreach ($this->getRules() as $v) {
try {
if ($v->check($input)) {
return true;
}
$v->check($input);
return;
} catch (ValidationException $e) {
if (!isset($firstException)) {
$firstException = $e;
@ -59,6 +59,6 @@ class AnyOf extends AbstractComposite
throw $firstException;
}
return false;
throw $this->reportError($input);
}
}

4
library/Rules/Domain.php
View file

@ -110,7 +110,7 @@ class Domain extends AbstractComposite
}
}
public function check($input)
public function check($input): void
{
foreach ($this->checks as $chk) {
$chk->check($input);
@ -123,7 +123,5 @@ class Domain extends AbstractComposite
foreach ($parts as $p) {
$this->otherParts->check($p);
}
return true;
}
}

4
library/Rules/Each.php
View file

@ -60,7 +60,7 @@ class Each extends IterableType
return true;
}
public function check($input)
public function check($input): void
{
if (!parent::validate($input)) {
throw $this->reportError($input);
@ -75,8 +75,6 @@ class Each extends IterableType
$this->keyValidator->check($key);
}
}
return true;
}
public function validate($input): bool

4
library/Rules/KeySet.php
View file

@ -130,11 +130,11 @@ class KeySet extends AllOf
/**
* {@inheritdoc}
*/
public function check($input)
public function check($input): void
{
$this->checkKeys($input);
return parent::check($input);
parent::check($input);
}
/**

4
library/Rules/KeyValue.php
View file

@ -79,7 +79,7 @@ class KeyValue extends AbstractRule
return true;
}
public function check($input)
public function check($input): void
{
$rule = $this->getRule($input);
@ -88,8 +88,6 @@ class KeyValue extends AbstractRule
} catch (ValidationException $exception) {
throw $this->overwriteExceptionParams($exception);
}
return true;
}
public function validate($input): bool

4
library/Rules/OneOf.php
View file

@ -48,7 +48,7 @@ class OneOf extends AbstractComposite
return 1 === $rulesPassedCount;
}
public function check($input)
public function check($input): void
{
$exceptions = [];
$rulesPassedCount = 0;
@ -63,7 +63,7 @@ class OneOf extends AbstractComposite
}
if (1 === $rulesPassedCount) {
return true;
return;
}
throw (array_shift($exceptions) ?: $this->reportError($input));

6
library/Rules/Optional.php
View file

@ -29,13 +29,13 @@ class Optional extends AbstractWrapper
return parent::assert($input);
}
public function check($input)
public function check($input): void
{
if ($this->isUndefined($input)) {
return true;
return;
}
return parent::check($input);
parent::check($input);
}
public function validate($input): bool

8
library/Rules/When.php
View file

@ -52,12 +52,14 @@ class When extends AbstractRule
return $this->else->assert($input);
}
public function check($input)
public function check($input): void
{
if ($this->when->validate($input)) {
return $this->then->check($input);
$this->then->check($input);
return;
}
return $this->else->check($input);
$this->else->check($input);
}
}

2
library/Validatable.php
View file

@ -18,7 +18,7 @@ interface Validatable
{
public function assert($input);
public function check($input);
public function check($input): void;
public function getName();

4
library/Validator.php
View file

@ -161,10 +161,10 @@ use Respect\Validation\Rules\Key;
*/
class Validator extends AllOf
{
public function check($input)
public function check($input): void
{
try {
return parent::check($input);
parent::check($input);
} catch (ValidationException $exception) {
if (1 == count($this->getRules()) && $this->template) {
$exception->setTemplate($this->template);

1
tests/unit/Rules/AbstractRelatedTest.php
View file

@ -22,7 +22,6 @@ final class AbstractRelatedTest extends TestCase
{
return [
['validate'],
['check'],
['assert'],
];
}

2
tests/unit/Rules/AbstractWrapperTest.php
View file

@ -91,7 +91,7 @@ final class AbstractWrapperTest extends TestCase
$wrapper = $this->getMockForAbstractClass(AbstractWrapper::class, [$validatable]);
self::assertTrue($wrapper->check($input));
$wrapper->check($input);
}
/**

8
tests/unit/Rules/AllOfTest.php
View file

@ -61,10 +61,10 @@ class AllOfTest extends TestCase
});
$o = new AllOf($valid1, $valid2, $valid3);
self::assertTrue($o->__invoke('any'));
self::assertTrue($o->check('any'));
$o->check('any');
self::assertTrue($o->assert('any'));
self::assertTrue($o->__invoke(''));
self::assertTrue($o->check(''));
$o->check('');
self::assertTrue($o->assert(''));
}
@ -87,7 +87,7 @@ class AllOfTest extends TestCase
{
$o = new AllOf($v1, $v2, $v3);
self::assertFalse($o->__invoke('any'));
self::assertFalse($o->check('any'));
$o->check('any');
}
/**
@ -97,7 +97,7 @@ class AllOfTest extends TestCase
public function testValidationCheckShouldFailOnEmptyInput($v1, $v2, $v3): void
{
$o = new AllOf($v1, $v2, $v3);
self::assertTrue($o->check(''));
$o->check('');
}
/**

2
tests/unit/Rules/AlphaTest.php
View file

@ -29,7 +29,7 @@ class AlphaTest extends TestCase
{
$validator = new Alpha($additional);
self::assertTrue($validator->validate($validAlpha));
self::assertTrue($validator->check($validAlpha));
$validator->check($validAlpha);
self::assertTrue($validator->assert($validAlpha));
}

4
tests/unit/Rules/AnyOfTest.php
View file

@ -36,7 +36,7 @@ class AnyOfTest extends TestCase
$o = new AnyOf($valid1, $valid2, $valid3);
self::assertTrue($o->validate('any'));
self::assertTrue($o->assert('any'));
self::assertTrue($o->check('any'));
$o->check('any');
}
/**
@ -65,6 +65,6 @@ class AnyOfTest extends TestCase
{
$o = new AnyOf(new Xdigit(), new Alnum());
self::assertFalse($o->validate(-10));
self::assertFalse($o->check(-10));
$o->check(-10);
}
}

8
tests/unit/Rules/AttributeTest.php
View file

@ -32,7 +32,7 @@ class AttributeTest extends TestCase
$validator = new Attribute('bar');
$obj = new \stdClass();
$obj->bar = 'foo';
self::assertTrue($validator->check($obj));
$validator->check($obj);
self::assertTrue($validator->__invoke($obj));
self::assertTrue($validator->assert($obj));
}
@ -58,7 +58,7 @@ class AttributeTest extends TestCase
$obj = new \stdClass();
$obj->baraaaaa = 'foo';
self::assertFalse($validator->__invoke($obj));
self::assertFalse($validator->check($obj));
$validator->check($obj);
}
/**
@ -87,7 +87,7 @@ class AttributeTest extends TestCase
$obj->bar = 'foo';
self::assertTrue($validator->__invoke($obj));
self::assertTrue($validator->assert($obj));
self::assertTrue($validator->check($obj));
$validator->check($obj);
}
/**
@ -122,7 +122,7 @@ class AttributeTest extends TestCase
$validator = new Attribute('bar', $subValidator);
$obj = new \stdClass();
$obj->bar = 'foo hey this has more than 3 chars';
self::assertFalse($validator->check($obj));
$validator->check($obj);
}
/**

4
tests/unit/Rules/BaseTest.php
View file

@ -31,7 +31,7 @@ class BaseTest extends TestCase
{
$object = new Base($base);
self::assertTrue($object->__invoke($input));
self::assertTrue($object->check($input));
$object->check($input);
self::assertTrue($object->assert($input));
}
@ -62,7 +62,7 @@ class BaseTest extends TestCase
{
$object = new Base($base, $custom);
self::assertTrue($object->__invoke($input));
self::assertTrue($object->check($input));
$object->check($input);
self::assertTrue($object->assert($input));
}

2
tests/unit/Rules/BetweenTest.php
View file

@ -72,7 +72,7 @@ class BetweenTest extends TestCase
$o = new Between($min, $max, $inclusive);
self::assertTrue($o->__invoke($input));
self::assertTrue($o->assert($input));
self::assertTrue($o->check($input));
$o->check($input);
}
/**

6
tests/unit/Rules/BoolTypeTest.php
View file

@ -29,8 +29,8 @@ class BoolTypeTest extends TestCase
self::assertTrue($validator->__invoke(false));
self::assertTrue($validator->assert(true));
self::assertTrue($validator->assert(false));
self::assertTrue($validator->check(true));
self::assertTrue($validator->check(false));
$validator->check(true);
$validator->check(false);
}
/**
@ -39,7 +39,7 @@ class BoolTypeTest extends TestCase
public function testInvalidBooleanShouldRaiseException(): void
{
$validator = new BoolType();
self::assertFalse($validator->check('foo'));
$validator->check('foo');
}
public function testInvalidBooleanValuesShouldReturnFalse(): void

2
tests/unit/Rules/CnhTest.php
View file

@ -36,7 +36,7 @@ class CnhTest extends TestCase
{
self::assertTrue($this->cnhValidator->assert($cnh));
self::assertTrue($this->cnhValidator->__invoke($cnh));
self::assertTrue($this->cnhValidator->check($cnh));
$this->cnhValidator->check($cnh);
}
/**

4
tests/unit/Rules/DirectoryTest.php
View file

@ -30,7 +30,7 @@ class DirectoryTest extends TestCase
$rule = new Directory();
self::assertTrue($rule->__invoke($input));
self::assertTrue($rule->assert($input));
self::assertTrue($rule->check($input));
$rule->check($input);
}
/**
@ -42,7 +42,7 @@ class DirectoryTest extends TestCase
$rule = new Directory();
self::assertFalse($rule->__invoke($input));
self::assertFalse($rule->assert($input));
self::assertFalse($rule->check($input));
$rule->check($input);
}
/**

4
tests/unit/Rules/DomainTest.php
View file

@ -38,7 +38,7 @@ class DomainTest extends TestCase
$this->object->tldCheck($tldcheck);
self::assertTrue($this->object->__invoke($input));
self::assertTrue($this->object->assert($input));
self::assertTrue($this->object->check($input));
$this->object->check($input);
}
/**
@ -48,7 +48,7 @@ class DomainTest extends TestCase
public function testNotDomain($input, $tldcheck = true): void
{
$this->object->tldCheck($tldcheck);
self::assertFalse($this->object->check($input));
$this->object->check($input);
}
/**

12
tests/unit/Rules/EachTest.php
View file

@ -66,8 +66,8 @@ class EachTest extends RuleTestCase
public function testValidatorShouldPassIfEveryArrayItemPass(): void
{
$v = new Each($this->createValidatableMock(true));
$result = $v->check([1, 2, 3, 4, 5]);
self::assertTrue($result);
$v->check([1, 2, 3, 4, 5]);
$result = $v->assert([1, 2, 3, 4, 5]);
self::assertTrue($result);
}
@ -75,8 +75,8 @@ class EachTest extends RuleTestCase
public function testValidatorShouldPassIfEveryArrayItemAndKeyPass(): void
{
$v = new Each($this->createValidatableMock(true), $this->createValidatableMock(true));
$result = $v->check(['a', 'b', 'c', 'd', 'e']);
self::assertTrue($result);
$v->check(['a', 'b', 'c', 'd', 'e']);
$result = $v->assert(['a', 'b', 'c', 'd', 'e']);
self::assertTrue($result);
}
@ -84,8 +84,8 @@ class EachTest extends RuleTestCase
public function testValidatorShouldPassWithOnlyKeyValidation(): void
{
$v = new Each(null, $this->createValidatableMock(true));
$result = $v->check(['a', 'b', 'c', 'd', 'e']);
self::assertTrue($result);
$v->check(['a', 'b', 'c', 'd', 'e']);
$result = $v->assert(['a', 'b', 'c', 'd', 'e']);
self::assertTrue($result);
}

2
tests/unit/Rules/EmailTest.php
View file

@ -109,7 +109,7 @@ class EmailTest extends TestCase
{
$validator = new Email();
self::assertTrue($validator->__invoke($validEmail));
self::assertTrue($validator->check($validEmail));
$validator->check($validEmail);
self::assertTrue($validator->assert($validEmail));
}

2
tests/unit/Rules/EndsWithTest.php
View file

@ -29,7 +29,7 @@ class EndsWithTest extends TestCase
{
$v = new EndsWith($start);
self::assertTrue($v->__invoke($input));
self::assertTrue($v->check($input));
$v->check($input);
self::assertTrue($v->assert($input));
}

2
tests/unit/Rules/EvenTest.php
View file

@ -35,7 +35,7 @@ class EvenTest extends TestCase
public function testEvenNumbersShouldPass($input): void
{
self::assertTrue($this->evenValidator->validate($input));
self::assertTrue($this->evenValidator->check($input));
$this->evenValidator->check($input);
self::assertTrue($this->evenValidator->assert($input));
}

2
tests/unit/Rules/FactorTest.php
View file

@ -34,7 +34,7 @@ class FactorTest extends TestCase
{
$min = new Factor($dividend);
self::assertTrue($min->__invoke($input));
self::assertTrue($min->check($input));
$min->check($input);
self::assertTrue($min->assert($input));
}

2
tests/unit/Rules/FloatValTest.php
View file

@ -36,7 +36,7 @@ class FloatValTest extends TestCase
{
self::assertTrue($this->floatValidator->assert($input));
self::assertTrue($this->floatValidator->__invoke($input));
self::assertTrue($this->floatValidator->check($input));
$this->floatValidator->check($input);
}
/**

2
tests/unit/Rules/InTest.php
View file

@ -29,7 +29,7 @@ class InTest extends TestCase
{
$v = new In($options);
self::assertTrue($v->__invoke($input));
self::assertTrue($v->check($input));
$v->check($input);
self::assertTrue($v->assert($input));
}

2
tests/unit/Rules/InstanceTest.php
View file

@ -54,7 +54,7 @@ class InstanceTest extends TestCase
{
self::assertTrue($this->instanceValidator->__invoke(new \ArrayObject()));
self::assertTrue($this->instanceValidator->assert(new \ArrayObject()));
self::assertTrue($this->instanceValidator->check(new \ArrayObject()));
$this->instanceValidator->check(new \ArrayObject());
}
/**

2
tests/unit/Rules/IntValTest.php
View file

@ -35,7 +35,7 @@ class IntValTest extends TestCase
public function testValidIntegersShouldReturnTrue($input): void
{
self::assertTrue($this->intValidator->__invoke($input));
self::assertTrue($this->intValidator->check($input));
$this->intValidator->check($input);
self::assertTrue($this->intValidator->assert($input));
}

4
tests/unit/Rules/IpTest.php
View file

@ -30,7 +30,7 @@ class IpTest extends TestCase
$ipValidator = new Ip($options);
self::assertTrue($ipValidator->__invoke($input));
self::assertTrue($ipValidator->assert($input));
self::assertTrue($ipValidator->check($input));
$ipValidator->check($input);
}
/**
@ -41,7 +41,7 @@ class IpTest extends TestCase
$ipValidator = new Ip($networkRange);
self::assertTrue($ipValidator->__invoke($input));
self::assertTrue($ipValidator->assert($input));
self::assertTrue($ipValidator->check($input));
$ipValidator->check($input);
}
/**

10
tests/unit/Rules/KeyNestedTest.php
View file

@ -15,6 +15,7 @@ namespace Respect\Validation\Rules;
use ArrayObject;
use PHPUnit\Framework\TestCase;
use Respect\Validation\Validatable;
/**
* @group rule
@ -47,9 +48,14 @@ class KeyNestedTest extends TestCase
0 => 'Zero, the hero!',
];
$rule = new KeyNested(0, new Equals('Zero, the hero!'));
$validatable = $this->createMock(Validatable::class);
$validatable
->expects($this->once())
->method('check')
->with($array[0]);
self::assertTrue($rule->check($array));
$rule = new KeyNested(0, $validatable);
$rule->check($array);
}
public function testArrayWithPresentKeysWillReturnTrueForHalfPathValidator(): void

6
tests/unit/Rules/KeyValueTest.php
View file

@ -97,11 +97,13 @@ class KeyValueTest extends TestCase
$rule->assert(['foo' => 43, 'bar' => 42]);
}
/**
* @doesNotPerformAssertions
*/
public function testShouldCheckWhenDefinedValuesMatch(): void
{
$rule = new KeyValue('foo', 'equals', 'bar');
self::assertTrue($rule->check(['foo' => 42, 'bar' => 42]));
$rule->check(['foo' => 42, 'bar' => 42]);
}
/**

2
tests/unit/Rules/LowercaseTest.php
View file

@ -30,7 +30,7 @@ class LowercaseTest extends TestCase
$lowercase = new Lowercase();
self::assertTrue($lowercase->__invoke($input));
self::assertTrue($lowercase->assert($input));
self::assertTrue($lowercase->check($input));
$lowercase->check($input);
}
/**

2
tests/unit/Rules/MacAddressTest.php
View file

@ -36,7 +36,7 @@ class MacAddressTest extends TestCase
{
self::assertTrue($this->macaddressValidator->__invoke($input));
self::assertTrue($this->macaddressValidator->assert($input));
self::assertTrue($this->macaddressValidator->check($input));
$this->macaddressValidator->check($input);
}
/**

2
tests/unit/Rules/MaxTest.php
View file

@ -29,7 +29,7 @@ class MaxTest extends TestCase
{
$max = new Max($maxValue, $inclusive);
self::assertTrue($max->validate($input));
self::assertTrue($max->check($input));
$max->check($input);
self::assertTrue($max->assert($input));
}

2
tests/unit/Rules/MinTest.php
View file

@ -30,7 +30,7 @@ class MinTest extends TestCase
{
$min = new Min($minValue, $inclusive);
self::assertTrue($min->__invoke($input));
self::assertTrue($min->check($input));
$min->check($input);
self::assertTrue($min->assert($input));
}

2
tests/unit/Rules/MininumAgeTest.php
View file

@ -30,7 +30,7 @@ class MininumAgeTest extends TestCase
$minimumAge = new MinimumAge($age, $format);
self::assertTrue($minimumAge->__invoke($input));
self::assertTrue($minimumAge->assert($input));
self::assertTrue($minimumAge->check($input));
$minimumAge->check($input);
}
/**

2
tests/unit/Rules/MultipleTest.php
View file

@ -30,7 +30,7 @@ class MultipleTest extends TestCase
$multiple = new Multiple($multipleOf);
self::assertTrue($multiple->validate($input));
self::assertTrue($multiple->assert($input));
self::assertTrue($multiple->check($input));
$multiple->check($input);
}
/**

2
tests/unit/Rules/NegativeTest.php
View file

@ -36,7 +36,7 @@ class NegativeTest extends TestCase
{
self::assertTrue($this->negativeValidator->assert($input));
self::assertTrue($this->negativeValidator->__invoke($input));
self::assertTrue($this->negativeValidator->check($input));
$this->negativeValidator->check($input);
}
/**

2
tests/unit/Rules/NfeAccessKeyTest.php
View file

@ -36,7 +36,7 @@ class NfeAccessKeyTest extends TestCase
{
self::assertTrue($this->nfeValidator->assert($aK));
self::assertTrue($this->nfeValidator->__invoke($aK));
self::assertTrue($this->nfeValidator->check($aK));
$this->nfeValidator->check($aK);
}
/**

2
tests/unit/Rules/NoWhitespaceTest.php
View file

@ -35,7 +35,7 @@ class NoWhitespaceTest extends TestCase
public function testStringWithNoWhitespaceShouldPass($input): void
{
self::assertTrue($this->noWhitespaceValidator->__invoke($input));
self::assertTrue($this->noWhitespaceValidator->check($input));
$this->noWhitespaceValidator->check($input);
self::assertTrue($this->noWhitespaceValidator->assert($input));
}

2
tests/unit/Rules/NoneOfTest.php
View file

@ -36,7 +36,7 @@ class NoneOfTest extends TestCase
$o = new NoneOf($valid1, $valid2, $valid3);
self::assertTrue($o->validate('any'));
self::assertTrue($o->assert('any'));
self::assertTrue($o->check('any'));
$o->check('any');
}
/**

2
tests/unit/Rules/NullTypeTest.php
View file

@ -33,7 +33,7 @@ class NullTypeTest extends TestCase
{
self::assertTrue($this->object->assert(null));
self::assertTrue($this->object->__invoke(null));
self::assertTrue($this->object->check(null));
$this->object->check(null);
}
/**

2
tests/unit/Rules/NumericValTest.php
View file

@ -35,7 +35,7 @@ class NumericValTest extends TestCase
public function testNumeric($input): void
{
self::assertTrue($this->object->__invoke($input));
self::assertTrue($this->object->check($input));
$this->object->check($input);
self::assertTrue($this->object->assert($input));
}

2
tests/unit/Rules/ObjectTypeTest.php
View file

@ -36,7 +36,7 @@ class ObjectTypeTest extends TestCase
{
self::assertTrue($this->object->__invoke($input));
self::assertTrue($this->object->assert($input));
self::assertTrue($this->object->check($input));
$this->object->check($input);
}
/**

2
tests/unit/Rules/OddTest.php
View file

@ -36,7 +36,7 @@ class OddTest extends TestCase
{
self::assertTrue($this->object->assert($input));
self::assertTrue($this->object->__invoke($input));
self::assertTrue($this->object->check($input));
$this->object->check($input);
}
/**

4
tests/unit/Rules/OneOfTest.php
View file

@ -38,7 +38,7 @@ class OneOfTest extends TestCase
self::assertTrue($rule->validate('any'));
self::assertTrue($rule->assert('any'));
self::assertTrue($rule->check('any'));
$rule->check('any');
}
/**
@ -49,7 +49,7 @@ class OneOfTest extends TestCase
$rule = new OneOf();
self::assertFalse($rule->validate('any'));
self::assertFalse($rule->check('any'));
$rule->check('any');
}
/**

4
tests/unit/Rules/OptionalTest.php
View file

@ -121,7 +121,7 @@ class OptionalTest extends TestCase
$rule = new Optional($validatable);
self::assertTrue($rule->check(''));
$rule->check('');
}
public function testShouldCheckRuleWhenInputIsNotOptional(): void
@ -137,6 +137,6 @@ class OptionalTest extends TestCase
$rule = new Optional($validatable);
self::assertTrue($rule->check($input));
$rule->check($input);
}
}

2
tests/unit/Rules/PerfectSquareTest.php
View file

@ -35,7 +35,7 @@ class PerfectSquareTest extends TestCase
public function testPerfectSquare($input): void
{
self::assertTrue($this->object->__invoke($input));
self::assertTrue($this->object->check($input));
$this->object->check($input);
self::assertTrue($this->object->assert($input));
}

2
tests/unit/Rules/PhoneTest.php
View file

@ -36,7 +36,7 @@ class PhoneTest extends TestCase
{
self::assertTrue($this->phoneValidator->__invoke($input));
self::assertTrue($this->phoneValidator->assert($input));
self::assertTrue($this->phoneValidator->check($input));
$this->phoneValidator->check($input);
}
/**

2
tests/unit/Rules/PositiveTest.php
View file

@ -35,7 +35,7 @@ class PositiveTest extends TestCase
public function testPositive($input): void
{
self::assertTrue($this->object->__invoke($input));
self::assertTrue($this->object->check($input));
$this->object->check($input);
self::assertTrue($this->object->assert($input));
}

2
tests/unit/Rules/PrimeNumberTest.php
View file

@ -35,7 +35,7 @@ class PrimeNumberTest extends TestCase
public function testPrimeNumber($input): void
{
self::assertTrue($this->object->__invoke($input));
self::assertTrue($this->object->check($input));
$this->object->check($input);
self::assertTrue($this->object->assert($input));
}

2
tests/unit/Rules/RomanTest.php
View file

@ -36,7 +36,7 @@ class RomanTest extends TestCase
{
self::assertTrue($this->romanValidator->__invoke($input));
self::assertTrue($this->romanValidator->assert($input));
self::assertTrue($this->romanValidator->check($input));
$this->romanValidator->check($input);
}
/**

14
tests/unit/Rules/SortedTest.php
View file

@ -29,7 +29,7 @@ class SortedTest extends TestCase
self::assertTrue($rule->validate($arr));
self::assertTrue($rule->assert($arr));
self::assertTrue($rule->check($arr));
$rule->check($arr);
}
public function testPassesWithEqualValues(): void
@ -39,7 +39,7 @@ class SortedTest extends TestCase
self::assertTrue($rule->validate($arr));
self::assertTrue($rule->assert($arr));
self::assertTrue($rule->check($arr));
$rule->check($arr);
}
/**
@ -51,7 +51,7 @@ class SortedTest extends TestCase
$rule = new Sorted();
self::assertFalse($rule->validate($arr));
self::assertFalse($rule->check($arr));
$rule->check($arr);
}
public function testPassesDescending(): void
@ -61,7 +61,7 @@ class SortedTest extends TestCase
self::assertTrue($rule->validate($arr));
self::assertTrue($rule->assert($arr));
self::assertTrue($rule->check($arr));
$rule->check($arr);
}
public function testPassesDescendingWithEqualValues(): void
@ -71,7 +71,7 @@ class SortedTest extends TestCase
self::assertTrue($rule->validate($arr));
self::assertTrue($rule->assert($arr));
self::assertTrue($rule->check($arr));
$rule->check($arr);
}
public function testPassesByFunction(): void
@ -93,7 +93,7 @@ class SortedTest extends TestCase
self::assertTrue($rule->validate($arr));
self::assertTrue($rule->assert($arr));
self::assertTrue($rule->check($arr));
$rule->check($arr);
}
/**
@ -117,6 +117,6 @@ class SortedTest extends TestCase
});
self::assertFalse($rule->validate($arr));
self::assertFalse($rule->check($arr));
$rule->check($arr);
}
}

2
tests/unit/Rules/StartsWithTest.php
View file

@ -29,7 +29,7 @@ class StartsWithTest extends TestCase
{
$v = new StartsWith($start);
self::assertTrue($v->__invoke($input));
self::assertTrue($v->check($input));
$v->check($input);
self::assertTrue($v->assert($input));
}

2
tests/unit/Rules/UppercaseTest.php
View file

@ -30,7 +30,7 @@ class UppercaseTest extends TestCase
$uppercase = new Uppercase();
self::assertTrue($uppercase->validate($input));
self::assertTrue($uppercase->assert($input));
self::assertTrue($uppercase->check($input));
$uppercase->check($input);
}
/**

2
tests/unit/Rules/VersionTest.php
View file

@ -30,7 +30,7 @@ class VersionTest extends TestCase
$rule = new Version();
self::assertTrue($rule->__invoke($input));
self::assertTrue($rule->assert($input));
self::assertTrue($rule->check($input));
$rule->check($input);
}
/**

2
tests/unit/Rules/XdigitTest.php
View file

@ -35,7 +35,7 @@ class XdigitTest extends TestCase
public function testValidateValidHexasdecimalDigits($input): void
{
self::assertTrue($this->xdigitsValidator->assert($input));
self::assertTrue($this->xdigitsValidator->check($input));
$this->xdigitsValidator->check($input);
self::assertTrue($this->xdigitsValidator->validate($input));
}