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 assert() 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 17:16:53 +01:00
parent 30dc089565
commit c80524b457
No known key found for this signature in database
GPG key ID: 221E9281655813A6
87 changed files with 286 additions and 216 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
library/Rules/AbstractRelated.php
View file

@ -56,7 +56,7 @@ abstract class AbstractRelated extends AbstractRule
|| $this->validator->$type($this->getReferenceValue($input)));
}
public function assert($input)
public function assert($input): void
{
$hasReference = $this->hasReference($input);
if ($this->mandatory && !$hasReference) {
@ -64,7 +64,7 @@ abstract class AbstractRelated extends AbstractRule
}
try {
return $this->decision('assert', $hasReference, $input);
$this->decision('assert', $hasReference, $input);
} catch (ValidationException $e) {
throw $this
->reportError($this->reference, ['hasReference' => true])

4
library/Rules/AbstractRule.php
View file

@ -26,10 +26,10 @@ abstract class AbstractRule implements Validatable
return $this->validate($input);
}
public function assert($input)
public function assert($input): void
{
if ($this->validate($input)) {
return true;
return;
}
throw $this->reportError($input);

4
library/Rules/AbstractWrapper.php
View file

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

4
library/Rules/AllOf.php
View file

@ -15,7 +15,7 @@ namespace Respect\Validation\Rules;
class AllOf extends AbstractComposite
{
public function assert($input)
public function assert($input): void
{
$exceptions = $this->validateRules($input);
$numRules = count($this->rules);
@ -28,8 +28,6 @@ class AllOf extends AbstractComposite
if (!empty($exceptions)) {
throw $this->reportError($input, $summary)->setRelated($exceptions);
}
return true;
}
public function check($input): void

4
library/Rules/AnyOf.php
View file

@ -17,7 +17,7 @@ use Respect\Validation\Exceptions\ValidationException;
class AnyOf extends AbstractComposite
{
public function assert($input)
public function assert($input): void
{
$validators = $this->getRules();
$exceptions = $this->validateRules($input);
@ -26,8 +26,6 @@ class AnyOf extends AbstractComposite
if ($numExceptions === $numRules) {
throw $this->reportError($input)->setRelated($exceptions);
}
return true;
}
public function validate($input): bool

4
library/Rules/Domain.php
View file

@ -79,7 +79,7 @@ class Domain extends AbstractComposite
return true;
}
public function assert($input)
public function assert($input): void
{
$e = [];
foreach ($this->checks as $chk) {
@ -97,8 +97,6 @@ class Domain extends AbstractComposite
if (count($e)) {
throw $this->reportError($input)->setRelated($e);
}
return true;
}
protected function collectAssertException(&$exceptions, $validator, $input): void

4
library/Rules/Each.php
View file

@ -27,7 +27,7 @@ class Each extends IterableType
$this->keyValidator = $keyValidator;
}
public function assert($input)
public function assert($input): void
{
$exceptions = [];
@ -56,8 +56,6 @@ class Each extends IterableType
if (!empty($exceptions)) {
throw $this->reportError($input)->setRelated($exceptions);
}
return true;
}
public function check($input): void

4
library/Rules/KeySet.php
View file

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

4
library/Rules/KeyValue.php
View file

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

4
library/Rules/NoneOf.php
View file

@ -15,7 +15,7 @@ namespace Respect\Validation\Rules;
class NoneOf extends AbstractComposite
{
public function assert($input)
public function assert($input): void
{
$exceptions = $this->validateRules($input);
$numRules = count($this->getRules());
@ -23,8 +23,6 @@ class NoneOf extends AbstractComposite
if ($numRules !== $numExceptions) {
throw $this->reportError($input)->setRelated($exceptions);
}
return true;
}
public function validate($input): bool

4
library/Rules/Not.php
View file

@ -37,10 +37,10 @@ class Not extends AbstractRule
return false === $this->rule->validate($input);
}
public function assert($input)
public function assert($input): void
{
if ($this->validate($input)) {
return true;
return;
}
$rule = $this->rule;

4
library/Rules/OneOf.php
View file

@ -21,7 +21,7 @@ use Respect\Validation\Exceptions\ValidationException;
*/
class OneOf extends AbstractComposite
{
public function assert($input)
public function assert($input): void
{
$validators = $this->getRules();
$exceptions = $this->validateRules($input);
@ -30,8 +30,6 @@ class OneOf extends AbstractComposite
if ($numExceptions !== $numRules - 1) {
throw $this->reportError($input)->setRelated($exceptions);
}
return true;
}
public function validate($input): bool

6
library/Rules/Optional.php
View file

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

4
library/Rules/Sf.php
View file

@ -55,11 +55,11 @@ class Sf extends AbstractRule
return $validator->validate($valueToValidate, $symfonyConstraint);
}
public function assert($input)
public function assert($input): void
{
$violations = $this->returnViolationsForConstraint($input, $this->constraint);
if (0 == count($violations)) {
return true;
return;
}
throw $this->reportError((string) $violations);

8
library/Rules/When.php
View file

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

4
library/Rules/Zend.php
View file

@ -46,12 +46,12 @@ class Zend extends AbstractRule
}
}
public function assert($input)
public function assert($input): void
{
$validator = clone $this->zendValidator;
if ($validator->isValid($input)) {
return true;
return;
}
$exceptions = [];

2
library/Validatable.php
View file

@ -16,7 +16,7 @@ namespace Respect\Validation;
/** Interface for validation rules */
interface Validatable
{
public function assert($input);
public function assert($input): void;
public function check($input): void;

4
tests/integration/rules/ip_1.phpt
View file

@ -9,7 +9,7 @@ $ip = new Ip();
var_dump(
$ip->validate('10.0.0.1'),
$ip->validate('192.168.1.150'),
$ip->assert('127.0.0.1'),
$ip->validate('127.0.0.1'),
$ip->validate('10,0.0.1'),
$ip->validate(null)
);
@ -20,4 +20,4 @@ bool(true)
bool(true)
bool(true)
bool(false)
bool(false)
bool(false)

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

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

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

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

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

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

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

@ -39,7 +39,7 @@ class AlnumTest extends TestCase
{
$validator = new Alnum($additional);
self::assertFalse($validator->validate($invalidAlnum));
self::assertFalse($validator->assert($invalidAlnum));
$validator->assert($invalidAlnum);
}
/**

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

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

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

@ -35,7 +35,7 @@ class AnyOfTest extends TestCase
});
$o = new AnyOf($valid1, $valid2, $valid3);
self::assertTrue($o->validate('any'));
self::assertTrue($o->assert('any'));
$o->assert('any');
$o->check('any');
}
@ -55,7 +55,7 @@ class AnyOfTest extends TestCase
});
$o = new AnyOf($valid1, $valid2, $valid3);
self::assertFalse($o->validate('any'));
self::assertFalse($o->assert('any'));
$o->assert('any');
}
/**

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

@ -14,10 +14,13 @@ declare(strict_types=1);
namespace Respect\Validation\Rules;
use PHPUnit\Framework\TestCase;
use Respect\Validation\Validatable;
class PrivClass
{
private $bar = 'foo';
public const PROPERTY_VALUE = 'foo';
private $bar = self::PROPERTY_VALUE;
}
/**
@ -34,7 +37,7 @@ class AttributeTest extends TestCase
$obj->bar = 'foo';
$validator->check($obj);
self::assertTrue($validator->__invoke($obj));
self::assertTrue($validator->assert($obj));
$validator->assert($obj);
}
/**
@ -46,7 +49,7 @@ class AttributeTest extends TestCase
$obj = new \stdClass();
$obj->baraaaaa = 'foo';
self::assertFalse($validator->__invoke($obj));
self::assertFalse($validator->assert($obj));
$validator->assert($obj);
}
/**
@ -86,7 +89,7 @@ class AttributeTest extends TestCase
$obj = new \stdClass();
$obj->bar = 'foo';
self::assertTrue($validator->__invoke($obj));
self::assertTrue($validator->assert($obj));
$validator->assert($obj);
$validator->check($obj);
}
@ -134,7 +137,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->assert($obj));
$validator->assert($obj);
}
public function testNotMandatoryAttributeShouldNotFailWhenAttributeIsAbsent(): void
@ -154,10 +157,17 @@ class AttributeTest extends TestCase
public function testPrivateAttributeShouldAlsoBeChecked(): void
{
$subValidator = new Length(1, 3);
$validator = new Attribute('bar', $subValidator);
$obj = new PrivClass();
self::assertTrue($validator->assert($obj));
$validatable = $this->createMock(Validatable::class);
$validatable
->expects($this->once())
->method('assert')
->with(PrivClass::PROPERTY_VALUE);
$validator = new Attribute('bar', $validatable);
$validator->assert($obj);
}
public function testPrivateAttributeShouldFailIfNotValid(): void

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

@ -32,7 +32,7 @@ class BaseTest extends TestCase
$object = new Base($base);
self::assertTrue($object->__invoke($input));
$object->check($input);
self::assertTrue($object->assert($input));
$object->assert($input);
}
/**
@ -52,7 +52,7 @@ class BaseTest extends TestCase
{
$object = new Base($base);
self::assertTrue($object->__invoke($input));
self::assertTrue($object->assert($input));
$object->assert($input);
}
/**
@ -63,7 +63,7 @@ class BaseTest extends TestCase
$object = new Base($base, $custom);
self::assertTrue($object->__invoke($input));
$object->check($input);
self::assertTrue($object->assert($input));
$object->assert($input);
}
public function providerForBase()

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

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

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

@ -27,8 +27,8 @@ class BoolTypeTest extends TestCase
$validator = new BoolType();
self::assertTrue($validator->__invoke(true));
self::assertTrue($validator->__invoke(false));
self::assertTrue($validator->assert(true));
self::assertTrue($validator->assert(false));
$validator->assert(true);
$validator->assert(false);
$validator->check(true);
$validator->check(false);
}

56
tests/unit/Rules/CallTest.php
View file

@ -14,6 +14,7 @@ declare(strict_types=1);
namespace Respect\Validation\Rules;
use PHPUnit\Framework\TestCase;
use Respect\Validation\Validatable;
/**
* @group rule
@ -22,35 +23,66 @@ use PHPUnit\Framework\TestCase;
*/
class CallTest extends TestCase
{
private const CALLBACK_RETURN = [];
public function thisIsASampleCallbackUsedInsideThisTest()
{
return [];
return self::CALLBACK_RETURN;
}
public function testCallbackValidatorShouldAcceptEmptyString(): void
{
$v = new Call('str_split', new ArrayVal());
self::assertTrue($v->assert(''));
$validatable = $this->createMock(Validatable::class);
$validatable
->expects($this->once())
->method('assert')
->with(['']);
$v = new Call('str_split', $validatable);
$v->assert('');
}
public function testCallbackValidatorShouldAcceptStringWithFunctionName(): void
{
$v = new Call('str_split', new ArrayVal());
self::assertTrue($v->assert('test'));
$validatable = $this->createMock(Validatable::class);
$validatable
->expects($this->once())
->method('assert')
->with(['t', 'e', 's', 't']);
$v = new Call('str_split', $validatable);
$v->assert('test');
}
public function testCallbackValidatorShouldAcceptArrayCallbackDefinition(): void
{
$v = new Call([$this, 'thisIsASampleCallbackUsedInsideThisTest'], new ArrayVal());
self::assertTrue($v->assert('test'));
$validatable = $this->createMock(Validatable::class);
$validatable
->expects($this->once())
->method('assert')
->with(self::CALLBACK_RETURN);
$v = new Call([$this, 'thisIsASampleCallbackUsedInsideThisTest'], $validatable);
$v->assert('test');
}
public function testCallbackValidatorShouldAcceptClosures(): void
{
$v = new Call(function () {
return [];
}, new ArrayVal());
self::assertTrue($v->assert('test'));
$return = [];
$validatable = $this->createMock(Validatable::class);
$validatable
->expects($this->once())
->method('assert')
->with($return);
$v = new Call(
function () use ($return) {
return $return;
},
$validatable
);
$v->assert('test');
}
/**
@ -60,6 +92,6 @@ class CallTest extends TestCase
{
$v = new Call('strrev', new ArrayVal());
self::assertFalse($v->validate('test'));
self::assertFalse($v->assert('test'));
$v->assert('test');
}
}

17
tests/unit/Rules/CallbackTest.php
View file

@ -55,9 +55,12 @@ class CallbackTest extends TestCase
$this->falsy->assert('');
}
/**
* @doesNotPerformAssertions
*/
public function testCallbackValidatorShouldReturnTrueIfCallbackReturnsTrue(): void
{
self::assertTrue($this->truthy->assert('wpoiur'));
$this->truthy->assert('wpoiur');
}
/**
@ -68,16 +71,22 @@ class CallbackTest extends TestCase
self::assertTrue($this->falsy->assert('w poiur'));
}
/**
* @doesNotPerformAssertions
*/
public function testCallbackValidatorShouldAcceptArrayCallbackDefinitions(): void
{
$v = new Callback([$this, 'thisIsASampleCallbackUsedInsideThisTest']);
self::assertTrue($v->assert('test'));
$v->assert('test');
}
/**
* @doesNotPerformAssertions
*/
public function testCallbackValidatorShouldAcceptFunctionNamesAsString(): void
{
$v = new Callback('is_string');
self::assertTrue($v->assert('test'));
$v->assert('test');
}
/**
@ -86,6 +95,6 @@ class CallbackTest extends TestCase
public function testInvalidCallbacksShouldRaiseComponentExceptionUponInstantiation(): void
{
$v = new Callback(new \stdClass());
self::assertTrue($v->assert('w poiur'));
$v->assert('w poiur');
}
}

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

@ -39,7 +39,7 @@ class CharsetTest extends TestCase
{
$validator = new Charset($charset);
self::assertFalse($validator->__invoke($input));
self::assertFalse($validator->assert($input));
$validator->assert($input);
}
/**

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

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

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

@ -39,7 +39,7 @@ class CntrlTest extends TestCase
{
$validator = new Cntrl($additional);
self::assertFalse($validator->validate($invalidCntrl));
self::assertFalse($validator->assert($invalidCntrl));
$validator->assert($invalidCntrl);
}
/**

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

@ -39,7 +39,7 @@ class ConsonantTest extends TestCase
{
$validator = new Consonant($additional);
self::assertFalse($validator->validate($invalidConsonants));
self::assertFalse($validator->assert($invalidConsonants));
$validator->assert($invalidConsonants);
}
/**

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

@ -30,19 +30,23 @@ class CpfTest extends TestCase
}
/**
* @doesNotPerformAssertions
*
* @dataProvider providerValidFormattedCpf
*/
public function testFormattedCpfsShouldValidate($input): void
{
self::assertTrue($this->cpfValidator->assert($input));
$this->cpfValidator->assert($input);
}
/**
* @doesNotPerformAssertions
*
* @dataProvider providerValidUnformattedCpf
*/
public function testUnformattedCpfsShouldValidates($input): void
{
self::assertTrue($this->cpfValidator->assert($input));
$this->cpfValidator->assert($input);
}
/**
@ -51,7 +55,7 @@ class CpfTest extends TestCase
*/
public function testInvalidCpfShouldFailWhenFormatted($input): void
{
self::assertFalse($this->cpfValidator->assert($input));
$this->cpfValidator->assert($input);
}
/**
@ -60,7 +64,7 @@ class CpfTest extends TestCase
*/
public function testInvalidCpfShouldFailWhenNotFormatted($input): void
{
self::assertFalse($this->cpfValidator->assert($input));
$this->cpfValidator->assert($input);
}
/**
@ -69,7 +73,7 @@ class CpfTest extends TestCase
*/
public function testCpfsWithIncorrectLengthShouldFail($input): void
{
self::assertFalse($this->cpfValidator->assert($input));
$this->cpfValidator->assert($input);
}
public function providerValidFormattedCpf()

26
tests/unit/Rules/DateTimeTest.php
View file

@ -44,6 +44,8 @@ class DateTimeTest extends TestCase
}
/**
* @doesNotPerformAssertions
*
* @expectedException \Respect\Validation\Exceptions\DateTimeException
*/
public function testDateEmptyShouldNotAssert(): void
@ -86,16 +88,22 @@ class DateTimeTest extends TestCase
self::assertFalse($this->dateValidator->__invoke(new \stdClass()));
}
/**
* @doesNotPerformAssertions
*/
public function testFormatsShouldValidateDateStrings(): void
{
$this->dateValidator = new DateTime('Y-m-d');
self::assertTrue($this->dateValidator->assert('2009-09-09'));
$this->dateValidator->assert('2009-09-09');
}
/**
* @doesNotPerformAssertions
*/
public function testFormatsShouldValidateDateStrings_with_any_formats(): void
{
$this->dateValidator = new DateTime('d/m/Y');
self::assertTrue($this->dateValidator->assert('23/05/1987'));
$this->dateValidator->assert('23/05/1987');
}
/**
@ -104,30 +112,36 @@ class DateTimeTest extends TestCase
public function testFormatsShouldValidateDateStrings_and_throw_DateTimeException_on_failure(): void
{
$this->dateValidator = new DateTime('y-m-d');
self::assertFalse($this->dateValidator->assert('2009-09-09'));
$this->dateValidator->assert('2009-09-09');
}
/**
* @doesNotPerformAssertions
*/
public function testDateTimeExceptionalFormatsThatShouldBeValid(): void
{
$this->dateValidator = new DateTime('c');
self::assertTrue($this->dateValidator->assert('2004-02-12T15:19:21+00:00'));
$this->dateValidator->assert('2004-02-12T15:19:21+00:00');
$this->dateValidator = new DateTime('r');
self::assertTrue($this->dateValidator->assert('Thu, 29 Dec 2005 01:02:03 +0000'));
$this->dateValidator->assert('Thu, 29 Dec 2005 01:02:03 +0000');
}
/**
* Test that datetime strings with timezone information are valid independent on the system's timezone setting.
*
* @doesNotPerformAssertions
*
* @param string $systemTimezone
* @param string $input
*
* @dataProvider providerForDateTimeTimezoneStrings
*/
public function testDateTimeSystemTimezoneIndependent($systemTimezone, $format, $input): void
{
date_default_timezone_set($systemTimezone);
$this->dateValidator = new DateTime($format);
self::assertTrue($this->dateValidator->assert($input));
$this->dateValidator->assert($input);
}
/**

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

@ -39,7 +39,7 @@ class DigitTest extends TestCase
{
$validator = new Digit($additional);
self::assertFalse($validator->validate($invalidDigits));
self::assertFalse($validator->assert($invalidDigits));
$validator->assert($invalidDigits);
}
/**

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

@ -29,7 +29,7 @@ class DirectoryTest extends TestCase
{
$rule = new Directory();
self::assertTrue($rule->__invoke($input));
self::assertTrue($rule->assert($input));
$rule->assert($input);
$rule->check($input);
}
@ -41,7 +41,7 @@ class DirectoryTest extends TestCase
{
$rule = new Directory();
self::assertFalse($rule->__invoke($input));
self::assertFalse($rule->assert($input));
$rule->assert($input);
$rule->check($input);
}

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

@ -37,7 +37,7 @@ class DomainTest extends TestCase
{
$this->object->tldCheck($tldcheck);
self::assertTrue($this->object->__invoke($input));
self::assertTrue($this->object->assert($input));
$this->object->assert($input);
$this->object->check($input);
}
@ -58,7 +58,7 @@ class DomainTest extends TestCase
public function testNotDomainCheck($input, $tldcheck = true): void
{
$this->object->tldCheck($tldcheck);
self::assertFalse($this->object->assert($input));
$this->object->assert($input);
}
public function providerForDomain()

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

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

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

@ -110,7 +110,7 @@ class EmailTest extends TestCase
$validator = new Email();
self::assertTrue($validator->__invoke($validEmail));
$validator->check($validEmail);
self::assertTrue($validator->assert($validEmail));
$validator->assert($validEmail);
}
/**
@ -121,7 +121,7 @@ class EmailTest extends TestCase
{
$validator = new Email();
self::assertFalse($validator->__invoke($invalidEmail));
self::assertFalse($validator->assert($invalidEmail));
$validator->assert($invalidEmail);
}
public function providerForValidEmail()

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

@ -30,7 +30,7 @@ class EndsWithTest extends TestCase
$v = new EndsWith($start);
self::assertTrue($v->__invoke($input));
$v->check($input);
self::assertTrue($v->assert($input));
$v->assert($input);
}
/**
@ -41,7 +41,7 @@ class EndsWithTest extends TestCase
{
$v = new EndsWith($start, $caseSensitive);
self::assertFalse($v->__invoke($input));
self::assertFalse($v->assert($input));
$v->assert($input);
}
public function providerForEndsWith()

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

@ -36,7 +36,7 @@ class EvenTest extends TestCase
{
self::assertTrue($this->evenValidator->validate($input));
$this->evenValidator->check($input);
self::assertTrue($this->evenValidator->assert($input));
$this->evenValidator->assert($input);
}
/**
@ -46,7 +46,7 @@ class EvenTest extends TestCase
public function testNotEvenNumbersShouldFail($input): void
{
self::assertFalse($this->evenValidator->validate($input));
self::assertFalse($this->evenValidator->assert($input));
$this->evenValidator->assert($input);
}
public function providerForEven()

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

@ -35,7 +35,7 @@ class FactorTest extends TestCase
$min = new Factor($dividend);
self::assertTrue($min->__invoke($input));
$min->check($input);
self::assertTrue($min->assert($input));
$min->assert($input);
}
/**
@ -50,7 +50,7 @@ class FactorTest extends TestCase
$min = new Factor($dividend);
self::assertFalse($min->__invoke($input));
self::assertFalse($min->assert($input));
$min->assert($input);
}
/**

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

@ -34,7 +34,7 @@ class FloatValTest extends TestCase
*/
public function testFloatNumbersShouldPass($input): void
{
self::assertTrue($this->floatValidator->assert($input));
$this->floatValidator->assert($input);
self::assertTrue($this->floatValidator->__invoke($input));
$this->floatValidator->check($input);
}
@ -46,7 +46,7 @@ class FloatValTest extends TestCase
public function testNotFloatNumbersShouldFail($input): void
{
self::assertFalse($this->floatValidator->__invoke($input));
self::assertFalse($this->floatValidator->assert($input));
$this->floatValidator->assert($input);
}
public function providerForFloat()

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

@ -39,7 +39,7 @@ class GraphTest extends TestCase
{
$validator = new Graph($additional);
self::assertFalse($validator->validate($invalidGraph));
self::assertFalse($validator->assert($invalidGraph));
$validator->assert($invalidGraph);
}
/**

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

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

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

@ -53,7 +53,7 @@ class InstanceTest extends TestCase
public function testInstanceValidationShouldReturnTrueForValidInstances(): void
{
self::assertTrue($this->instanceValidator->__invoke(new \ArrayObject()));
self::assertTrue($this->instanceValidator->assert(new \ArrayObject()));
$this->instanceValidator->assert(new \ArrayObject());
$this->instanceValidator->check(new \ArrayObject());
}
@ -63,6 +63,6 @@ class InstanceTest extends TestCase
public function testInvalidInstancesShouldThrowInstanceException(): void
{
self::assertFalse($this->instanceValidator->validate(new \stdClass()));
self::assertFalse($this->instanceValidator->assert(new \stdClass()));
$this->instanceValidator->assert(new \stdClass());
}
}

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

@ -36,7 +36,7 @@ class IntValTest extends TestCase
{
self::assertTrue($this->intValidator->__invoke($input));
$this->intValidator->check($input);
self::assertTrue($this->intValidator->assert($input));
$this->intValidator->assert($input);
}
/**
@ -46,7 +46,7 @@ class IntValTest extends TestCase
public function testInvalidIntegersShouldThrowIntException($input): void
{
self::assertFalse($this->intValidator->__invoke($input));
self::assertFalse($this->intValidator->assert($input));
$this->intValidator->assert($input);
}
public function providerForInt()

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

@ -29,7 +29,7 @@ class IpTest extends TestCase
{
$ipValidator = new Ip($options);
self::assertTrue($ipValidator->__invoke($input));
self::assertTrue($ipValidator->assert($input));
$ipValidator->assert($input);
$ipValidator->check($input);
}
@ -40,7 +40,7 @@ class IpTest extends TestCase
{
$ipValidator = new Ip($networkRange);
self::assertTrue($ipValidator->__invoke($input));
self::assertTrue($ipValidator->assert($input));
$ipValidator->assert($input);
$ipValidator->check($input);
}
@ -52,7 +52,7 @@ class IpTest extends TestCase
{
$ipValidator = new Ip($options);
self::assertFalse($ipValidator->__invoke($input));
self::assertFalse($ipValidator->assert($input));
$ipValidator->assert($input);
}
/**
@ -63,7 +63,7 @@ class IpTest extends TestCase
{
$ipValidator = new Ip($networkRange);
self::assertFalse($ipValidator->__invoke($input));
self::assertFalse($ipValidator->assert($input));
$ipValidator->assert($input);
}
public function providerForIp()

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

@ -138,7 +138,7 @@ class KeyNestedTest extends TestCase
'bar' => 'foo',
],
];
self::assertTrue($validator->assert($object));
$validator->assert($object);
}
/**
@ -148,9 +148,12 @@ class KeyNestedTest extends TestCase
{
$validator = new KeyNested('baz.bar');
$object = 123;
self::assertFalse($validator->assert($object));
$validator->assert($object);
}
/**
* @doesNotPerformAssertions
*/
public function testExtraValidatorShouldValidateKey(): void
{
$subValidator = new Length(3, 7);
@ -162,7 +165,7 @@ class KeyNestedTest extends TestCase
],
],
];
self::assertTrue($validator->assert($object));
$validator->assert($object);
}
public function testNotMandatoryExtraValidatorShouldPassWithAbsentKey(): void

11
tests/unit/Rules/KeyTest.php
View file

@ -101,7 +101,7 @@ class KeyTest extends TestCase
$validator = new Key('bar');
$someArray = [];
$someArray['baraaaaaa'] = 'foo';
self::assertTrue($validator->assert($someArray));
$validator->assert($someArray);
}
/**
@ -111,7 +111,7 @@ class KeyTest extends TestCase
{
$validator = new Key('bar');
$someArray = 123;
self::assertFalse($validator->assert($someArray));
$validator->assert($someArray);
}
/**
@ -119,16 +119,19 @@ class KeyTest extends TestCase
*/
public function testInvalidConstructorParametersShouldThrowComponentExceptionUponInstantiation(): void
{
$validator = new Key(['invalid']);
new Key(['invalid']);
}
/**
* @doesNotPerformAssertions
*/
public function testExtraValidatorShouldValidateKey(): void
{
$subValidator = new Length(1, 3);
$validator = new Key('bar', $subValidator);
$someArray = [];
$someArray['bar'] = 'foo';
self::assertTrue($validator->assert($someArray));
$validator->assert($someArray);
}
public function testNotMandatoryExtraValidatorShouldPassWithAbsentKey(): void

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

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

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

