dualfroz/nette-utils
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
nette-utils/tests/Utils/Validators.is().phpt
T
dualfroz 6a4be2daab fix(Validators): allow pipe in pattern regular expressions 
The 'pattern:' argument of Validators::is() crashed on a valid regular
expression containing a pipe, e.g. Validators::is('a', 'pattern:(a|b)').

Two parsing bugs combined: the expression was split into validators on every
'|', tearing the regexp apart, and the pipe was also used as the PCRE
delimiter. A 'pattern:' argument now consumes the rest of the expression and
the delimiter is changed to '~', with the pattern anchored as a whole so bare
alternations work too. Pipe-as-OR semantics for combined validators are kept.

Fixes nette/utils#206
2026-09-04 09:22:41 +02:00

441 lines
16 KiB
PHP
Raw Permalink Blame History

<?php declare(strict_types=1);
/**
* Test: Nette\Utils\Validators::is()
*/
use Nette\Utils\Validators;
use Tester\Assert;
require __DIR__ . '/../bootstrap.php';
test('checks integer type with range constraints', function () {
Assert::false(Validators::is(true, 'int'));
Assert::false(Validators::is('1', 'int'));
Assert::true(Validators::is(1, 'integer'));
Assert::true(Validators::is(1, 'int'));
Assert::false(Validators::is(1, 'int:)'));
Assert::false(Validators::is(1, 'int:0'));
Assert::true(Validators::is(1, 'int:1'));
Assert::true(Validators::is(0, 'int:0'));
Assert::true(Validators::is(1, 'int:..'));
Assert::false(Validators::is(1, 'int:0..0'));
Assert::true(Validators::is(1, 'int:0..1'));
Assert::true(Validators::is(1, 'int:0..'));
Assert::false(Validators::is(1, 'int:..0'));
Assert::true(Validators::is(1, 'int:..1'));
Assert::true(Validators::is(0, 'int:..0'));
Assert::true(Validators::is(-1, 'int:..0'));
});
test('verifies validity of a float value', function () {
Assert::false(Validators::is(true, 'float'));
Assert::false(Validators::is('1', 'float'));
Assert::false(Validators::is(1, 'float'));
Assert::true(Validators::is(1.0, 'float'));
});
test('validates number type for both integers and floats', function () {
Assert::false(Validators::is(true, 'number'));
Assert::false(Validators::is('1', 'number'));
Assert::true(Validators::is(1, 'number'));
Assert::true(Validators::is(1.0, 'number'));
});
test('checks numeric string format with sign and decimal rules', function () {
Assert::false(Validators::is(true, 'numeric'));
Assert::true(Validators::is('1', 'numeric'));
Assert::true(Validators::is('-1', 'numeric'));
Assert::true(Validators::is('-1.5', 'numeric'));
Assert::true(Validators::is('-.5', 'numeric'));
Assert::true(Validators::is('+1', 'numeric'));
Assert::true(Validators::is('+1.5', 'numeric'));
Assert::true(Validators::is('+.5', 'numeric'));
Assert::false(Validators::is('1e6', 'numeric'));
Assert::true(Validators::is(1, 'numeric'));
Assert::true(Validators::is(1.0, 'numeric'));
});
test('validates strict numeric integer string format', function () {
Assert::false(Validators::is(true, 'numericint'));
Assert::true(Validators::is('1', 'numericint'));
Assert::true(Validators::is('-1', 'numericint'));
Assert::false(Validators::is('-1.5', 'numericint'));
Assert::false(Validators::is('-.5', 'numericint'));
Assert::true(Validators::is('+1', 'numericint'));
Assert::false(Validators::is('+1.5', 'numericint'));
Assert::false(Validators::is('+.5', 'numericint'));
Assert::false(Validators::is('1e6', 'numericint'));
Assert::true(Validators::is(1, 'numericint'));
Assert::false(Validators::is(1.0, 'numericint'));
});
test('ensures boolean value matches expected flag', function () {
Assert::false(Validators::is(1, 'bool'));
Assert::true(Validators::is(true, 'bool'));
Assert::true(Validators::is(false, 'bool'));
Assert::true(Validators::is(true, 'boolean'));
Assert::true(Validators::is(true, 'bool:1'));
Assert::false(Validators::is(true, 'bool:0'));
Assert::false(Validators::is(false, 'bool:1'));
Assert::true(Validators::is(false, 'bool:0'));
Assert::true(Validators::is(false, 'bool:0..1'));
});
test('checks string type with fixed length constraint', function () {
Assert::false(Validators::is(1, 'string'));
Assert::true(Validators::is('', 'string'));
Assert::true(Validators::is('hello', 'string'));
Assert::true(Validators::is('hello', 'string:5'));
Assert::false(Validators::is('hello', 'string:4'));
Assert::true(Validators::is('hello', 'string:4..'));
Assert::false(Validators::is('hello', 'string:1..4'));
});
test('validates Unicode string with length requirements', function () {
Assert::false(Validators::is(1, 'unicode'));
Assert::true(Validators::is('', 'unicode'));
Assert::true(Validators::is('hello', 'unicode'));
Assert::false(Validators::is("hello\xFF", 'unicode'));
Assert::true(Validators::is('hello', 'unicode:5'));
Assert::false(Validators::is('hello', 'unicode:4'));
Assert::true(Validators::is('hello', 'unicode:4..'));
Assert::false(Validators::is('hello', 'unicode:1..4'));
});
test('checks array structure against length constraints', function () {
Assert::false(Validators::is(null, 'array'));
Assert::true(Validators::is([], 'array'));
Assert::true(Validators::is([], 'array:0'));
Assert::true(Validators::is([1], 'array:1'));
Assert::true(Validators::is([1], 'array:0..'));
Assert::true(Validators::is([], 'array:..1'));
});
test('verifies that value is a sequential list', function () {
Assert::false(Validators::is(null, 'list'));
Assert::true(Validators::is([], 'list'));
Assert::true(Validators::is([1], 'list'));
Assert::true(Validators::is(['a', 'b', 'c'], 'list'));
Assert::false(Validators::is([4 => 1, 2, 3], 'list'));
Assert::false(Validators::is([1 => 'a', 0 => 'b'], 'list'));
Assert::false(Validators::is(['key' => 'value'], 'list'));
$arr = [];
$arr[] = &$arr;
Assert::true(Validators::is($arr, 'list'));
Assert::false(Validators::is([1, 2, 3], 'list:4'));
});
test('confirms value is an object instance', function () {
Assert::false(Validators::is(null, 'object'));
Assert::true(Validators::is(new stdClass, 'object'));
});
test('checks that value is scalar', function () {
Assert::false(Validators::is(null, 'scalar'));
Assert::false(Validators::is([], 'scalar'));
Assert::true(Validators::is(1, 'scalar'));
});
test('validates callable type including array callables', function () {
Assert::false(Validators::is(null, 'callable'));
Assert::false(Validators::is([], 'callable'));
Assert::false(Validators::is(1, 'callable'));
Assert::false(Validators::is('', 'callable'));
Assert::true(Validators::is('hello', 'callable'));
Assert::false(Validators::is(['hello'], 'callable'));
Assert::true(Validators::is(['hello', 'world'], 'callable'));
});
test('ensures value is null', function () {
Assert::false(Validators::is(0, 'null'));
Assert::true(Validators::is(null, 'null'));
});
test('accepts any value for mixed type', function () {
Assert::true(Validators::is([], 'mixed'));
Assert::true(Validators::is(null, 'mixed'));
});
test('validates email format with domain restrictions', function () {
Assert::false(Validators::is('', 'email'));
Assert::false(Validators::is(false, 'email'));
Assert::false(Validators::is('hello', 'email'));
Assert::true(Validators::is('hello@world.cz', 'email'));
Assert::false(Validators::is('hello@localhost', 'email'));
Assert::false(Validators::is('hello@127.0.0.1', 'email'));
Assert::false(Validators::is('hello@localhost.a0', 'email'));
Assert::false(Validators::is('hello@localhost.0a', 'email'));
Assert::true(Validators::is('hello@l.org', 'email'));
Assert::true(Validators::is('hello@1.org', 'email'));
Assert::false(Validators::is('jean.françois@lyotard.fr', 'email'));
Assert::true(Validators::is('jerzy@kosiński.pl', 'email'));
Assert::false(Validators::is('péter@esterházy.hu', 'email'));
Assert::true(Validators::is('hello@1.c0m', 'email'));
Assert::true(Validators::is('hello@1.c', 'email'));
});
test('verifies URL format across various domain cases', function () {
Assert::false(Validators::is('', 'url'));
Assert::false(Validators::is(false, 'url'));
Assert::false(Validators::is('hello', 'url'));
Assert::false(Validators::is('nette.org', 'url'));
Assert::false(Validators::is('http://nette.org0', 'url'));
Assert::false(Validators::is('http://nette.0org', 'url'));
Assert::false(Validators::is('http://_nette.org', 'url'));
Assert::false(Validators::is('http://www._nette.org', 'url'));
Assert::false(Validators::is('http://www.ne_tte.org', 'url'));
Assert::true(Validators::is('http://1.org', 'url'));
Assert::true(Validators::is('http://l.org', 'url'));
Assert::true(Validators::is('http://localhost', 'url'));
Assert::true(Validators::is('http://127.0.0.1', 'url'));
Assert::true(Validators::is('http://255.255.255.255', 'url'));
Assert::false(Validators::is('http://999.999.999.999', 'url'));
Assert::false(Validators::is('http://256.1.1.1', 'url'));
Assert::false(Validators::is('http://1.2.3', 'url'));
Assert::true(Validators::is('http://[::1]', 'url'));
Assert::true(Validators::is('http://[2001:0db8:0000:0000:0000:0000:1428:57AB]', 'url'));
Assert::true(Validators::is('http://nette.org/path', 'url'));
Assert::true(Validators::is('http://nette.org:8080/path', 'url'));
Assert::true(Validators::is('https://www.nette.org/path', 'url'));
Assert::true(Validators::is('https://www.nette.org/path?query#fragment', 'url'));
Assert::true(Validators::is('https://www.nette.org?query', 'url'));
Assert::true(Validators::is('https://www.nette.org#fragment', 'url'));
Assert::true(Validators::is('https://www.nette.org?#', 'url'));
Assert::true(Validators::is('https://example.c0m', 'url'));
Assert::true(Validators::is('https://example.l', 'url'));
Assert::true(Validators::is('http://one_two.example.com', 'url'));
Assert::true(Validators::is('http://_.example.com', 'url'));
Assert::true(Validators::is('http://_e_.example.com', 'url'));
});
test('checks URI format with proper scheme requirements', function () {
Assert::false(Validators::is('', 'uri'));
Assert::false(Validators::is(false, 'uri'));
Assert::false(Validators::is('hello', 'uri'));
Assert::false(Validators::is('nette.org', 'uri'));
Assert::false(Validators::is('mailto: gandalf@example.org', 'uri'));
Assert::false(Validators::is('invalid-scheme :gandalf@example.org', 'uri'));
Assert::false(Validators::is('invalid-scheme~:gandalf@example.org', 'uri'));
Assert::true(Validators::is('mailto:gandalf@example.org', 'uri'));
Assert::true(Validators::is('valid-scheme+.0:lalala', 'uri'));
Assert::true(Validators::is('bitcoin:mipcBbFg9gMiCh81Kj8tqqdgoZub1ZJRfn', 'uri'));
});
test('accepts empty and null values for none type', function () {
Assert::true(Validators::is(0, 'none'));
Assert::true(Validators::is('', 'none'));
Assert::true(Validators::is(null, 'none'));
Assert::true(Validators::is(false, 'none'));
Assert::false(Validators::is('0', 'none'));
Assert::true(Validators::is([], 'none'));
});
test('validates string against a regular expression pattern', function () {
Assert::true(Validators::is('', 'pattern'));
Assert::true(Validators::is(' 123', 'pattern:\s+\d+'));
Assert::false(Validators::is(' 123x', 'pattern:\s+\d+'));
});
test('allows pipe inside a regular expression pattern', function () {
// grouped alternation, https://github.com/nette/utils/issues/206
Assert::true(Validators::is('a', 'pattern:(a|b)'));
Assert::true(Validators::is('b', 'pattern:(a|b)'));
Assert::false(Validators::is('c', 'pattern:(a|b)'));
// bare alternation must no longer throw and is anchored as a whole
Assert::true(Validators::is('a', 'pattern:a|b'));
Assert::true(Validators::is('b', 'pattern:a|b'));
Assert::false(Validators::is('c', 'pattern:a|b'));
Assert::false(Validators::is('ab', 'pattern:a|b'));
// a pattern combined with other validators
Assert::true(Validators::is(5, 'int|pattern:(a|b)'));
Assert::true(Validators::is('a', 'int|pattern:(a|b)'));
Assert::false(Validators::is('c', 'int|pattern:(a|b)'));
});
test('ensures alphanumeric string meets minimum length', function () {
Assert::false(Validators::is('', 'alnum'));
Assert::false(Validators::is('a-1', 'alnum'));
Assert::true(Validators::is('a1', 'alnum'));
Assert::true(Validators::is('a1', 'alnum:2'));
});
test('checks alphabetic string within a specified length range', function () {
Assert::false(Validators::is('', 'alpha'));
Assert::false(Validators::is('a1', 'alpha'));
Assert::true(Validators::is('aA', 'alpha'));
Assert::true(Validators::is('aA', 'alpha:1..3'));
});
test('validates digit-only string with length limitations', function () {
Assert::false(Validators::is('', 'digit'));
Assert::false(Validators::is('123x', 'digit'));
Assert::true(Validators::is('123', 'digit'));
Assert::false(Validators::is('123', 'digit:..2'));
});
test('ensures string is entirely lowercase with fixed length', function () {
Assert::false(Validators::is('', 'lower'));
Assert::false(Validators::is('Hello', 'lower'));
Assert::true(Validators::is('hello', 'lower'));
Assert::false(Validators::is('hello', 'lower:9'));
});
test('confirms string is entirely uppercase', function () {
Assert::false(Validators::is('', 'upper'));
Assert::false(Validators::is('Hello', 'upper'));
Assert::true(Validators::is('HELLO', 'upper'));
});
test('validates that string contains only whitespace', function () {
Assert::false(Validators::is('', 'space'));
Assert::false(Validators::is(' 1', 'space'));
Assert::true(Validators::is(" \t\r\n", 'space'));
});
test('checks that string consists solely of hexadecimal digits', function () {
Assert::false(Validators::is('', 'xdigit'));
Assert::false(Validators::is('123x', 'xdigit'));
Assert::true(Validators::is('123aA', 'xdigit'));
});
test('validates union type allowing int or float values', function () {
Assert::true(Validators::is(1.0, 'int|float'));
Assert::true(Validators::is(1, 'int|float'));
Assert::false(Validators::is('1', 'int|float'));
});
test('verifies existence of a type by its name', function () {
class rimmer
{
}
interface kryton
{
}
Assert::true(Validators::is('rimmer', 'type'));
Assert::true(Validators::is('kryton', 'type'));
Assert::false(Validators::is('1', 'type'));
});
test('checks for the existence of a class by name', function () {
Assert::true(Validators::is('rimmer', 'class'));
Assert::false(Validators::is('kryton', 'class'));
Assert::false(Validators::is('1', 'class'));
});
test('determines if an interface exists by its name', function () {
Assert::false(Validators::is('rimmer', 'interface'));
Assert::true(Validators::is('kryton', 'interface'));
Assert::false(Validators::is('1', 'interface'));
});
test('validates file existence based on file type', function () {
Assert::true(Validators::is(__FILE__, 'file'));
Assert::false(Validators::is(__FILE__ . 'xx', 'class'));
});
test('confirms directory existence', function () {
Assert::true(Validators::is(__DIR__, 'directory'));
Assert::false(Validators::is(__DIR__ . 'xx', 'directory'));
});
test('ensures identifier follows naming conventions', function () {
Assert::true(Validators::is('Item', 'identifier'));
Assert::false(Validators::is('0Item', 'identifier'));
});
test('validates optional string or email format', function () {
Assert::true(Validators::is('', 'string:0|email'));
Assert::true(Validators::is('foo@bar.com', 'string:0|email'));
Assert::false(Validators::is('foo', 'string:0|email'));
});
test('checks that value is iterable from arrays, iterators, or generators', function () {
$gen = function () {
yield;
};
Assert::true(Validators::is([1, 2, 3], 'iterable'));
Assert::true(Validators::is(new ArrayIterator([1, 2, 3]), 'iterable'));
Assert::true(Validators::is($gen(), 'iterable'));
Assert::false(Validators::is(1, 'iterable'));
Assert::false(Validators::is(3.14, 'iterable'));
Assert::false(Validators::is(new stdClass, 'iterable'));
});
test('validates multi-dimensional arrays against element type rules', function () {
class Abc
{
}
Assert::true(Validators::is([], 'int[]'));
Assert::true(Validators::is(new ArrayIterator([]), 'int[]'));
Assert::false(Validators::is(1, 'int[]'));
Assert::false(Validators::is(2.15, 'int[]'));
Assert::true(Validators::is(2.15, 'float|int[]'));
Assert::true(Validators::is(2.15, 'int[]|float'));
Assert::true(Validators::is([1, 2, 3], 'int[]'));
Assert::false(Validators::is([1, 2, 3], 'int[][]'));
Assert::true(Validators::is([[1], [2, 3]], 'int[][]'));
Assert::false(Validators::is([1, 2.15, 3], 'int[]'));
Assert::true(Validators::is([1, 2.15, 3], 'number[]'));
Assert::true(Validators::is([new Abc], 'Abc[]'));
Assert::false(Validators::is([new Abc, new stdClass], 'Abc[]'));
Assert::true(Validators::is(['ABCD', 'EFGH', 'IJKL'], 'string:4[]'));
Assert::false(Validators::is(['ABCD', 'EFGH', 'IJKLM'], 'string:4[]'));
Assert::true(Validators::is([['ABCD', 'EFGH'], ['IJKL']], 'string:4[][]'));
Assert::false(Validators::is([['ABCD', 'EFGH'], ['IJKLM']], 'string:4[][]'));
});
test('checks nullable string type acceptance', function () {
Assert::true(Validators::is(null, '?string'));
Assert::true(Validators::is('1', '?string'));
Assert::false(Validators::is(true, '?int'));
Assert::false(Validators::is(0, '?string'));
});
Reference in new issue View Git Blame Copy Permalink