TestFest - Respect\Validation 1.0

RespectValidation
O mais incrível mecanismo de validação já criado para PHP

Sobre
• Biblioteca de validação criada por Alexandre Gaigalas (Alganet)
• PHP 5.3+ e HHVM 3.3+
• Interface ﬂuente
• Mais de 100 regras de validação
• Mais de 175 mil instalações via Composer
• Média de 13 mil instalações por mês via Composer

• Obter dados via $_POST
• Validar se a chave “email” é um email válido
• Exibir mensagem de erro

Validator - Zend
use ZendInputFilterInput;
use ZendInputFilterInputFilter;
use ZendValidatorEmailAddress;
$email = new Input('email');
$email->getValidatorChain()
->attach(new EmailAddress());
$inputFilter = new InputFilter();
$inputFilter->add($email)
->setData($_POST);
if (!$inputFilter->isValid()) {
foreach ($inputFilter->getMessages() as $messages) {
echo current($messages);
break;
}
}

Validation - Illuminate
use IlluminateValidationFactory;
use SymfonyComponentTranslationTranslator;
$factory = new Factory(new Translator('en'));
$validator = $factory->make(
$_POST,
array('email' => 'required|email')
);
if ($validator->fails()) {
echo $validator->messages()->first();
}

Validator - Symfony
use SymfonyComponentValidatorValidation;
use SymfonyComponentValidatorConstraints as Assert;
$constraint = new AssertCollection(array(
'email' => new AssertEmail(),
));
$validator = Validation::createValidator();
$violations = $validator->validateValue($_POST, $constraint);
if (count($violations) > 0) {
echo $violations;
}

Validation - Respect
use RespectValidationValidator as v;
try {
v::key('email', v::email())->check($_POST);
} catch (Exception $exception) {
echo $exception->getMessage();
}

Método validate()
if (!v::email()->validate($input)) {
// ...
}

Método check()
try {
v::stringType()->length(2, 15)->check(0);
} catch (ValidationExceptionInterface $exception) {
echo $exception->getMainMessage();
}
// Resultado:
//
// 0 must be a string

Método check()
try {
v::stringType()->length(2, 15)->check('A');
} catch (ValidationExceptionInterface $exception) {
}
// Resultado:
//
// "A" must have a length between 2 and 15

Método assert()
try {
v::stringType()->length(2, 15)->assert(0);
} catch (NestedValidationExceptionInterface $exception) {
echo $exception->getFullMessage();
}
// Resultado:
//
// -All of the required rules must pass for 0
// |-0 must be a string
// -0 must have a length between 2 and 15

Não utilizar estáticos
use RespectValidationRules;
use RespectValidationValidator;
$validator = new Validator();
$validator->addRule(new RulesKey('email', new RulesEmail()));
$validator->assert($_POST);

Reutilizar cadeia de validação
$validator = v::stringType()->length(2, 15);
$validator->assert($input1);
$validator->check($input2);
if ($validator->validate($input3)) {
// ...
}
if ($validator($input4)) {
// ...
}

Obter as mensagens em formato
de array
try {
print_r($exception->getMessages());
}
// Resultado:
//
// Array
// (
// [0] => 0 must be a string
// [1] => 0 must have a length between 2 and 15
// )

Traduzir mensagens
try {
v::stringType()->length(2, 15)->check(0);
} catch (ValidationException $exception) {
$exception->setParam('translator', 'gettext');
// ...
}

Customizar mensagens1
try {
$messages = $exception->findMessages(array(
'stringType' => 'Valor precisa ser uma string',
'length' => 'Valor precisa conter de 2 a 15 caracteres',
));
print_r($messages);
}
// Resultado:
//
// Array
// (
// [stringType] => Valor precisa ser uma string
// [length] => Valor precisa conter de 2 a 15 caracteres
// )

Customizar mensagens2
try {
v::key('email', v::email())->assert(0);
$messages = $exception->findMessages(array(
'email' => ‘Você precisa fornecer um email válido'
));
print_r($messages);
}
// Resultado:
//
// Array
// (
// [email] => Você precisa fornecer um email válido
// )