@ -29,7 +29,7 @@ class LowercaseTest extends TestCase
{
$lowercase = new Lowercase();
self::assertTrue($lowercase->__invoke($input));
self::assertTrue($lowercase->assert($input));
$lowercase->assert($input);
$lowercase->check($input);
}
@ -41,7 +41,7 @@ class LowercaseTest extends TestCase
{
$lowercase = new Lowercase();
self::assertFalse($lowercase->__invoke($input));
self::assertFalse($lowercase->assert($input));
$lowercase->assert($input);
}
public function providerForValidLowercase()

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

@ -35,7 +35,7 @@ class MacAddressTest extends TestCase
public function testValidMacaddressesShouldReturnTrue($input): void
{
self::assertTrue($this->macaddressValidator->__invoke($input));
self::assertTrue($this->macaddressValidator->assert($input));
$this->macaddressValidator->assert($input);
$this->macaddressValidator->check($input);
}
@ -46,7 +46,7 @@ class MacAddressTest extends TestCase
public function testInvalidMacaddressShouldThrowMacAddressException($input): void
{
self::assertFalse($this->macaddressValidator->__invoke($input));
self::assertFalse($this->macaddressValidator->assert($input));
$this->macaddressValidator->assert($input);
}
public function providerForMacAddress()

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

