testfest - respect\validation 1.0

$: TestFest - Respect\Validation 1.0$
Respect\ValidationO 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 fluente

• 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

Exemplo

• Obter dados via $_POST

• Validar se a chave “email” é um email válido

• Exibir mensagem de erro

Validator - Zenduse Zend\InputFilter\Input;use Zend\InputFilter\InputFilter;use Zend\Validator\EmailAddress;

$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 - Illuminateuse Illuminate\Validation\Factory;use Symfony\Component\Translation\Translator;

$factory = new Factory(new Translator('en'));$validator = $factory->make( $_POST, array('email' => 'required|email'));

if ($validator->fails()) { echo $validator->messages()->first();}

Validator - Symfonyuse Symfony\Component\Validator\Validation;use Symfony\Component\Validator\Constraints as Assert;

$constraint = new Assert\Collection(array( 'email' => new Assert\Email(),));

$validator = Validation::createValidator();$violations = $validator->validateValue($_POST, $constraint);if (count($violations) > 0) { echo $violations;}

Validation - Respectuse Respect\Validation\Validator as v;

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

Validando

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) { echo $exception->getMainMessage();}

// 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

E se eu quiser…

Não utilizar estáticosuse Respect\Validation\Rules;use Respect\Validation\Validator;

$validator = new Validator();$validator->addRule(new Rules\Key('email', new Rules\Email()));$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 { v::stringType()->length(2, 15)->assert(0);} catch (NestedValidationExceptionInterface $exception) { print_r($exception->getMessages());}

// Resultado://// Array// (// [0] => 0 must be a string// [1] => 0 must have a length between 2 and 15// )

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

Customizar mensagens1

try { v::stringType()->length(2, 15)->assert(0);} catch (NestedValidationExceptionInterface $exception) { $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);} catch (NestedValidationExceptionInterface $exception) { $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 opcionaisv::optional(v::email())->validate(''); // truev::optional(v::email())->validate(null); // true

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

Utilizar minhas próprias regrasv::with('My\\Validation\\Rules\\');v::myRule(); // Tenta carregar "My\Validation\Rules\MyRule" se existir

Como testar?

Regra: IntType<?php

namespace Respect\Validation\Rules;

class IntType extends AbstractRule{ public function validate($input) { return is_int($input); }}

Teste unitário: IntTypeTestnamespace Respect\Validation\Rules;

/** * @group rule * @covers Respect\Validation\Rules\IntType */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) { $rule = new IntType();

$this->assertFalse($rule->validate($input)); } // ...

Exception: IntTypeExceptionnamespace Respect\Validation\Exceptions;

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--<?phprequire 'vendor/autoload.php';

use Respect\Validation\Validator as v;

// ..?>--EXPECTF--

Teste1: intType_1.phpt--FILE--<?phprequire 'vendor/autoload.php';

use Respect\Validation\Validator as v;

v::intType()->assert(42);v::intType()->check(1984);?>--EXPECTF--


use Respect\Validation\Validator as v;use Respect\Validation\Exceptions\IntTypeException;

try { v::intType()->check('42');} catch (IntTypeException $exception) { echo $exception->getMainMessage();}?>--EXPECTF--"42" must be an integer


use Respect\Validation\Validator as v;use Respect\Validation\Exceptions\AllOfException;

try { v::intType()->assert('1984');} catch (AllOfException $exception) { echo $exception->getFullMessage();}?>--EXPECTF--\-"1984" must be an integer


use Respect\Validation\Validator as v;use Respect\Validation\Exceptions\IntTypeException;

try { v::not(v::intType())->check(42);} catch (IntTypeException $exception) { echo $exception->getMainMessage();}?>--EXPECTF--42 must not be an integer


use Respect\Validation\Validator as v;use Respect\Validation\Exceptions\AllOfException;

try { v::not(v::intType())->assert(1984);} catch (AllOfException $exception) { echo $exception->getFullMessage();}?>--EXPECTF--\-1984 must not be an integer

Como não testar?

/** * @dataProvider providerForValidIntType */ public function testShouldValidateInputWhenItIsAValidIntType($input) { $rule = new IntType();

$this->assertTrue($rule->__invoke($input)); $this->assertTrue($rule->validate($input)); $this->assertTrue($rule->check($input)); $this->assertTrue($rule->assert($input)) }

/** * @dataProvider providerForInvalidIntType * @expectedException Respect\Validation\Exceptions\IntTypeException */ public function testShouldInvalidateInputWhenItIsNotAValidIntType($input) { $rule = new IntType();

$this->assertFalse($rule->check($input)); $this->assertFalse($rule->assert($input)); }

/** * @dataProvider providerForInvalidIntType * @expectedException Respect\Validation\Exceptions\IntTypeException */ public function testShouldInvalidateInputWhenItIsNotAValidIntType($input) { $rule = new IntType();

$this->assertFalse($rule->check($input)); }

Let’s test!

testfest - respect\validation 1.0

Software