tests/Zend/ValidateTest.php

   1 <?php
   2 /**
   3  * Zend Framework
   4  *
   5  * LICENSE
   6  *
   7  * This source file is subject to the new BSD license that is bundled
   8  * with this package in the file LICENSE.txt.
   9  * It is also available through the world-wide-web at this URL:
  10  * http://framework.zend.com/license/new-bsd
  11  * If you did not receive a copy of the license and are unable to
  12  * obtain it through the world-wide-web, please send an email
  13  * to license@zend.com so we can send you a copy immediately.
  14  *
  15  * @category   Zend
  16  * @package    Zend_Validate
  17  * @subpackage UnitTests
  18  * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  19  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  20  * @version    $Id$
  21  */
  22
  23 /**
  24  * Test helper
  25  */
  26 require_once dirname(__FILE__) . '/../TestHelper.php';
  27
  28 /**
  29  * @see Zend_Validate
  30  */
  31 require_once 'Zend/Validate.php';
  32
  33 /**
  34  * @see Zend_Validate_Abstract
  35  */
  36 require_once 'Zend/Validate/Abstract.php';
  37
  38 /**
  39  * @see Zend_Translate
  40  */
  41 require_once 'Zend/Translate.php';
  42
  43 /**
  44  * @category   Zend
  45  * @package    Zend_Validate
  46  * @subpackage UnitTests
  47  * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  48  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  49  * @group      Zend_Validate
  50  */
  51 class Zend_ValidateTest extends PHPUnit_Framework_TestCase
  52 {
  53     /**
  54      * Zend_Validate object
  55      *
  56      * @var Zend_Validate
  57      */
  58     protected $_validator;
  59
  60     /**
  61      * Creates a new Zend_Validate object for each test method
  62      *
  63      * @return void
  64      */
  65     public function setUp()
  66     {
  67         $this->_validator = new Zend_Validate();
  68     }
  69
  70     /**
  71      * Resets the default namespaces
  72      *
  73      * @return void
  74      */
  75     public function tearDown()
  76     {
  77         Zend_Validate::setDefaultNamespaces(array());
  78     }
  79
  80     /**
  81      * Ensures expected results from empty validator chain
  82      *
  83      * @return void
  84      */
  85     public function testEmpty()
  86     {
  87         $this->assertEquals(array(), $this->_validator->getMessages());
  88         $this->assertEquals(array(), $this->_validator->getErrors());
  89         $this->assertTrue($this->_validator->isValid('something'));
  90         $this->assertEquals(array(), $this->_validator->getErrors());
  91     }
  92
  93     /**
  94      * Ensures expected behavior from a validator known to succeed
  95      *
  96      * @return void
  97      */
  98     public function testTrue()
  99     {
 100         $this->_validator->addValidator(new Zend_ValidateTest_True());
 101         $this->assertTrue($this->_validator->isValid(null));
 102         $this->assertEquals(array(), $this->_validator->getMessages());
 103         $this->assertEquals(array(), $this->_validator->getErrors());
 104     }
 105
 106     /**
 107      * Ensures expected behavior from a validator known to fail
 108      *
 109      * @return void
 110      */
 111     public function testFalse()
 112     {
 113         $this->_validator->addValidator(new Zend_ValidateTest_False());
 114         $this->assertFalse($this->_validator->isValid(null));
 115         $this->assertEquals(array('error' => 'validation failed'), $this->_validator->getMessages());
 116     }
 117
 118     /**
 119      * Ensures that a validator may break the chain
 120      *
 121      * @return void
 122      */
 123     public function testBreakChainOnFailure()
 124     {
 125         $this->_validator->addValidator(new Zend_ValidateTest_False(), true)
 126                          ->addValidator(new Zend_ValidateTest_False());
 127         $this->assertFalse($this->_validator->isValid(null));
 128         $this->assertEquals(array('error' => 'validation failed'), $this->_validator->getMessages());
 129     }
 130
 131     /**
 132      * Ensures that we can call the static method is()
 133      * to instantiate a named validator by its class basename
 134      * and it returns the result of isValid() with the input.
 135      */
 136     public function testStaticFactory()
 137     {
 138         $this->assertTrue(Zend_Validate::is('1234', 'Digits'));
 139         $this->assertFalse(Zend_Validate::is('abc', 'Digits'));
 140     }
 141
 142     /**
 143      * Ensures that a validator with constructor arguments can be called
 144      * with the static method is().
 145      */
 146     public function testStaticFactoryWithConstructorArguments()
 147     {
 148         $this->assertTrue(Zend_Validate::is('12', 'Between', array('min' => 1, 'max' => 12)));
 149         $this->assertFalse(Zend_Validate::is('24', 'Between', array('min' => 1, 'max' => 12)));
 150     }
 151
 152     /**
 153      * Ensures that if we specify a validator class basename that doesn't
 154      * exist in the namespace, is() throws an exception.
 155      *
 156      * Refactored to conform with ZF-2724.
 157      *
 158      * @group  ZF-2724
 159      * @return void
 160      * @expectedException Zend_Validate_Exception
 161      */
 162     public function testStaticFactoryClassNotFound()
 163     {
 164         Zend_Validate::is('1234', 'UnknownValidator');
 165     }
 166
 167     /**
 168      * Testing Namespaces
 169      *
 170      * @return void
 171      */
 172     public function testNamespaces()
 173     {
 174         $this->assertEquals(array(), Zend_Validate::getDefaultNamespaces());
 175         $this->assertFalse(Zend_Validate::hasDefaultNamespaces());
 176
 177         Zend_Validate::setDefaultNamespaces('TestDir');
 178         $this->assertEquals(array('TestDir'), Zend_Validate::getDefaultNamespaces());
 179
 180         Zend_Validate::setDefaultNamespaces('OtherTestDir');
 181         $this->assertEquals(array('OtherTestDir'), Zend_Validate::getDefaultNamespaces());
 182
 183         $this->assertTrue(Zend_Validate::hasDefaultNamespaces());
 184
 185         Zend_Validate::setDefaultNamespaces(array());
 186
 187         $this->assertEquals(array(), Zend_Validate::getDefaultNamespaces());
 188         $this->assertFalse(Zend_Validate::hasDefaultNamespaces());
 189
 190         Zend_Validate::addDefaultNamespaces(array('One', 'Two'));
 191         $this->assertEquals(array('One', 'Two'), Zend_Validate::getDefaultNamespaces());
 192
 193         Zend_Validate::addDefaultNamespaces('Three');
 194         $this->assertEquals(array('One', 'Two', 'Three'), Zend_Validate::getDefaultNamespaces());
 195
 196         Zend_Validate::setDefaultNamespaces(array());
 197     }
 198
 199     public function testIsValidWithParameters()
 200     {
 201         $this->assertTrue(Zend_Validate::is(5, 'Between', array(1, 10)));
 202         $this->assertTrue(Zend_Validate::is(5, 'Between', array('min' => 1, 'max' => 10)));
 203     }
 204
 205     public function testSetGetMessageLengthLimitation()
 206     {
 207         Zend_Validate::setMessageLength(5);
 208         $this->assertEquals(5, Zend_Validate::getMessageLength());
 209
 210         $valid = new Zend_Validate_Between(1, 10);
 211         $this->assertFalse($valid->isValid(24));
 212         $message = current($valid->getMessages());
 213         $this->assertTrue(strlen($message) <= 5);
 214     }
 215
 216     public function testSetGetDefaultTranslator()
 217     {
 218         set_error_handler(array($this, 'errorHandlerIgnore'));
 219         $translator = new Zend_Translate('array', array(), 'en');
 220         restore_error_handler();
 221         Zend_Validate_Abstract::setDefaultTranslator($translator);
 222         $this->assertSame($translator->getAdapter(), Zend_Validate_Abstract::getDefaultTranslator());
 223     }
 224
 225     /**
 226      * Handle file not found errors
 227      *
 228      * @group  ZF-2724
 229      * @param  int $errnum
 230      * @param  string $errstr
 231      * @return void
 232      */
 233     public function handleNotFoundError($errnum, $errstr)
 234     {
 235         if (strstr($errstr, 'No such file')) {
 236             $this->error = true;
 237         }
 238     }
 239
 240     /**
 241      * Ignores a raised PHP error when in effect, but throws a flag to indicate an error occurred
 242      *
 243      * @param  integer $errno
 244      * @param  string  $errstr
 245      * @param  string  $errfile
 246      * @param  integer $errline
 247      * @param  array   $errcontext
 248      * @return void
 249      */
 250     public function errorHandlerIgnore($errno, $errstr, $errfile, $errline, array $errcontext)
 251     {
 252         $this->_errorOccurred = true;
 253     }
 254 }
 255
 256
 257 /**
 258  * Validator to return true to any input.
 259  */
 260 class Zend_ValidateTest_True extends Zend_Validate_Abstract
 261 {
 262     public function isValid($value)
 263     {
 264         return true;
 265     }
 266 }
 267
 268
 269 /**
 270  * Validator to return false to any input.
 271  */
 272 class Zend_ValidateTest_False extends Zend_Validate_Abstract
 273 {
 274     public function isValid($value)
 275     {
 276         $this->_messages = array('error' => 'validation failed');
 277         return false;
 278     }
 279 }