@ -30,7 +30,7 @@ class MaxTest extends TestCase
$max = new Max($maxValue, $inclusive);
self::assertTrue($max->validate($input));
$max->check($input);
self::assertTrue($max->assert($input));
$max->assert($input);
}
/**
@ -41,7 +41,7 @@ class MaxTest extends TestCase
{
$max = new Max($maxValue, $inclusive);
self::assertFalse($max->validate($input));
self::assertFalse($max->assert($input));
$max->assert($input);
}
public function providerForValidMax()

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

@ -31,7 +31,7 @@ class MinTest extends TestCase
$min = new Min($minValue, $inclusive);
self::assertTrue($min->__invoke($input));
$min->check($input);
self::assertTrue($min->assert($input));
$min->assert($input);
}
/**
@ -42,7 +42,7 @@ class MinTest extends TestCase
{
$min = new Min($minValue, $inclusive);
self::assertFalse($min->__invoke($input));
self::assertFalse($min->assert($input));
$min->assert($input);
}
public function providerForValidMin()

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

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

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

@ -29,7 +29,7 @@ class MultipleTest extends TestCase
{
$multiple = new Multiple($multipleOf);
self::assertTrue($multiple->validate($input));
self::assertTrue($multiple->assert($input));
$multiple->assert($input);
$multiple->check($input);
}
@ -41,7 +41,7 @@ class MultipleTest extends TestCase
{
$multiple = new Multiple($multipleOf);
self::assertFalse($multiple->validate($input));
self::assertFalse($multiple->assert($input));
$multiple->assert($input);
}
public function providerForMultiple()

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

@ -34,7 +34,7 @@ class NegativeTest extends TestCase
*/
public function testNegativeShouldPass($input): void
{
self::assertTrue($this->negativeValidator->assert($input));
$this->negativeValidator->assert($input);
self::assertTrue($this->negativeValidator->__invoke($input));
$this->negativeValidator->check($input);
}
@ -46,7 +46,7 @@ class NegativeTest extends TestCase
public function testNotNegativeNumbersShouldThrowNegativeException($input): void
{
self::assertFalse($this->negativeValidator->__invoke($input));
self::assertFalse($this->negativeValidator->assert($input));
$this->negativeValidator->assert($input);
}
public function providerForNegative()

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

