888 lines
22 KiB
PHP
888 lines
22 KiB
PHP
<?php
|
|
|
|
use \api\core\Checker;
|
|
|
|
describe('api', function(){
|
|
describe('core', function(){
|
|
describe('Checker', function(){
|
|
|
|
/* (1) Unknown type
|
|
---------------------------------------------------------*/
|
|
context('* unknown type', function(){
|
|
|
|
it('fail with any value', function(){
|
|
|
|
expect(Checker::run('unknown_type', 'someString' ))->toBeFalsy();
|
|
expect(Checker::run('unknown_type', 123 ))->toBeFalsy();
|
|
expect(Checker::run('unknown_type', [1, 2] ))->toBeFalsy();
|
|
expect(Checker::run('unknown_type', true ))->toBeFalsy();
|
|
expect(Checker::run('unknown_type', false ))->toBeFalsy();
|
|
expect(Checker::run('unknown_type', new StdClass() ))->toBeFalsy();
|
|
expect(Checker::run('unknown_type', null ))->toBeFalsy();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
/* (2) Mixed
|
|
---------------------------------------------------------*/
|
|
context('* mixed', function(){
|
|
|
|
it('pass with any type', function(){
|
|
|
|
expect(Checker::run('mixed', 'someString' ))->toBeTruthy();
|
|
expect(Checker::run('mixed', 123 ))->toBeTruthy();
|
|
expect(Checker::run('mixed', [1, 2] ))->toBeTruthy();
|
|
expect(Checker::run('mixed', true ))->toBeTruthy();
|
|
expect(Checker::run('mixed', false ))->toBeTruthy();
|
|
expect(Checker::run('mixed', new StdClass() ))->toBeTruthy();
|
|
|
|
});
|
|
|
|
it('fail with null', function(){
|
|
|
|
expect(Checker::run('mixed', null))->toBeFalsy();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
/* (3) id
|
|
---------------------------------------------------------*/
|
|
context('* id', function(){
|
|
|
|
it('pass when numeric (int or string)', function(){
|
|
|
|
$int = 12;
|
|
$string = '12';
|
|
|
|
expect($int)->toBeA('int');
|
|
expect(Checker::run('id', $int))->toBeTruthy();
|
|
|
|
expect($string)->toBeA('string');
|
|
expect(Checker::run('id', $string))->toBeTruthy();
|
|
|
|
});
|
|
|
|
it('pass when decimal with 0 as decimal part (double or string)', function(){
|
|
|
|
$int = 12.0;
|
|
$string = '12.0';
|
|
|
|
expect($int)->toBeA('double');
|
|
expect(Checker::run('id', $int))->toBeTruthy();
|
|
|
|
expect($string)->toBeA('string');
|
|
expect(Checker::run('id', $string))->toBeTruthy();
|
|
|
|
});
|
|
|
|
it('fail when decimal (double or string)', function(){
|
|
|
|
$int = 12.5;
|
|
$string = '12.5';
|
|
|
|
expect($int)->toBeA('double');
|
|
expect(Checker::run('id', $int))->toBeFalsy();
|
|
|
|
expect($string)->toBeA('string');
|
|
expect(Checker::run('id', $string))->toBeFalsy();
|
|
|
|
});
|
|
|
|
it('pass at boundaries', function(){
|
|
|
|
expect(Checker::run('id', 0 ))->toBeTruthy();
|
|
expect(Checker::run('id', 2147483647 ))->toBeTruthy();
|
|
|
|
});
|
|
|
|
it('fail with out-of-boundaries', function(){
|
|
|
|
expect(Checker::run('id', 0-1 ))->toBeFalsy();
|
|
expect(Checker::run('id', 2147483647+1 ))->toBeFalsy();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
/* (4) text
|
|
---------------------------------------------------------*/
|
|
context('* text', function(){
|
|
|
|
it('pass with any string', function(){
|
|
|
|
expect(Checker::run('text', '123' ))->toBeTruthy();
|
|
expect(Checker::run('text', '123'.'123' ))->toBeTruthy();
|
|
|
|
});
|
|
|
|
it('pass with empty string', function(){
|
|
|
|
$empty_str = '';
|
|
expect($empty_str)->toHaveLength(0);
|
|
expect(Checker::run('text', $empty_str))->toBeTruthy();
|
|
|
|
});
|
|
|
|
it('fail when not a string', function(){
|
|
|
|
$vars = [
|
|
'array' => [],
|
|
'int' => 1,
|
|
'double' => 1.23,
|
|
'boolean' => true,
|
|
'object' => new StdClass(),
|
|
'null' => null
|
|
];
|
|
|
|
foreach($vars as $type=>$value){
|
|
|
|
expect($value)->toBeA($type);
|
|
expect(Checker::run('text', $value))->toBeFalsy();
|
|
|
|
}
|
|
|
|
// expect(Checker::run('text', [] ))->toBeFalsy();
|
|
// expect(Checker::run('text', 1 ))->toBeFalsy();
|
|
// expect(Checker::run('text', 1.23 ))->toBeFalsy();
|
|
// expect(Checker::run('text', true ))->toBeFalsy();
|
|
// expect(Checker::run('text', false ))->toBeFalsy();
|
|
// expect(Checker::run('text', new StdClass() ))->toBeFalsy();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
/* (5) Rfid
|
|
---------------------------------------------------------*/
|
|
context('* hash', function(){
|
|
|
|
given('sizes', function(){ return [
|
|
64 => 'sha256',
|
|
128 => 'sha512'
|
|
];
|
|
|
|
});
|
|
|
|
|
|
it('fail when -64/128 char hash', function(){
|
|
|
|
foreach($this->sizes as $size=>$sha){
|
|
|
|
$hash = hash($sha, 'someClearText');
|
|
$hash = substr($hash, 1); // remove 1 char
|
|
|
|
expect($hash)->toHaveLength($size-1);
|
|
expect(Checker::run('hash', $hash))->toBeFalsy();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
it('pass when 64/128 char hash', function(){
|
|
|
|
foreach($this->sizes as $size=>$sha){
|
|
|
|
$hash = hash($sha, 'someClearText');
|
|
|
|
expect($hash)->toHaveLength($size);
|
|
expect(Checker::run('hash', $hash))->toBeTruthy();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
it('fail when +64/128 char hash', function(){
|
|
|
|
foreach($this->sizes as $size=>$sha){
|
|
|
|
$hash = hash($sha, 'someClearText');
|
|
$hash = $hash.'a'; // add character
|
|
|
|
expect($hash)->toHaveLength($size+1);
|
|
expect(Checker::run('hash', $hash))->toBeFalsy();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
it('fail when incorrect character', function(){
|
|
$hash = hash('sha256', 'someClearText');
|
|
$hash[1] = 'g';
|
|
|
|
expect($hash)->not->toMatch('/^[a-f0-9]+$/');
|
|
expect(Checker::run('hash', $hash))->toBeFalsy();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
/* (6) mail
|
|
---------------------------------------------------------*/
|
|
context('* mail', function(){
|
|
|
|
it('fail with out-of-boundaries elements', function(){
|
|
|
|
expect(Checker::run('mail', '@b.cd'))->toBeFalsy();
|
|
expect(Checker::run('mail', 'a@.cd'))->toBeFalsy();
|
|
expect(Checker::run('mail', 'a@b.d'))->toBeFalsy();
|
|
expect(Checker::run('mail', 'a@b.cdefg'))->toBeFalsy();
|
|
|
|
});
|
|
|
|
it('pass with max length', function(){
|
|
|
|
$mail = str_repeat('a', 45).'@b.cd';
|
|
|
|
expect($mail)->toHaveLength(50);
|
|
expect(Checker::run('mail', $mail))->toBeTruthy();
|
|
|
|
});
|
|
|
|
it('fail with more than max length', function(){
|
|
|
|
$mail = str_repeat('a', 46).'@b.cd';
|
|
|
|
expect($mail)->toHaveLength(51);
|
|
expect(Checker::run('mail', $mail))->toBeFalsy();
|
|
|
|
});
|
|
|
|
it('pass with minimum match', function(){
|
|
|
|
expect(Checker::run('mail', 'a@b.cd'))->toBeTruthy();
|
|
expect(Checker::run('mail', 'a@b.cdef'))->toBeTruthy();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
/* (7) alphanumeric
|
|
---------------------------------------------------------*/
|
|
context('* alphanumeric', function(){
|
|
|
|
it('pass when : letters/numbers/./-', function(){
|
|
|
|
expect(Checker::run('alphanumeric', 'abcz0129-.'))->toBeTruthy();
|
|
|
|
});
|
|
|
|
it('pass when unicode', function(){
|
|
|
|
expect(Checker::run('alphanumeric', 'çèééàôò'))->toBeTruthy();
|
|
|
|
});
|
|
|
|
it('fail when not alphanumeric (space/,)', function(){
|
|
|
|
expect(Checker::run('alphanumeric', 'abcz0129-. '))->toBeFalsy();
|
|
expect(Checker::run('alphanumeric', 'abcz0129-.,'))->toBeFalsy();
|
|
|
|
});
|
|
|
|
it('pass when empty', function(){
|
|
|
|
$str = '';
|
|
|
|
expect($str)->toBeEmpty();
|
|
expect(Checker::run('alphanumeric', $str))->toBeTruthy();
|
|
|
|
});
|
|
|
|
|
|
});
|
|
|
|
/* (8) letters
|
|
---------------------------------------------------------*/
|
|
context('* letters', function(){
|
|
|
|
it('pass when : letter/number/space/./-/_', function(){
|
|
|
|
expect(Checker::run('letters', 'abcz-0.9_a'))->toBeTruthy();
|
|
|
|
});
|
|
|
|
it('pass when unicode', function(){
|
|
|
|
expect(Checker::run('letters', 'çèééàôò'))->toBeTruthy();
|
|
|
|
});
|
|
|
|
it('fail when not letters (,/;)', function(){
|
|
|
|
expect(Checker::run('letters', 'abcz-0.9_a,'))->toBeFalsy();
|
|
expect(Checker::run('letters', 'abcz-0.9_a;'))->toBeFalsy();
|
|
|
|
});
|
|
|
|
it('fail when empty', function(){
|
|
|
|
$str = '';
|
|
|
|
expect($str)->toBeEmpty();
|
|
expect(Checker::run('letters', $str))->toBeFalsy();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
/* (9) rfid
|
|
---------------------------------------------------------*/
|
|
context('* rfid', function(){
|
|
|
|
it('pass when 4 block id', function(){
|
|
|
|
expect(Checker::run('rfid', 'AB-CD-EF-09'))->toBeTruthy();
|
|
|
|
});
|
|
|
|
it('fail when 4 block id but lowercase', function(){
|
|
|
|
expect(Checker::run('rfid', 'ab-cd-ef-09'))->toBeFalsy();
|
|
|
|
});
|
|
|
|
it('pass when 6 block id', function(){
|
|
|
|
expect(Checker::run('rfid', 'AB-CD-EF-09-18-27'))->toBeTruthy();
|
|
|
|
});
|
|
|
|
it('fail when 4 block id but lowercase', function(){
|
|
|
|
expect(Checker::run('rfid', 'ab-cd-ef-09-18-27'))->toBeFalsy();
|
|
|
|
});
|
|
|
|
it('fail when 6 block id', function(){
|
|
|
|
expect(Checker::run('rfid', 'B-CD-EF-01-23-45'))->toBeFalsy();
|
|
expect(Checker::run('rfid', 'AB-D-EF-01-23-45'))->toBeFalsy();
|
|
expect(Checker::run('rfid', 'AB-CD-F-01-23-45'))->toBeFalsy();
|
|
expect(Checker::run('rfid', 'AB-CD-EF-1-23-45'))->toBeFalsy();
|
|
expect(Checker::run('rfid', 'AB-CD-EF-01-3-45'))->toBeFalsy();
|
|
expect(Checker::run('rfid', 'AB-CD-EF-01-23-5'))->toBeFalsy();
|
|
expect(Checker::run('rfid', 'ABCD-EF-01-23-45'))->toBeFalsy();
|
|
expect(Checker::run('rfid', 'AB-CDEF-01-23-45'))->toBeFalsy();
|
|
expect(Checker::run('rfid', 'AB-CD-EF01-23-45'))->toBeFalsy();
|
|
expect(Checker::run('rfid', 'AB-CD-EF-0123-45'))->toBeFalsy();
|
|
expect(Checker::run('rfid', 'AB-CD-EF-01-2345'))->toBeFalsy();
|
|
|
|
});
|
|
|
|
it('fail when incorrect char', function(){
|
|
|
|
expect(Checker::run('rfid', 'AB-CD-EG-01'))->toBeFalsy();
|
|
expect(Checker::run('rfid', 'AB-CD-EH-01-23-45'))->toBeFalsy();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
/* (10) Status
|
|
---------------------------------------------------------*/
|
|
context('* status', function(){
|
|
|
|
it('pass when numeric (int or string)', function(){
|
|
|
|
$int = 12;
|
|
$string = '12';
|
|
|
|
expect($int)->toBeA('int');
|
|
expect(Checker::run('status', $int))->toBeTruthy();
|
|
|
|
expect($string)->toBeA('string');
|
|
expect(Checker::run('status', $string))->toBeTruthy();
|
|
|
|
});
|
|
|
|
it('pass when decimal with 0 as decimal part (double or string)', function(){
|
|
|
|
$int = 12.0;
|
|
$string = '12.0';
|
|
|
|
expect($int)->toBeA('double');
|
|
expect(Checker::run('status', $int))->toBeTruthy();
|
|
|
|
expect($string)->toBeA('string');
|
|
expect(Checker::run('status', $string))->toBeTruthy();
|
|
|
|
});
|
|
|
|
it('fail when decimal (double or string)', function(){
|
|
|
|
$int = 12.5;
|
|
$string = '12.5';
|
|
|
|
expect($int)->toBeA('double');
|
|
expect(Checker::run('status', $int))->toBeFalsy();
|
|
|
|
expect($string)->toBeA('string');
|
|
expect(Checker::run('status', $string))->toBeFalsy();
|
|
|
|
});
|
|
|
|
it('pass when boundaries', function(){
|
|
|
|
expect(Checker::run('status', 0))->toBeTruthy();
|
|
expect(Checker::run('status', '0'))->toBeTruthy();
|
|
expect(Checker::run('status', 0.0))->toBeTruthy();
|
|
expect(Checker::run('status', '0.0'))->toBeTruthy();
|
|
|
|
expect(Checker::run('status', 100))->toBeTruthy();
|
|
expect(Checker::run('status', '100'))->toBeTruthy();
|
|
expect(Checker::run('status', 100.0))->toBeTruthy();
|
|
expect(Checker::run('status', '100.0'))->toBeTruthy();
|
|
});
|
|
|
|
it('fail when out-of-boundaries', function(){
|
|
|
|
expect(Checker::run('status', -1))->toBeFalsy();
|
|
expect(Checker::run('status', '-1'))->toBeFalsy();
|
|
expect(Checker::run('status', -1.0))->toBeFalsy();
|
|
expect(Checker::run('status', '-1.0'))->toBeFalsy();
|
|
|
|
expect(Checker::run('status', 101))->toBeFalsy();
|
|
expect(Checker::run('status', '101'))->toBeFalsy();
|
|
expect(Checker::run('status', 101.0))->toBeFalsy();
|
|
expect(Checker::run('status', '101.0'))->toBeFalsy();
|
|
});
|
|
|
|
});
|
|
|
|
/* (11) Boolean
|
|
---------------------------------------------------------*/
|
|
context('* boolean', function(){
|
|
|
|
it('pass when real boolean true/false', function(){
|
|
|
|
expect(Checker::run('boolean', true))->toBeTruthy();
|
|
expect(Checker::run('boolean', false))->toBeTruthy();
|
|
|
|
});
|
|
|
|
it('faise when false boolean (int, string)', function(){
|
|
|
|
expect(Checker::run('boolean', 1))->toBeFalsy();
|
|
expect(Checker::run('boolean', 0))->toBeFalsy();
|
|
expect(Checker::run('boolean', ''))->toBeFalsy();
|
|
expect(Checker::run('boolean', []))->toBeFalsy();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
/* (12) Object
|
|
---------------------------------------------------------*/
|
|
context('* object', function(){
|
|
|
|
it('fail when empty real object', function(){
|
|
|
|
$obj = new StdClass();
|
|
|
|
expect((array) $obj)->toBeEmpty();
|
|
expect(Checker::run('object', $obj))->toBeFalsy();
|
|
|
|
});
|
|
|
|
it('pass when non-empty real object', function(){
|
|
|
|
$obj = new StdClass();
|
|
$obj->a = 10;
|
|
|
|
expect((array) $obj)->not->toBeEmpty();
|
|
expect(Checker::run('object', $obj))->toBeTruthy();
|
|
|
|
});
|
|
|
|
it('faise when false object (assoc. array)', function(){
|
|
|
|
expect(Checker::run('object', ['a'=>function(){}]))->toBeFalsy();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
/* (13) Json
|
|
---------------------------------------------------------*/
|
|
context('* json', function(){
|
|
|
|
it('pass when valid json string', function(){
|
|
|
|
expect(Checker::run('json', '{}'))->toBeTruthy();
|
|
expect(Checker::run('json', '{"a": true}'))->toBeTruthy();
|
|
|
|
});
|
|
|
|
it('fail when not a string', function(){
|
|
|
|
expect(Checker::run('json', 123 ))->toBeFalsy();
|
|
expect(Checker::run('json', [1, 2] ))->toBeFalsy();
|
|
expect(Checker::run('json', true ))->toBeFalsy();
|
|
expect(Checker::run('json', false ))->toBeFalsy();
|
|
expect(Checker::run('json', new StdClass() ))->toBeFalsy();
|
|
expect(Checker::run('json', null ))->toBeFalsy();
|
|
|
|
});
|
|
|
|
it('fail when invalid json string', function(){
|
|
|
|
expect(Checker::run('json', ''))->toBeFalsy();
|
|
expect(Checker::run('json', '{;}'))->toBeFalsy();
|
|
expect(Checker::run('json', '{"a": true}.'))->toBeFalsy();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
/* (14) numeric
|
|
---------------------------------------------------------*/
|
|
context('* numeric', function(){
|
|
|
|
it('pass when numeric (int, double, negative_int, or string)', function(){
|
|
|
|
$values = [ 0, 10, -10, 0.5, -1.5, '0', '10', '-10', '0.5', '-1.5' ];
|
|
|
|
foreach($values as $value)
|
|
expect(Checker::run('numeric', $value))->toBeTruthy();
|
|
|
|
});
|
|
|
|
it('pass when $value == null', function(){
|
|
|
|
$values = [ 0, '', [] ];
|
|
|
|
foreach($values as $value){
|
|
|
|
expect($value)->toEqual(null);
|
|
expect(Checker::run('numeric', $value))->toBeTruthy();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
it('pass when $value == "null"', function(){
|
|
|
|
expect(Checker::run('numeric', 'null'))->toBeTruthy();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
/* (15) Varchar
|
|
---------------------------------------------------------*/
|
|
context('* varchar(start,stop)', function(){
|
|
|
|
given('values', function(){ return [
|
|
'ab',
|
|
'abcdef',
|
|
'abcdefkls023213\'/\\5\'7;658'
|
|
];
|
|
});
|
|
|
|
it('pass when boundaries matches', function(){
|
|
|
|
foreach($this->values as $value){
|
|
$min = 0;
|
|
$max = strlen($value)+1;
|
|
expect(Checker::run("varchar($min,$max)", $value))->toBeTruthy();
|
|
|
|
}
|
|
});
|
|
|
|
it('pass when boundaries matches min length', function(){
|
|
|
|
foreach($this->values as $value){
|
|
$min = strlen($value);
|
|
$max = strlen($value)+1;
|
|
expect(Checker::run("varchar($min,$max)", $value))->toBeTruthy();
|
|
|
|
}
|
|
});
|
|
|
|
it('pass when boundaries matches max length', function(){
|
|
|
|
foreach($this->values as $value){
|
|
$min = 0;
|
|
$max = strlen($value);
|
|
expect(Checker::run("varchar($min,$max)", $value))->toBeTruthy();
|
|
|
|
}
|
|
});
|
|
|
|
it('fail when boundaries are over min length', function(){
|
|
|
|
foreach($this->values as $value){
|
|
$min = strlen($value)+1;
|
|
$max = strlen($value)+2;
|
|
|
|
expect($min)->toBeGreaterThan(strlen($value));
|
|
expect(Checker::run("varchar($min,$max)", $value))->toBeFalsy();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
it('fail when boundaries are under max length', function(){
|
|
|
|
foreach($this->values as $value){
|
|
$min = strlen($value)-2;
|
|
$max = strlen($value)-1;
|
|
|
|
expect($max)->toBeLessThan(strlen($value));
|
|
expect(Checker::run("varchar($min,$max)", $value))->toBeFalsy();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
});
|
|
|
|
/* (16) Varchar + flag
|
|
---------------------------------------------------------*/
|
|
context('* varchar(start,stop,letters)', function(){
|
|
|
|
given('values', function(){ return [
|
|
'ab123-23',
|
|
'abcdef__-0.9',
|
|
'abcz-0.9_a'
|
|
];
|
|
});
|
|
|
|
given('notletters', function(){ return [
|
|
'abcdefkls023213\'/\\5\'7;658',
|
|
'abc;658',
|
|
'abc$658'
|
|
];
|
|
});
|
|
|
|
it('pass when boundaries matches', function(){
|
|
|
|
foreach($this->values as $value){
|
|
$min = 0;
|
|
$max = strlen($value)+1;
|
|
expect(Checker::run("varchar($min,$max,letters)", $value))->toBeTruthy();
|
|
|
|
}
|
|
});
|
|
|
|
it('pass when boundaries matches min length', function(){
|
|
|
|
foreach($this->values as $value){
|
|
$min = strlen($value);
|
|
$max = strlen($value)+1;
|
|
expect(Checker::run("varchar($min,$max,letters)", $value))->toBeTruthy();
|
|
|
|
}
|
|
});
|
|
|
|
it('pass when boundaries matches max length', function(){
|
|
|
|
foreach($this->values as $value){
|
|
$min = 0;
|
|
$max = strlen($value);
|
|
expect(Checker::run("varchar($min,$max,letters)", $value))->toBeTruthy();
|
|
|
|
}
|
|
});
|
|
|
|
it('fail when boundaries are over min length', function(){
|
|
|
|
foreach($this->values as $value){
|
|
$min = strlen($value)+1;
|
|
$max = strlen($value)+2;
|
|
|
|
expect($min)->toBeGreaterThan(strlen($value));
|
|
expect(Checker::run("varchar($min,$max,letters)", $value))->toBeFalsy();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
it('fail when boundaries are under max length', function(){
|
|
|
|
foreach($this->values as $value){
|
|
$min = strlen($value)-2;
|
|
$max = strlen($value)-1;
|
|
|
|
expect($max)->toBeLessThan(strlen($value));
|
|
expect(Checker::run("varchar($min,$max,letters)", $value))->toBeFalsy();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
it('fail when boundaries matches + not letters (incorrect flag check)', function(){
|
|
|
|
foreach($this->notletters as $value){
|
|
$min = 0;
|
|
$max = strlen($value)+1;
|
|
expect(Checker::run("varchar($min,$max,letters)", $value))->toBeFalsy();
|
|
|
|
}
|
|
});
|
|
|
|
it('fail when boundaries matches min length + not letters (incorrect flag check)', function(){
|
|
|
|
foreach($this->notletters as $value){
|
|
$min = strlen($value);
|
|
$max = strlen($value)+1;
|
|
expect(Checker::run("varchar($min,$max,letters)", $value))->toBeFalsy();
|
|
|
|
}
|
|
});
|
|
|
|
it('fail when boundaries matches max length + not letters (incorrect flag check)', function(){
|
|
|
|
foreach($this->notletters as $value){
|
|
$min = 0;
|
|
$max = strlen($value);
|
|
expect(Checker::run("varchar($min,$max,letters)", $value))->toBeFalsy();
|
|
|
|
}
|
|
});
|
|
|
|
it('fail when boundaries are over min length + not letters (incorrect flag check)', function(){
|
|
|
|
foreach($this->notletters as $value){
|
|
$min = strlen($value)+1;
|
|
$max = strlen($value)+2;
|
|
|
|
expect($min)->toBeGreaterThan(strlen($value));
|
|
expect(Checker::run("varchar($min,$max,letters)", $value))->toBeFalsy();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
it('fail when boundaries are under max length', function(){
|
|
|
|
foreach($this->notletters as $value){
|
|
$min = strlen($value)-2;
|
|
$max = strlen($value)-1;
|
|
|
|
expect($max)->toBeLessThan(strlen($value));
|
|
expect(Checker::run("varchar($min,$max,letters)", $value))->toBeFalsy();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
});
|
|
|
|
/* (17) Array
|
|
---------------------------------------------------------*/
|
|
context('* array<subtype>', function(){
|
|
|
|
it('pass when empty array', function(){
|
|
|
|
$arr = [];
|
|
|
|
expect($arr)->toBeA('array');
|
|
expect($arr)->toBeEmpty();
|
|
expect(Checker::run('array<mixed>', $arr))->toBeTruthy();
|
|
|
|
});
|
|
|
|
it('pass when empty array (whatever subtype)', function(){
|
|
|
|
$arr = [];
|
|
|
|
expect($arr)->toBeA('array');
|
|
expect($arr)->toBeEmpty();
|
|
|
|
expect(Checker::run('array<mixed>', $arr))->toBeTruthy();
|
|
expect(Checker::run('array<numeric>', $arr))->toBeTruthy();
|
|
expect(Checker::run('array<array>', $arr))->toBeTruthy();
|
|
|
|
});
|
|
|
|
it('fail when empty array (single type \'array\')', function(){
|
|
|
|
$arr = [];
|
|
|
|
expect($arr)->toBeA('array');
|
|
expect($arr)->toBeEmpty();
|
|
|
|
expect(Checker::run('array', $arr))->toBeFalsy();
|
|
|
|
});
|
|
|
|
it('pass when recursive empty arrays', function(){
|
|
|
|
$arr = [[], []];
|
|
|
|
expect($arr)->toBeA('array');
|
|
expect($arr[0])->toBeA('array');
|
|
expect($arr[1])->toBeA('array');
|
|
expect($arr[0])->toBeEmpty();
|
|
expect($arr[1])->toBeEmpty();
|
|
|
|
expect(Checker::run('array<mixed>', $arr))->toBeTruthy();
|
|
expect(Checker::run('array<array<mixed>>', $arr))->toBeTruthy();
|
|
|
|
});
|
|
|
|
it('fail when recursive empty arrays (array<array>)', function(){
|
|
|
|
$arr = [[], []];
|
|
|
|
expect($arr)->toBeA('array');
|
|
expect($arr[0])->toBeA('array');
|
|
expect($arr[1])->toBeA('array');
|
|
expect($arr[0])->toBeEmpty();
|
|
expect($arr[1])->toBeEmpty();
|
|
|
|
expect(Checker::run('array<array>', $arr))->toBeFalsy();
|
|
|
|
});
|
|
|
|
it('pass when recursive array<id>', function(){
|
|
|
|
$arr = [0, 1, 2, 2147483647];
|
|
|
|
foreach($arr as $id)
|
|
expect(Checker::run('id', $id))->toBeTruthy();
|
|
|
|
expect($arr)->toBeA('array');
|
|
expect(Checker::run('array<mixed>', $arr))->toBeTruthy();
|
|
expect(Checker::run('array<id>', $arr))->toBeTruthy();
|
|
|
|
});
|
|
|
|
it('fail when recursive array<id>', function(){
|
|
|
|
// last boundary
|
|
$arr = [1, 2, 3, 4, 2147483647+1];
|
|
expect(Checker::run('id', $arr[4]))->toBeFalsy();
|
|
expect(Checker::run('array<id>', $arr))->toBeFalsy();
|
|
|
|
// middle wrong
|
|
$arr = [1, 2, 2147483647+1, 3, 4];
|
|
expect(Checker::run('id', $arr[2]))->toBeFalsy();
|
|
expect(Checker::run('array<id>', $arr))->toBeFalsy();
|
|
|
|
// first wrong
|
|
$arr = [2147483647+1, 1, 2, 3, 4];
|
|
expect(Checker::run('id', $arr[0]))->toBeFalsy();
|
|
|
|
expect(Checker::run('array<id>', $arr))->toBeFalsy();
|
|
|
|
// all wrong
|
|
foreach([-1, -2, -3, 2.3, 2147483647+1] as $id)
|
|
expect(Checker::run('id', $id))->toBeFalsy();
|
|
|
|
expect(Checker::run('array<id>', $arr))->toBeFalsy();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
|
|
});
|
|
});
|
|
}); |