Trabalhar com valores opcionais
v::optional(v::email())->validate(''); // true
v::optional(v::email())->validate(null); // true

Inverter uma regra
v::not(v::equals('foo'))->validate('bar'); //true
v::not(v::equals('foo'))->validate('foo'); //false

Utilizar minhas próprias regras
v::with('MyValidationRules');
v::myRule(); // Tenta carregar "MyValidationRulesMyRule" se existir

Regra: IntType
<?php
namespace RespectValidationRules;
class IntType extends AbstractRule
{
public function validate($input)
{
return is_int($input);
}
}

Teste unitário: IntTypeTest
namespace RespectValidationRules;
/**
* @group rule
* @covers RespectValidationRulesIntType
*/
class IntTypeTest extends PHPUnit_Framework_TestCase
{
}

Teste1: Sucesso
// ...
public function providerForValidIntType()
{
return array(
array(0),
array(123456),
array(PHP_INT_MAX),
array(PHP_INT_MAX * -1),
);
}
/**
* @dataProvider providerForValidIntType
*/
public function testShouldValidateInputWhenItIsAValidIntType($input)
{
$rule = new IntType();
$this->assertTrue($rule->validate($input));
}
// ...

Teste2: Falha
// ...
public function providerForInvalidIntType()
{
return array(
array('1'),
array(1.0),
array(PHP_INT_MAX + 1),
array(true),
);
}
/**
* @dataProvider providerForInvalidIntType
*/
public function testShouldInvalidateInputWhenItIsNotAValidIntType($input)
{
$this->assertFalse($rule->validate($input));
}
// ...

Exception: IntTypeException
namespace RespectValidationExceptions;
class IntTypeException extends ValidationException
{
public static $defaultTemplates = array(
self::MODE_DEFAULT => array(
self::STANDARD => '{{name}} must be an integer',
),
self::MODE_NEGATIVE => array(
self::STANDARD => '{{name}} must not be an integer',
),
);
}

Teste de integração: PHPT
--FILE--
<?php
require 'vendor/autoload.php';
// ..
?>
--EXPECTF--

Teste1: intType_1.phpt
--FILE--
<?php
v::intType()->assert(42);
v::intType()->check(1984);
?>
--EXPECTF--

--FILE--
<?php
use RespectValidationExceptionsIntTypeException;
try {
v::intType()->check('42');
} catch (IntTypeException $exception) {
}
?>
--EXPECTF--
"42" must be an integer

--FILE--
<?php
use RespectValidationExceptionsAllOfException;
try {
v::intType()->assert('1984');
} catch (AllOfException $exception) {
}
?>
--EXPECTF--
-"1984" must be an integer

--FILE--
<?php
use RespectValidationExceptionsIntTypeException;
try {
v::not(v::intType())->check(42);
} catch (IntTypeException $exception) {
}
?>
--EXPECTF--
42 must not be an integer

--FILE--
<?php
use RespectValidationExceptionsAllOfException;
try {
v::not(v::intType())->assert(1984);
} catch (AllOfException $exception) {
}
?>
--EXPECTF--
-1984 must not be an integer

/**
* @dataProvider providerForValidIntType
*/
public function testShouldValidateInputWhenItIsAValidIntType($input)
{
$this->assertTrue($rule->__invoke($input));
$this->assertTrue($rule->validate($input));
$this->assertTrue($rule->check($input));
$this->assertTrue($rule->assert($input))
}

/**
* @expectedException RespectValidationExceptionsIntTypeException
*/
{
$this->assertFalse($rule->check($input));
$this->assertFalse($rule->assert($input));
}

/**
* @expectedException RespectValidationExceptionsIntTypeException
*/
{
$this->assertFalse($rule->check($input));
}

TestFest - Respect\Validation 1.0

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie TestFest - Respect\Validation 1.0

Ähnlich wie TestFest - Respect\Validation 1.0 (20)

Mehr von Henrique Moody

Mehr von Henrique Moody (6)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

TestFest - Respect\Validation 1.0