@ -34,7 +34,7 @@ class NfeAccessKeyTest extends TestCase
*/
public function testValidAccessKey($aK): void
{
self::assertTrue($this->nfeValidator->assert($aK));
$this->nfeValidator->assert($aK);
self::assertTrue($this->nfeValidator->__invoke($aK));
$this->nfeValidator->check($aK);
}
@ -45,7 +45,7 @@ class NfeAccessKeyTest extends TestCase
*/
public function testInvalidAccessKey($aK): void
{
self::assertFalse($this->nfeValidator->assert($aK));
$this->nfeValidator->assert($aK);
}
/**
@ -54,7 +54,7 @@ class NfeAccessKeyTest extends TestCase
*/
public function testInvalidLengthCnh($aK): void
{
self::assertFalse($this->nfeValidator->assert($aK));
$this->nfeValidator->assert($aK);
}
public function validAccessKeyProvider()

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

@ -36,7 +36,7 @@ class NoWhitespaceTest extends TestCase
{
self::assertTrue($this->noWhitespaceValidator->__invoke($input));
$this->noWhitespaceValidator->check($input);
self::assertTrue($this->noWhitespaceValidator->assert($input));
$this->noWhitespaceValidator->assert($input);
}
/**
@ -46,7 +46,7 @@ class NoWhitespaceTest extends TestCase
public function testStringWithWhitespaceShouldFail($input): void
{
self::assertFalse($this->noWhitespaceValidator->__invoke($input));
self::assertFalse($this->noWhitespaceValidator->assert($input));
$this->noWhitespaceValidator->assert($input);
}
/**
@ -55,7 +55,7 @@ class NoWhitespaceTest extends TestCase
public function testStringWithLineBreaksShouldFail(): void
{
self::assertFalse($this->noWhitespaceValidator->__invoke("w\npoiur"));
self::assertFalse($this->noWhitespaceValidator->assert("w\npoiur"));
$this->noWhitespaceValidator->assert("w\npoiur");
}
public function providerForPass()

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

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

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

@ -30,11 +30,13 @@ class NotEmptyTest extends TestCase
}
/**
* @doesNotPerformAssertions
*
* @dataProvider providerForNotEmpty
*/
public function testStringNotEmpty($input): void
{
self::assertTrue($this->object->assert($input));
$this->object->assert($input);
}
/**
@ -43,7 +45,7 @@ class NotEmptyTest extends TestCase
*/
public function testStringEmpty($input): void
{
self::assertFalse($this->object->assert($input));
$this->object->assert($input);
}
public function providerForNotEmpty()

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

