public function testInValid()
{
$array = ['ids' => ['*****@*****.**', '*****@*****.**', 1234]];
$this->validation->add('ids', $this->testable);
$messages = $this->validation->validate($array);
$this->assertEquals(1, count($messages));
}
public function validation()
{
$validator = new Validation();
$validator->add('creeA', new PresenceOfValidator(array('message' => "La date de création est nécessaire")));
$validator->add('courrierElectronique', new EmailValidator(array('field' => '', 'message' => 'Le courrier électronique est invalide')));
$validator->add('statut', new ExclusionInValidator(array('domain' => array('X', 'Z'), 'message' => 'L\'état ne doit être "X" ou "Z"')));
$validator->add('statut', new InclusionInValidator(array('domain' => array('P', 'I', 'w'), 'message' => 'L\'état doit être "P", "I" ou "w"')));
$validator->add('courrierElectronique', new UniquenessValidator(array('message' => 'Le courrier électronique doit être unique', 'model' => $this)));
$validator->validate('statut', new RegexValidator(array('pattern' => '/[A-Z]/', 'message' => "L'état ne correspond pas à l'expression régulière")));
$validator->validate('courrierElectronique', new StringLengthValidator(array('min' => '7', 'max' => '50', 'messageMinimum' => "Le courrier électronique est trop court", 'messageMaximum' => "Le courrier électronique est trop long")));
return $this->validate($validator);
}
public function testCustomMessage()
{
$this->specify('Test Email validator works with a custom message.', function () {
$validation = new Validation();
$validation->add('email', new Email(['message' => 'The email is not valid']));
$messages = $validation->validate([]);
$expectedMessages = Validation\Message\Group::__set_state(['_messages' => [0 => Validation\Message::__set_state(['_type' => 'Email', '_message' => 'The email is not valid', '_field' => 'email', '_code' => '0'])]]);
$this->assertEquals($expectedMessages, $messages);
$messages = $validation->validate(['email' => 'x=1']);
expect($expectedMessages)->equals($messages);
$messages = $validation->validate(['email' => '*****@*****.**']);
expect($messages)->count(0);
});
}
public function testCustomMessage()
{
$this->specify('Test URL validator works with a custom message.', function () {
$validation = new Validation();
$validation->add('url', new Validation\Validator\Url(['message' => 'The url is not valid']));
$messages = $validation->validate([]);
$expectedMessages = Validation\Message\Group::__set_state(['_messages' => [0 => Validation\Message::__set_state(['_type' => 'Url', '_message' => 'The url is not valid', '_field' => 'url', '_code' => '0'])]]);
expect($expectedMessages)->equals($messages);
$messages = $validation->validate(['url' => 'x=1']);
expect($expectedMessages)->equals($messages);
$messages = $validation->validate(['url' => 'http://phalconphp.com']);
expect($messages)->count(0);
});
}
public function testCustomMessage()
{
$this->specify('Test Between validator works with a custom message.', function () {
$validation = new Validation();
$validation->add('price', new Between(['minimum' => 1, 'maximum' => 3, 'message' => 'The price must be between 1 and 3']));
$messages = $validation->validate(['price' => 5]);
$expectedMessages = Validation\Message\Group::__set_state(['_messages' => [0 => Validation\Message::__set_state(['_type' => 'Between', '_message' => 'The price must be between 1 and 3', '_field' => 'price', '_code' => '0'])]]);
$this->assertEquals($expectedMessages, $messages);
$messages = $validation->validate([]);
expect($expectedMessages)->equals($messages);
$messages = $validation->validate(['price' => 2]);
expect($messages)->count(0);
});
}
public function validate(array $data)
{
$messages = parent::validate($data);
if ($messages->count() > 0) {
throw new ValidationException($messages);
}
}
public function createAction()
{
$response = new Response();
$response->setHeader('Content-Type', 'application/json');
if ($this->request->isPost()) {
$validation = new Validation();
$validation->add('profilesId', new PresenceOf(array('message' => '请选择一个角色类型')));
$messages = $validation->validate($_POST);
$datas = array();
if (count($messages)) {
foreach ($messages as $message) {
$datas[] = $message->getMessage();
}
$response->setJsonContent(array('status' => 'error', 'messages' => $datas));
} else {
$user = new Users();
$user->assign(array('name' => $this->request->getPost('name', 'striptags'), 'email' => $this->request->getPost('email', 'email'), 'profilesId' => $this->request->getPost('profilesId', 'int')));
if (!$user->save()) {
foreach ($user->getMessages() as $message) {
$datas[] = $message->getMessage();
}
$response->setJsonContent(array('status' => 'error', 'messages' => $datas));
} else {
$response->setJsonContent(array('status' => 'success', 'messages' => '用户添加成功'));
}
}
}
return $response;
}
public function signup($data)
{
foreach ($data as $k => $v) {
$this->{$k} = $v;
}
$this->confirm = 1;
$validation = new Validation();
$validation->add('email', new Validation\Validator\Email(array('message' => 'Указан не действительный E-mail')));
$validation->add('email', new \App\Library\Validators\Uniqueness(array("model" => 'App\\Models\\Users', "message" => "Такой E-mail уже используется.")));
$validation->add('fname', new Validation\Validator\PresenceOf(array('message' => 'Поле "Имя" должно быть заполнено')));
$validation->add('fname', new Validation\Validator\StringLength(array("max" => 40, 'messageMaximum' => 'Длина текста в поле "' . $this->getLabel('fname') . '" должна быть не более 40 символов')));
$validation->add('lname', new Validation\Validator\StringLength(array("max" => 40, 'messageMaximum' => 'Длина текста в поле "' . $this->getLabel('lname') . '" должна быть не более 40 символов')));
$validation->add('thname', new Validation\Validator\StringLength(array("max" => 40, 'messageMaximum' => 'Длина текста в поле "' . $this->getLabel('thname') . '" должна быть не более 40 символов')));
$validation->add('password', new Validation\Validator\PresenceOf(array('message' => 'Пароль должен быть указан')));
$validation->add('password', new Validation\Validator\Confirmation(array('with' => 'password_confirm', 'message' => '"Пароль" и "Повтор пароля" должны совпадать')));
$messages = $validation->validate($data);
if (count($messages)) {
return $validation->getMessages();
} else {
if ($this->create() === true) {
return true;
} else {
return $this->getMessages();
}
}
}
/**
* User login
*/
public function indexAction()
{
//User has login yet
if ($this->_user) {
$this->session->remove('auth');
unset($_SESSION);
}
$this->_addSocialLogin();
//Regular login
if ($this->request->isPost()) {
$validation = new Validation();
$validation->add('email', new Email());
$messages = $validation->validate($this->request->getPost());
if (count($messages)) {
foreach ($messages as $message) {
$this->flashSession->error($message);
}
$this->response->redirect('/user/login/');
return;
}
$email = strtolower($this->request->getPost('email', 'email'));
$password = $this->request->getPost('password', 'string');
if (Users::login($email, $password)) {
$user = Users::getCurrentUser();
$this->flashSession->success('Hi, ' . $user['full_name']);
$this->response->redirect('/');
} else {
$this->flashSession->error('User or password not match!');
$this->response->redirect('/user/login/');
}
}
}
/**
* Login Action
*/
public function indexAction()
{
//User has login yet
if ($this->_user) {
$this->session->remove('auth');
unset($_SESSION);
}
//Regular login
if ($this->request->isPost()) {
$validation = new Validation();
$validation->add('email', new Email());
$messages = $validation->validate($this->request->getPost());
if (count($messages)) {
foreach ($messages as $message) {
$this->flashSession->error($message);
}
return $this->response->redirect('/admin/user/login/');
}
$email = strtolower($this->request->getPost('email', 'email'));
$password = $this->request->getPost('password', 'string');
if (Users::login($email, $password)) {
$this->response->redirect('/admin/');
} else {
$this->flashSession->error('m_user_message_login__user_or_password_do_not_match');
return $this->response->redirect('/admin/user/login/');
}
}
return null;
}
/**
* Tests alnum validator with multiple field
*
* @author Wojciech Ślawski <*****@*****.**>
* @since 2016-06-05
*/
public function testMultipleField()
{
$this->specify('Test alnum validator with multiple field.', function () {
$validation = new Validation();
$validationMessages = ['name' => 'Name must be alnum', 'type' => 'Type must be alnum'];
$validation->add(['name', 'type'], new Alnum(['message' => $validationMessages]));
$messages = $validation->validate(['name' => 'SomeValue123', 'type' => 'SomeValue123']);
expect($messages->count())->equals(0);
$messages = $validation->validate(['name' => 'SomeValue123!@#', 'type' => 'SomeValue123']);
expect($messages->count())->equals(1);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['name']);
$messages = $validation->validate(['name' => 'SomeValue123!@#', 'type' => 'SomeValue123!@#']);
expect($messages->count())->equals(2);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['name']);
expect($messages->offsetGet(1)->getMessage())->equals($validationMessages['type']);
});
}
/**
* Tests numericality validator with multiple field
*
* @author Wojciech Ślawski <*****@*****.**>
* @since 2016-06-05
*/
public function testMultipleField()
{
$this->specify('Test numericality validator with multiple field', function () {
$validation = new Validation();
$validationMessages = ['amount' => 'Amount must be digit.', 'price' => 'Price must be digit.'];
$validation->add(['amount', 'price'], new Numericality(['message' => $validationMessages]));
$messages = $validation->validate(['amount' => 123, 'price' => 123]);
expect($messages->count())->equals(0);
$messages = $validation->validate(['amount' => '123abc', 'price' => 123]);
expect($messages->count())->equals(1);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['amount']);
$messages = $validation->validate(['amount' => '123abc', 'price' => '123abc']);
expect($messages->count())->equals(2);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['amount']);
expect($messages->offsetGet(1)->getMessage())->equals($validationMessages['price']);
});
}
/**
* Tests between validator with multiple field
*
* @author Wojciech Ślawski <*****@*****.**>
* @since 2016-06-05
*/
public function testMultipleField()
{
$this->specify('Test between validator with multiple field.', function () {
$validation = new Validation();
$validationMessages = ['amount' => 'Amount must be between 0 and 999.', 'price' => 'Price must be between 0 and 999.'];
$validation->add(['amount', 'price'], new Between(['minimum' => ['amount' => 0, 'price' => 0], 'maximum' => ['amount' => 999, 'price' => 999], 'message' => $validationMessages]));
$messages = $validation->validate(['amount' => 100]);
expect($messages->count())->equals(0);
$messages = $validation->validate(['amount' => 1000, 'price' => 100]);
expect($messages->count())->equals(1);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['amount']);
$messages = $validation->validate(['amount' => 1000, 'price' => 1000]);
expect($messages->count())->equals(2);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['amount']);
expect($messages->offsetGet(1)->getMessage())->equals($validationMessages['price']);
});
}
/**
* Tests url validator with multiple field
*
* @author Wojciech Ślawski <*****@*****.**>
* @since 2016-06-05
*/
public function testMultipleField()
{
$this->specify('Test url validator with multiple field.', function () {
$validation = new Validation();
$validationMessages = ['url' => 'Url must be correct url.', 'anotherUrl' => 'AnotherUrl must be correct url.'];
$validation->add(['url', 'anotherUrl'], new Validation\Validator\Url(['message' => $validationMessages]));
$messages = $validation->validate(['url' => 'http://google.com', 'anotherUrl' => 'http://google.com']);
expect($messages->count())->equals(0);
$messages = $validation->validate(['url' => '://google.', 'anotherUrl' => 'http://google.com']);
expect($messages->count())->equals(1);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['url']);
$messages = $validation->validate(['url' => '://google.', 'anotherUrl' => '://google.']);
expect($messages->count())->equals(2);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['url']);
expect($messages->offsetGet(1)->getMessage())->equals($validationMessages['anotherUrl']);
});
}
/**
* Tests email validator with multiple field
*
* @author Wojciech Ślawski <*****@*****.**>
* @since 2016-06-05
*/
public function testMultipleField()
{
$this->specify('Test email validator with multiple field.', function () {
$validation = new Validation();
$validationMessages = ['email' => 'Email must be correct email.', 'anotherEmail' => 'AnotherEmail must be correct email.'];
$validation->add(['email', 'anotherEmail'], new Email(['message' => $validationMessages]));
$messages = $validation->validate(['email' => '*****@*****.**', 'anotherEmail' => '*****@*****.**']);
expect($messages->count())->equals(0);
$messages = $validation->validate(['email' => 'rootlocalhost', 'anotherEmail' => '*****@*****.**']);
expect($messages->count())->equals(1);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['email']);
$messages = $validation->validate(['email' => 'rootlocalhost', 'anotherEmail' => 'rootlocalhost']);
expect($messages->count())->equals(2);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['email']);
expect($messages->offsetGet(1)->getMessage())->equals($validationMessages['anotherEmail']);
});
}
public function testEmptyMongoIdValueWithAllowEmptyOption()
{
$array = ['id' => ''];
$this->testable->setOption('allowEmpty', true);
$this->validation->add('id', $this->testable);
$messages = $this->validation->validate($array);
$this->assertEquals(0, count($messages));
}
/**
* Tests confirmation validator with multiple field
*
* @author Wojciech Ślawski <*****@*****.**>
* @since 2016-06-05
*/
public function testMultipleField()
{
$this->specify('Test confirmation validator with multiple field.', function () {
$validation = new Validation();
$validationMessages = ['name' => 'Name must be same as nameWith.', 'type' => 'Type must be same as typeWith.'];
$validation->add(['name', 'type'], new Confirmation(['with' => ['name' => 'nameWith', 'type' => 'typeWith'], 'message' => $validationMessages]));
$messages = $validation->validate(['name' => 'SomeValue', 'nameWith' => 'SomeValue', 'type' => 'SomeValue', 'typeWith' => 'SomeValue']);
expect($messages->count())->equals(0);
$messages = $validation->validate(['name' => 'SomeValue', 'nameWith' => 'SomeValue123', 'type' => 'SomeValue', 'typeWith' => 'SomeValue']);
expect($messages->count())->equals(1);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['name']);
$messages = $validation->validate(['name' => 'SomeValue', 'nameWith' => 'SomeValue123', 'type' => 'SomeValue', 'typeWith' => 'SomeValue123']);
expect($messages->count())->equals(2);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['name']);
expect($messages->offsetGet(1)->getMessage())->equals($validationMessages['type']);
});
}
/**
* Tests credit card validator with multiple field
*
* @author Wojciech Ślawski <*****@*****.**>
* @since 2016-06-05
*/
public function testMultipleField()
{
$this->specify('Test credit card validator with multiple field.', function () {
$validation = new Validation();
$validationMessages = ['creditCard' => 'CreditCard must be correct credit card value.', 'anotherCreditCard' => 'AnotherCreditCard must be correct credit card value.'];
$validation->add(['creditCard', 'anotherCreditCard'], new CreditCard(['message' => $validationMessages]));
$messages = $validation->validate(['creditCard' => 4601587377626131, 'anotherCreditCard' => 4601587377626131]);
expect($messages->count())->equals(0);
$messages = $validation->validate(['creditCard' => 46015873776261312, 'anotherCreditCard' => 4601587377626131]);
expect($messages->count())->equals(1);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['creditCard']);
$messages = $validation->validate(['creditCard' => 46015873776261312, 'anotherCreditCard' => 46015873776261312]);
expect($messages->count())->equals(2);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['creditCard']);
expect($messages->offsetGet(1)->getMessage())->equals($validationMessages['anotherCreditCard']);
});
}
/**
* Tests date validator with multiple field
*
* @author Wojciech Ślawski <*****@*****.**>
* @since 2016-06-05
*/
public function testMultipleField()
{
$this->specify('Test date validator with multiple field.', function () {
$validation = new Validation();
$validationMessages = ['date' => 'Date must be correct date formay Y-m-d.', 'anotherDate' => 'AnotherDate must be correct date format d-m-Y.'];
$validation->add(['date', 'anotherDate'], new Date(['format' => ['date' => 'Y-m-d', 'anotherDate' => 'd-m-Y'], 'message' => $validationMessages]));
$messages = $validation->validate(['date' => '2016-06-05', 'anotherDate' => '05-06-2016']);
expect($messages->count())->equals(0);
$messages = $validation->validate(['date' => '2016-06-32', 'anotherDate' => '05-06-2016']);
expect($messages->count())->equals(1);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['date']);
$messages = $validation->validate(['date' => '2016-06-32', 'anotherDate' => '32-06-2016']);
expect($messages->count())->equals(2);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['date']);
expect($messages->offsetGet(1)->getMessage())->equals($validationMessages['anotherDate']);
});
}
public function testShouldValidateIntOrStringOfDigits()
{
$this->specify('The Digit Validator does not validate digits correctly', function ($digit) {
$validation = new Validation();
$validation->add('amount', new Digit());
$messages = $validation->validate(['amount' => $digit]);
expect($messages)->count(0);
}, ['examples' => [['123'], [123], [PHP_INT_MAX], [0xffffff], [100000], [-100000], [0], ["0"], ["00001233422003400"]]]);
}
public function testAlreadyTakenUniquenessWithCustomMessage()
{
$uniquenessOptions = ['table' => 'users', 'column' => 'login', 'message' => 'Login already taken.'];
$uniqueness = new Uniqueness($uniquenessOptions, $this->getDbStub());
$this->validation->add('login', $uniqueness);
$messages = $this->validation->validate(['login' => 'login_taken']);
$this->assertCount(1, $messages);
$this->assertEquals('Login already taken.', $messages[0]);
}
/**
* Tests identical validator with multiple field and multiple accepted
*
* @author Wojciech Ślawski <*****@*****.**>
* @since 2016-06-05
*/
public function testMultipleFieldMultipleAccepted()
{
$this->specify('Test identical with multiple field and accepted.', function () {
$validation = new Validation();
$validationMessages = ['name' => 'Name must be SomeValue.', 'anotherName' => 'AnotherName must be SomeAnotherValue.'];
$validation->add(['name', 'anotherName'], new Validation\Validator\Identical(['accepted' => ['name' => 'SomeValue', 'anotherName' => 'SomeAnotherValue'], 'message' => $validationMessages]));
$messages = $validation->validate(['name' => 'SomeValue', 'anotherName' => 'SomeAnotherValue']);
expect($messages->count())->equals(0);
$messages = $validation->validate(['name' => 'SomeValue123', 'anotherName' => 'SomeAnotherValue']);
expect($messages->count())->equals(1);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['name']);
$messages = $validation->validate(['name' => 'SomeValue', 'anotherName' => 'SomeAnotherValue123']);
expect($messages->count())->equals(1);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['anotherName']);
$messages = $validation->validate(['name' => 'SomeValue123', 'anotherName' => 'SomeAnotherValue123']);
expect($messages->count())->equals(2);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['name']);
expect($messages->offsetGet(1)->getMessage())->equals($validationMessages['anotherName']);
});
}
/**
* @dataProvider providerCards
* @param mixed $type
* @param mixed $cardnumber
* @param boolean $willReturn
*/
public function testShouldValidateCardNumberForModel($type, $cardnumber, $willReturn)
{
$validation = new Validation();
if ($type) {
$validation->add('creditcard', new CardNumber(['type' => $type]));
} else {
$validation->add('creditcard', new CardNumber());
}
$messages = $validation->validate(['creditcard' => $cardnumber]);
$this->assertNotEquals($willReturn, $messages->valid());
}
/**
* Tests regex validator with multiple field and pattern
*
* @author Wojciech Ślawski <*****@*****.**>
* @since 2016-06-05
*/
public function testMultipleFieldMultiplePattern()
{
$this->specify('Test regex validator with multiple field and pattern.', function () {
$validation = new Validation();
$validationMessages = ['name' => 'Name can be only lowercase letters.', 'type' => 'Type can be only uppercase letters.'];
$validation->add(['name', 'type'], new Validation\Validator\Regex(['pattern' => ['name' => '/^[a-z]+$/', 'type' => '/^[A-Z]+$/'], 'message' => $validationMessages]));
$messages = $validation->validate(['name' => 'somevalue', 'type' => 'SOMEVALUE']);
expect($messages->count())->equals(0);
$messages = $validation->validate(['name' => 'SomeValue', 'type' => 'SOMEVALUE']);
expect($messages->count())->equals(1);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['name']);
$messages = $validation->validate(['name' => 'somevalue', 'type' => 'somevalue']);
expect($messages->count())->equals(1);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['type']);
$messages = $validation->validate(['name' => 'SomeValue', 'type' => 'SomeValue']);
expect($messages->count())->equals(2);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['name']);
expect($messages->offsetGet(1)->getMessage())->equals($validationMessages['type']);
});
}
/**
* Tests exclusion in validator with multiple field and multiple domain
*
* @author Wojciech Ślawski <*****@*****.**>
* @since 2016-06-05
*/
public function testMultipleFieldMultipleDomain()
{
$this->specify('Test exclusion in validator with multiple field and single domain.', function () {
$validation = new Validation();
$validationMessages = ['type' => 'Type cant be mechanic or cyborg.', 'anotherType' => 'AnotherType cant by mechanic or hydraulic.'];
$validation->add(['type', 'anotherType'], new ExclusionIn(['domain' => ['type' => ['mechanic', 'cyborg'], 'anotherType' => ['mechanic', 'hydraulic']], 'message' => $validationMessages]));
$messages = $validation->validate(['type' => 'hydraulic', 'anotherType' => 'cyborg']);
expect($messages->count())->equals(0);
$messages = $validation->validate(['type' => 'cyborg', 'anotherType' => 'cyborg']);
expect($messages->count())->equals(1);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['type']);
$messages = $validation->validate(['type' => 'hydraulic', 'anotherType' => 'mechanic']);
expect($messages->count())->equals(1);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['anotherType']);
$messages = $validation->validate(['type' => 'cyborg', 'anotherType' => 'mechanic']);
expect($messages->count())->equals(2);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['type']);
expect($messages->offsetGet(1)->getMessage())->equals($validationMessages['anotherType']);
});
}
public function testShouldValidateUsingDigitsInDecimalValidation()
{
$validation = new Validation();
$validation->add('number1', new Decimal(['places' => 2, 'digits' => 2, 'label' => 'Magic number #1', 'message' => ':field must contain valid decimal value']));
$validation->add('number2', new Decimal(['places' => 2, 'digits' => 1, 'label' => 'Magic number #2', 'message' => ':field must contain valid decimal value']));
$validation->validate(['number1' => '9.99', 'number2' => '6.99']);
$messages = $validation->getMessages();
$this->assertEquals(1, $messages->count());
$this->assertEquals('Magic number #1 must contain valid decimal value', $messages[0]->getMessage());
$this->assertEquals('Decimal', $messages[0]->getType());
}
/**
* Tests presence of validator with multiple field
*
* @author Wojciech Ślawski <*****@*****.**>
* @since 2016-06-05
*/
public function testMultipleField()
{
$this->specify('Test presence of validator with multiple field.', function () {
$validation = new Validation();
$validationMessages = ['name' => 'Name cant be empty.', 'type' => 'Type cant be empty.'];
$validation->add(['name', 'type'], new PresenceOf(['message' => $validationMessages]));
$messages = $validation->validate(['name' => 'SomeValue', 'type' => 'SomeValue']);
expect($messages->count())->equals(0);
$messages = $validation->validate(['name' => '', 'type' => 'SomeValue']);
expect($messages->count())->equals(1);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['name']);
$expectedMessages = Group::__set_state(['_messages' => [Message::__set_state(['_type' => 'PresenceOf', '_message' => 'Name cant be empty.', '_field' => 'name', '_code' => '0'])]]);
expect($messages)->equals($expectedMessages);
$messages = $validation->validate(['name' => '', 'type' => '']);
expect($messages->count())->equals(2);
expect($messages->offsetGet(0)->getMessage())->equals($validationMessages['name']);
expect($messages->offsetGet(1)->getMessage())->equals($validationMessages['type']);
$expectedMessages = Group::__set_state(['_messages' => [Message::__set_state(['_type' => 'PresenceOf', '_message' => 'Name cant be empty.', '_field' => 'name', '_code' => '0']), Message::__set_state(['_type' => 'PresenceOf', '_message' => 'Type cant be empty.', '_field' => 'type', '_code' => '0'])]]);
expect($messages)->equals($expectedMessages);
});
}
/**
* Tests string length validator with multiple field and min, max
*
* @author Wojciech Ślawski <*****@*****.**>
* @since 2016-06-05
*/
public function testMultipleFieldMultipleMinMax()
{
$this->specify('Test string length with multiple field and min, max.', function () {
$validation = new Validation();
$validationMinimumMessages = ['name' => 'Name length must be minimum 0.', 'type' => 'Type length must be minimum 0.'];
$validationMaximumMessages = ['name' => 'Name length must be maximum 9.', 'type' => 'Type length must be maximum 4.'];
$validation->add(['name', 'type'], new Validation\Validator\StringLength(['min' => ['name' => 0, 'type' => 0], 'max' => ['name' => 9, 'type' => 4], 'messageMinimum' => $validationMinimumMessages, 'messageMaximum' => $validationMaximumMessages]));
$messages = $validation->validate(['name' => 'SomeValue', 'type' => 'Some']);
expect($messages->count())->equals(0);
$messages = $validation->validate(['name' => 'SomeValue123', 'type' => 'Some']);
expect($messages->count())->equals(1);
expect($messages->offsetGet(0)->getMessage())->equals($validationMaximumMessages['name']);
$messages = $validation->validate(['name' => 'SomeValue', 'type' => 'SomeValue']);
expect($messages->count())->equals(1);
expect($messages->offsetGet(0)->getMessage())->equals($validationMaximumMessages['type']);
$messages = $validation->validate(['name' => 'SomeValue123', 'type' => 'SomeValue']);
expect($messages->count())->equals(2);
expect($messages->offsetGet(0)->getMessage())->equals($validationMaximumMessages['name']);
expect($messages->offsetGet(1)->getMessage())->equals($validationMaximumMessages['type']);
});
}
public function validate($data = null, $entity = null)
{
$message = parent::validate($data, $entity);
if (0 != count($message)) {
return $message;
}
if (!empty($data['email'])) {
if (!filter_var($data['email'], FILTER_VALIDATE_EMAIL)) {
$this->appendMessage(new Message('The e-mail is not valid', 'email', 'Inclusion'));
}
}
return $this->getMessages();
}
protected function checkNamespace($namespace)
{
$validation = new Validation();
$validation->add('namespace', new Namespaces(['allowEmpty' => true]));
$messages = $validation->validate(['namespace' => $namespace]);
if (count($messages)) {
$errors = [];
foreach ($messages as $message) {
$errors[] = $message->getMessage();
}
throw new BuilderException(sprintf('%s', implode(PHP_EOL, $errors)));
}
return true;
}