@ -24,12 +24,14 @@ use Respect\Validation\Validator;
class NotTest extends TestCase
{
/**
* @doesNotPerformAssertions
*
* @dataProvider providerForValidNot
*/
public function testNot($v, $input): void
{
$not = new Not($v);
self::assertTrue($not->assert($input));
$not->assert($input);
}
/**
@ -39,7 +41,7 @@ class NotTest extends TestCase
public function testNotNotHaha($v, $input): void
{
$not = new Not($v);
self::assertFalse($not->assert($input));
$not->assert($input);
}
/**

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

@ -31,7 +31,7 @@ class NullTypeTest extends TestCase
public function testNullValue(): void
{
self::assertTrue($this->object->assert(null));
$this->object->assert(null);
self::assertTrue($this->object->__invoke(null));
$this->object->check(null);
}
@ -43,7 +43,7 @@ class NullTypeTest extends TestCase
public function testNotNull($input): void
{
self::assertFalse($this->object->__invoke($input));
self::assertFalse($this->object->assert($input));
$this->object->assert($input);
}
public function providerForNotNull()

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

@ -36,7 +36,7 @@ class NumericValTest extends TestCase
{
self::assertTrue($this->object->__invoke($input));
$this->object->check($input);
self::assertTrue($this->object->assert($input));
$this->object->assert($input);
}
/**
@ -46,7 +46,7 @@ class NumericValTest extends TestCase
public function testNotNumeric($input): void
{
self::assertFalse($this->object->__invoke($input));
self::assertFalse($this->object->assert($input));
$this->object->assert($input);
}
public function providerForNumeric()

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

@ -35,7 +35,7 @@ class ObjectTypeTest extends TestCase
public function testObject($input): void
{
self::assertTrue($this->object->__invoke($input));
self::assertTrue($this->object->assert($input));
$this->object->assert($input);
$this->object->check($input);
}
@ -46,7 +46,7 @@ class ObjectTypeTest extends TestCase
public function testNotObject($input): void
{
self::assertFalse($this->object->__invoke($input));
self::assertFalse($this->object->assert($input));
$this->object->assert($input);
}
public function providerForObject()

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

@ -34,7 +34,7 @@ class OddTest extends TestCase
*/
public function testOdd($input): void
{
self::assertTrue($this->object->assert($input));
$this->object->assert($input);
self::assertTrue($this->object->__invoke($input));
$this->object->check($input);
}
@ -46,7 +46,7 @@ class OddTest extends TestCase
public function testNotOdd($input): void
{
self::assertFalse($this->object->__invoke($input));
self::assertFalse($this->object->assert($input));
$this->object->assert($input);
}
public function providerForOdd()

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

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

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

@ -93,7 +93,7 @@ class OptionalTest extends TestCase
$rule = new Optional($validatable);
self::assertTrue($rule->assert(''));
$rule->assert('');
}
public function testShouldAssertRuleWhenInputIsNotOptional(): void
@ -109,7 +109,7 @@ class OptionalTest extends TestCase
$rule = new Optional($validatable);
self::assertTrue($rule->assert($input));
$rule->assert($input);
}
public function testShouldNotCheckRuleWhenInputIsOptional(): void

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

@ -36,7 +36,7 @@ class PerfectSquareTest extends TestCase
{
self::assertTrue($this->object->__invoke($input));
$this->object->check($input);
self::assertTrue($this->object->assert($input));
$this->object->assert($input);
}
/**
@ -46,7 +46,7 @@ class PerfectSquareTest extends TestCase
public function testNotPerfectSquare($input): void
{
self::assertFalse($this->object->__invoke($input));
self::assertFalse($this->object->assert($input));
$this->object->assert($input);
}
public function providerForPerfectSquare()

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

@ -35,7 +35,7 @@ class PhoneTest extends TestCase
public function testValidPhoneShouldReturnTrue($input): void
{
self::assertTrue($this->phoneValidator->__invoke($input));
self::assertTrue($this->phoneValidator->assert($input));
$this->phoneValidator->assert($input);
$this->phoneValidator->check($input);
}
@ -46,7 +46,7 @@ class PhoneTest extends TestCase
public function testInvalidPhoneShouldThrowPhoneException($input): void
{
self::assertFalse($this->phoneValidator->__invoke($input));
self::assertFalse($this->phoneValidator->assert($input));
$this->phoneValidator->assert($input);
}
public function providerForPhone()

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

@ -36,7 +36,7 @@ class PositiveTest extends TestCase
{
self::assertTrue($this->object->__invoke($input));
$this->object->check($input);
self::assertTrue($this->object->assert($input));
$this->object->assert($input);
}
/**
@ -46,7 +46,7 @@ class PositiveTest extends TestCase
public function testNotPositive($input): void
{
self::assertFalse($this->object->__invoke($input));
self::assertFalse($this->object->assert($input));
$this->object->assert($input);
}
public function providerForPositive()

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

@ -36,7 +36,7 @@ class PrimeNumberTest extends TestCase
{
self::assertTrue($this->object->__invoke($input));
$this->object->check($input);
self::assertTrue($this->object->assert($input));
$this->object->assert($input);
}
/**
@ -46,7 +46,7 @@ class PrimeNumberTest extends TestCase
public function testNotPrimeNumber($input): void
{
self::assertFalse($this->object->__invoke($input));
self::assertFalse($this->object->assert($input));
$this->object->assert($input);
}
public function providerForPrimeNumber()

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

@ -39,7 +39,7 @@ class PrntTest extends TestCase
{
$validator = new Prnt($additional);
self::assertFalse($validator->validate($invalidPrint));
self::assertFalse($validator->assert($invalidPrint));
$validator->assert($invalidPrint);
}
/**

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

@ -39,7 +39,7 @@ class PunctTest extends TestCase
{
$validator = new Punct($additional);
self::assertFalse($validator->validate($invalidPunct));
self::assertFalse($validator->assert($invalidPunct));
$validator->assert($invalidPunct);
}
/**

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

@ -35,7 +35,7 @@ class RomanTest extends TestCase
public function testValidRomansShouldReturnTrue($input): void
{
self::assertTrue($this->romanValidator->__invoke($input));
self::assertTrue($this->romanValidator->assert($input));
$this->romanValidator->assert($input);
$this->romanValidator->check($input);
}
@ -46,7 +46,7 @@ class RomanTest extends TestCase
public function testInvalidRomansShouldThrowRomanException($input): void
{
self::assertFalse($this->romanValidator->__invoke($input));
self::assertFalse($this->romanValidator->assert($input));
$this->romanValidator->assert($input);
}
public function providerForRoman()

7
tests/unit/Rules/SfTest.php
View file

@ -40,16 +40,15 @@ class SfTest extends TestCase
}
/**
* @doesNotPerformAssertions
*
* @depends testValidationWithAnExistingValidationConstraint
*/
public function testAssertionWithAnExistingValidationConstraint(): void
{
$constraintName = 'Time';
$validConstraintValue = '04:20:00';
self::assertTrue(
v::sf($constraintName)->assert($validConstraintValue),
sprintf('"%s" should be valid under "%s" constraint.', $validConstraintValue, $constraintName)
);
v::sf($constraintName)->assert($validConstraintValue);
}
/**

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

@ -28,7 +28,7 @@ class SortedTest extends TestCase
$rule = new Sorted();
self::assertTrue($rule->validate($arr));
self::assertTrue($rule->assert($arr));
$rule->assert($arr);
$rule->check($arr);
}
@ -38,7 +38,7 @@ class SortedTest extends TestCase
$rule = new Sorted();
self::assertTrue($rule->validate($arr));
self::assertTrue($rule->assert($arr));
$rule->assert($arr);
$rule->check($arr);
}
@ -60,7 +60,7 @@ class SortedTest extends TestCase
$rule = new Sorted(null, false);
self::assertTrue($rule->validate($arr));
self::assertTrue($rule->assert($arr));
$rule->assert($arr);
$rule->check($arr);
}
@ -70,7 +70,7 @@ class SortedTest extends TestCase
$rule = new Sorted(null, false);
self::assertTrue($rule->validate($arr));
self::assertTrue($rule->assert($arr));
$rule->assert($arr);
$rule->check($arr);
}
@ -92,7 +92,7 @@ class SortedTest extends TestCase
});
self::assertTrue($rule->validate($arr));
self::assertTrue($rule->assert($arr));
$rule->assert($arr);
$rule->check($arr);
}

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

@ -39,7 +39,7 @@ class SpaceTest extends TestCase
{
$validator = new Space($additional);
self::assertFalse($validator->validate($invalidSpace));
self::assertFalse($validator->assert($invalidSpace));
$validator->assert($invalidSpace);
}
/**

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

@ -30,7 +30,7 @@ class StartsWithTest extends TestCase
$v = new StartsWith($start);
self::assertTrue($v->__invoke($input));
$v->check($input);
self::assertTrue($v->assert($input));
$v->assert($input);
}
/**
@ -41,7 +41,7 @@ class StartsWithTest extends TestCase
{
$v = new StartsWith($start, $caseSensitive);
self::assertFalse($v->__invoke($input));
self::assertFalse($v->assert($input));
$v->assert($input);
}
public function providerForStartsWith()

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

@ -29,7 +29,7 @@ class UppercaseTest extends TestCase
{
$uppercase = new Uppercase();
self::assertTrue($uppercase->validate($input));
self::assertTrue($uppercase->assert($input));
$uppercase->assert($input);
$uppercase->check($input);
}
@ -41,7 +41,7 @@ class UppercaseTest extends TestCase
{
$lowercase = new Uppercase();
self::assertFalse($lowercase->validate($input));
self::assertFalse($lowercase->assert($input));
$lowercase->assert($input);
}
public function providerForValidUppercase()

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

@ -29,7 +29,7 @@ class VersionTest extends TestCase
{
$rule = new Version();
self::assertTrue($rule->__invoke($input));
self::assertTrue($rule->assert($input));
$rule->assert($input);
$rule->check($input);
}
@ -41,7 +41,7 @@ class VersionTest extends TestCase
{
$rule = new Version();
self::assertFalse($rule->__invoke($input));
self::assertFalse($rule->assert($input));
$rule->assert($input);
}
public function providerForValidVersion()

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

@ -39,7 +39,7 @@ class VowelTest extends TestCase
{
$validator = new Vowel($additional);
self::assertFalse($validator->validate($invalidVowels));
self::assertFalse($validator->assert($invalidVowels));
$validator->assert($invalidVowels);
}
/**

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

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

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

@ -105,7 +105,7 @@ class ZendTest extends TestCase
$v = new Zend('Date');
$date = new DateTime();
self::assertTrue($v->validate($date));
self::assertTrue($v->assert($date));
$v->assert($date);
}
/**
@ -135,7 +135,7 @@ class ZendTest extends TestCase
public function testParamsNot(): void
{
$v = new Zend('StringLength', ['min' => 10, 'max' => 25]);
self::assertFalse($v->assert('aw'));
$v->assert('aw');
}
}