tests/Zend/Validate/EmailAddressTest.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 if (!defined('PHPUnit_MAIN_METHOD')) {
  24     define('PHPUnit_MAIN_METHOD', 'Zend_Validate_EmailAddressTest::main');
  25 }
  26
  27 /**
  28  * Test helper
  29  */
  30 require_once dirname(__FILE__) . '/../../TestHelper.php';
  31
  32 /**
  33  * @see Zend_Validate_EmailAddress
  34  */
  35 require_once 'Zend/Validate/EmailAddress.php';
  36
  37 /**
  38  * @category   Zend
  39  * @package    Zend_Validate
  40  * @subpackage UnitTests
  41  * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  42  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  43  * @group      Zend_Validate
  44  */
  45 class Zend_Validate_EmailAddressTest extends PHPUnit_Framework_TestCase
  46 {
  47     /**
  48      * Default instance created for all test methods
  49      *
  50      * @var Zend_Validate_EmailAddress
  51      */
  52     protected $_validator;
  53
  54     /**
  55      * Runs this test suite
  56      *
  57      * @return void
  58      */
  59     public static function main()
  60     {
  61         $suite  = new PHPUnit_Framework_TestSuite(__CLASS__);
  62         $result = PHPUnit_TextUI_TestRunner::run($suite);
  63     }
  64
  65     /**
  66      * Creates a new Zend_Validate_EmailAddress object for each test method
  67      *
  68      * @return void
  69      */
  70     public function setUp()
  71     {
  72         $this->_validator = new Zend_Validate_EmailAddress();
  73     }
  74
  75     /**
  76      * Ensures that a basic valid e-mail address passes validation
  77      *
  78      * @return void
  79      */
  80     public function testBasic()
  81     {
  82         $this->assertTrue($this->_validator->isValid('username@example.com'));
  83     }
  84
  85     /**
  86      * Ensures that localhost address is valid
  87      *
  88      * @return void
  89      */
  90     public function testLocalhostAllowed()
  91     {
  92         $validator = new Zend_Validate_EmailAddress(Zend_Validate_Hostname::ALLOW_ALL);
  93         $this->assertTrue($validator->isValid('username@localhost'));
  94     }
  95
  96     /**
  97      * Ensures that local domain names are valid
  98      *
  99      * @return void
 100      */
 101     public function testLocaldomainAllowed()
 102     {
 103         $validator = new Zend_Validate_EmailAddress(Zend_Validate_Hostname::ALLOW_ALL);
 104         $this->assertTrue($validator->isValid('username@localhost.localdomain'));
 105     }
 106
 107     /**
 108      * Ensures that IP hostnames are valid
 109      *
 110      * @return void
 111      */
 112     public function testIPAllowed()
 113     {
 114         $validator = new Zend_Validate_EmailAddress(Zend_Validate_Hostname::ALLOW_DNS | Zend_Validate_Hostname::ALLOW_IP);
 115         $valuesExpected = array(
 116             array(Zend_Validate_Hostname::ALLOW_DNS, true, array('bob@212.212.20.4')),
 117             array(Zend_Validate_Hostname::ALLOW_DNS, false, array('bob@localhost'))
 118             );
 119         foreach ($valuesExpected as $element) {
 120             foreach ($element[2] as $input) {
 121                 $this->assertEquals($element[1], $validator->isValid($input), implode("\n", $validator->getMessages()));
 122             }
 123         }
 124     }
 125
 126     /**
 127      * Ensures that validation fails when the local part is missing
 128      *
 129      * @return void
 130      */
 131     public function testLocalPartMissing()
 132     {
 133         $this->assertFalse($this->_validator->isValid('@example.com'));
 134         $messages = $this->_validator->getMessages();
 135         $this->assertEquals(1, count($messages));
 136         $this->assertContains('local-part@hostname', current($messages));
 137     }
 138
 139     /**
 140      * Ensures that validation fails and produces the expected messages when the local part is invalid
 141      *
 142      * @return void
 143      */
 144     public function testLocalPartInvalid()
 145     {
 146         $this->assertFalse($this->_validator->isValid('Some User@example.com'));
 147
 148         $messages = $this->_validator->getMessages();
 149
 150         $this->assertEquals(3, count($messages));
 151
 152         $this->assertContains('Some User', current($messages));
 153         $this->assertContains('dot-atom', current($messages));
 154
 155         $this->assertContains('Some User', next($messages));
 156         $this->assertContains('quoted-string', current($messages));
 157
 158         $this->assertContains('Some User', next($messages));
 159         $this->assertContains('no valid local part', current($messages));
 160     }
 161
 162     /**
 163      * Ensures that no validation failure message is produced when the local part follows the quoted-string format
 164      *
 165      * @return void
 166      */
 167     public function testLocalPartQuotedString()
 168     {
 169         $this->assertTrue($this->_validator->isValid('"Some User"@example.com'));
 170
 171         $messages = $this->_validator->getMessages();
 172
 173         $this->assertType('array', $messages);
 174         $this->assertEquals(0, count($messages));
 175     }
 176
 177     /**
 178      * Ensures that validation fails when the hostname is invalid
 179      *
 180      * @return void
 181      */
 182     public function testHostnameInvalid()
 183     {
 184         $this->assertFalse($this->_validator->isValid('username@ example . com'));
 185         $messages = $this->_validator->getMessages();
 186         $this->assertThat(count($messages), $this->greaterThanOrEqual(1));
 187         $this->assertContains('no valid hostname', current($messages));
 188     }
 189
 190     /**
 191      * Ensures that quoted-string local part is considered valid
 192      *
 193      * @return void
 194      */
 195     public function testQuotedString()
 196     {
 197         $emailAddresses = array(
 198             '"username"@example.com',
 199             '"bob%jones"@domain.com',
 200             '"bob jones"@domain.com',
 201             '"bob@jones"@domain.com',
 202             '"[[ bob ]]"@domain.com',
 203             '"jones"@domain.com'
 204             );
 205         foreach ($emailAddresses as $input) {
 206             $this->assertTrue($this->_validator->isValid($input), "$input failed to pass validation:\n"
 207                             . implode("\n", $this->_validator->getMessages()));
 208         }
 209     }
 210
 211     /**
 212      * Ensures that validation fails when the e-mail is given as for display,
 213      * with angle brackets around the actual address
 214      *
 215      * @return void
 216      */
 217     public function testEmailDisplay()
 218     {
 219         $this->assertFalse($this->_validator->isValid('User Name <username@example.com>'));
 220         $messages = $this->_validator->getMessages();
 221         $this->assertThat(count($messages), $this->greaterThanOrEqual(3));
 222         $this->assertContains('no valid hostname', current($messages));
 223         $this->assertContains('cannot match TLD', next($messages));
 224         $this->assertContains('does not appear to be a valid local network name', next($messages));
 225     }
 226
 227     /**
 228      * Ensures that the validator follows expected behavior for valid email addresses
 229      *
 230      * @return void
 231      */
 232     public function testBasicValid()
 233     {
 234         $emailAddresses = array(
 235             'bob@domain.com',
 236             'bob.jones@domain.co.uk',
 237             'bob.jones.smythe@domain.co.uk',
 238             'BoB@domain.museum',
 239             'bobjones@domain.info',
 240             "B.O'Callaghan@domain.com",
 241             'bob+jones@domain.us',
 242             'bob+jones@domain.co.uk',
 243             'bob@some.domain.uk.com',
 244             'bob@verylongdomainsupercalifragilisticexpialidociousspoonfulofsugar.com'
 245             );
 246         foreach ($emailAddresses as $input) {
 247             $this->assertTrue($this->_validator->isValid($input), "$input failed to pass validation:\n"
 248                             . implode("\n", $this->_validator->getMessages()));
 249         }
 250     }
 251
 252     /**
 253      * Ensures that the validator follows expected behavior for invalid email addresses
 254      *
 255      * @return void
 256      */
 257     public function testBasicInvalid()
 258     {
 259         $emailAddresses = array(
 260             '',
 261             'bob
 262
 263             @domain.com',
 264             'bob jones@domain.com',
 265             '.bobJones@studio24.com',
 266             'bobJones.@studio24.com',
 267             'bob.Jones.@studio24.com',
 268             '"bob%jones@domain.com',
 269             'bob@verylongdomainsupercalifragilisticexpialidociousaspoonfulofsugar.com',
 270             'bob+domain.com',
 271             'bob.domain.com',
 272             'bob @domain.com',
 273             'bob@ domain.com',
 274             'bob @ domain.com',
 275             'Abc..123@example.com'
 276             );
 277         foreach ($emailAddresses as $input) {
 278             $this->assertFalse($this->_validator->isValid($input), implode("\n", $this->_validator->getMessages()) . $input);
 279         }
 280     }
 281
 282    /**
 283      * Ensures that the validator follows expected behavior for valid email addresses with complex local parts
 284      *
 285      * @return void
 286      */
 287     public function testComplexLocalValid()
 288     {
 289         $emailAddresses = array(
 290             'Bob.Jones@domain.com',
 291             'Bob.Jones!@domain.com',
 292             'Bob&Jones@domain.com',
 293             '/Bob.Jones@domain.com',
 294             '#Bob.Jones@domain.com',
 295             'Bob.Jones?@domain.com',
 296             'Bob~Jones@domain.com'
 297             );
 298         foreach ($emailAddresses as $input) {
 299             $this->assertTrue($this->_validator->isValid($input));
 300         }
 301     }
 302
 303
 304    /**
 305      * Ensures that the validator follows expected behavior for checking MX records
 306      *
 307      * @return void
 308      */
 309     public function testMXRecords()
 310     {
 311         if (!defined('TESTS_ZEND_VALIDATE_ONLINE_ENABLED')
 312             || !constant('TESTS_ZEND_VALIDATE_ONLINE_ENABLED')
 313         ) {
 314             $this->markTestSkipped('Testing MX records only works when a valid internet connection is available');
 315             return;
 316         }
 317
 318         $validator = new Zend_Validate_EmailAddress(Zend_Validate_Hostname::ALLOW_DNS, true);
 319
 320         // Are MX checks supported by this system?
 321         if (!$validator->validateMxSupported()) {
 322             $this->markTestSkipped('Testing MX records is not supported with this configuration');
 323             return;
 324         }
 325
 326         $valuesExpected = array(
 327             array(true, array('Bob.Jones@zend.com', 'Bob.Jones@php.net')),
 328             array(false, array('Bob.Jones@bad.example.com', 'Bob.Jones@anotherbad.example.com'))
 329             );
 330         foreach ($valuesExpected as $element) {
 331             foreach ($element[1] as $input) {
 332                 $this->assertEquals($element[0], $validator->isValid($input), implode("\n", $validator->getMessages()));
 333             }
 334         }
 335
 336         // Try a check via setting the option via a method
 337         unset($validator);
 338         $validator = new Zend_Validate_EmailAddress();
 339         $validator->setValidateMx(true);
 340         foreach ($valuesExpected as $element) {
 341             foreach ($element[1] as $input) {
 342                 $this->assertEquals($element[0], $validator->isValid($input), implode("\n", $validator->getMessages()));
 343             }
 344         }
 345     }
 346
 347    /**
 348      * Test changing hostname settings via EmailAddress object
 349      *
 350      * @return void
 351      */
 352     public function testHostnameSettings()
 353     {
 354         $validator = new Zend_Validate_EmailAddress();
 355
 356         // Check no IDN matching
 357         $validator->getHostnameValidator()->setValidateIdn(false);
 358         $valuesExpected = array(
 359             array(false, array('name@b�rger.de', 'name@h�llo.de', 'name@h�llo.se'))
 360             );
 361         foreach ($valuesExpected as $element) {
 362             foreach ($element[1] as $input) {
 363                 $this->assertEquals($element[0], $validator->isValid($input), implode("\n", $validator->getMessages()));
 364             }
 365         }
 366
 367         // Check no TLD matching
 368         $validator->getHostnameValidator()->setValidateTld(false);
 369         $valuesExpected = array(
 370             array(true, array('name@domain.xx', 'name@domain.zz', 'name@domain.madeup'))
 371             );
 372         foreach ($valuesExpected as $element) {
 373             foreach ($element[1] as $input) {
 374                 $this->assertEquals($element[0], $validator->isValid($input), implode("\n", $validator->getMessages()));
 375             }
 376         }
 377     }
 378
 379     /**
 380      * Ensures that getMessages() returns expected default value (an empty array)
 381      *
 382      * @return void
 383      */
 384     public function testGetMessages()
 385     {
 386         $this->assertEquals(array(), $this->_validator->getMessages());
 387     }
 388
 389     /**
 390      * @see ZF-2861
 391      */
 392     public function testHostnameValidatorMessagesShouldBeTranslated()
 393     {
 394         require_once 'Zend/Validate/Hostname.php';
 395         $hostnameValidator = new Zend_Validate_Hostname();
 396         require_once 'Zend/Translate.php';
 397         $translations = array(
 398             'hostnameIpAddressNotAllowed' => 'hostnameIpAddressNotAllowed translation',
 399             'hostnameUnknownTld' => 'hostnameUnknownTld translation',
 400             'hostnameDashCharacter' => 'hostnameDashCharacter translation',
 401             'hostnameInvalidHostnameSchema' => 'hostnameInvalidHostnameSchema translation',
 402             'hostnameUndecipherableTld' => 'hostnameUndecipherableTld translation',
 403             'hostnameInvalidHostname' => 'hostnameInvalidHostname translation',
 404             'hostnameInvalidLocalName' => 'hostnameInvalidLocalName translation',
 405             'hostnameLocalNameNotAllowed' => 'hostnameLocalNameNotAllowed translation',
 406         );
 407         $translator = new Zend_Translate('array', $translations);
 408         $this->_validator->setTranslator($translator)->setHostnameValidator($hostnameValidator);
 409
 410         $this->_validator->isValid('_XX.!!3xx@0.239,512.777');
 411         $messages = $hostnameValidator->getMessages();
 412         $found = false;
 413         foreach ($messages as $code => $message) {
 414             if (array_key_exists($code, $translations)) {
 415                 $this->assertEquals($translations[$code], $message);
 416                 $found = true;
 417                 break;
 418             }
 419         }
 420         $this->assertTrue($found);
 421     }
 422
 423     /**
 424      * @see ZF-4888
 425      */
 426     public function testEmailsExceedingLength()
 427     {
 428         $emailAddresses = array(
 429             'thislocalpathoftheemailadressislongerthantheallowedsizeof64characters@domain.com',
 430             'bob@verylongdomainsupercalifragilisticexpialidociousspoonfulofsugarverylongdomainsupercalifragilisticexpialidociousspoonfulofsugarverylongdomainsupercalifragilisticexpialidociousspoonfulofsugarverylongdomainsupercalifragilisticexpialidociousspoonfulofsugarexpialidociousspoonfulofsugar.com',
 431             );
 432         foreach ($emailAddresses as $input) {
 433             $this->assertFalse($this->_validator->isValid($input));
 434         }
 435     }
 436
 437     /**
 438      * @see ZF-4352
 439      */
 440     public function testNonStringValidation()
 441     {
 442         $this->assertFalse($this->_validator->isValid(array(1 => 1)));
 443     }
 444
 445     /**
 446      * @see ZF-7490
 447      */
 448     public function testSettingHostnameMessagesThroughEmailValidator()
 449     {
 450         $translations = array(
 451             'hostnameIpAddressNotAllowed' => 'hostnameIpAddressNotAllowed translation',
 452             'hostnameUnknownTld' => 'hostnameUnknownTld translation',
 453             'hostnameDashCharacter' => 'hostnameDashCharacter translation',
 454             'hostnameInvalidHostnameSchema' => 'hostnameInvalidHostnameSchema translation',
 455             'hostnameUndecipherableTld' => 'hostnameUndecipherableTld translation',
 456             'hostnameInvalidHostname' => 'hostnameInvalidHostname translation',
 457             'hostnameInvalidLocalName' => 'hostnameInvalidLocalName translation',
 458             'hostnameLocalNameNotAllowed' => 'hostnameLocalNameNotAllowed translation',
 459         );
 460
 461         $this->_validator->setMessages($translations);
 462         $this->_validator->isValid('_XX.!!3xx@0.239,512.777');
 463         $messages = $this->_validator->getMessages();
 464         $found = false;
 465         foreach ($messages as $code => $message) {
 466             if (array_key_exists($code, $translations)) {
 467                 $this->assertEquals($translations[$code], $message);
 468                 $found = true;
 469                 break;
 470             }
 471         }
 472
 473         $this->assertTrue($found);
 474     }
 475
 476     /**
 477      * Testing initializing with several options
 478      */
 479     public function testInstanceWithOldOptions()
 480     {
 481         $handler = set_error_handler(array($this, 'errorHandler'), E_USER_NOTICE);
 482         $validator = new Zend_Validate_EmailAddress();
 483         $options   = $validator->getOptions();
 484
 485         $this->assertEquals(Zend_Validate_Hostname::ALLOW_DNS, $options['allow']);
 486         $this->assertFalse($options['mx']);
 487
 488         try {
 489             $validator = new Zend_Validate_EmailAddress(Zend_Validate_Hostname::ALLOW_ALL, true, new Zend_Validate_Hostname(Zend_Validate_Hostname::ALLOW_ALL));
 490             $options   = $validator->getOptions();
 491
 492             $this->assertEquals(Zend_Validate_Hostname::ALLOW_ALL, $options['allow']);
 493             $this->assertTrue($options['mx']);
 494             set_error_handler($handler);
 495         } catch (Zend_Exception $e) {
 496             $this->markTestSkipped('MX not available on this system');
 497         }
 498     }
 499
 500     /**
 501      * Testing setOptions
 502      */
 503     public function testSetOptions()
 504     {
 505         $this->_validator->setOptions(array('messages' => array(Zend_Validate_EmailAddress::INVALID => 'TestMessage')));
 506         $messages = $this->_validator->getMessageTemplates();
 507         $this->assertEquals('TestMessage', $messages[Zend_Validate_EmailAddress::INVALID]);
 508
 509         $oldHostname = $this->_validator->getHostnameValidator();
 510         $this->_validator->setOptions(array('hostname' => new Zend_Validate_Hostname(Zend_Validate_Hostname::ALLOW_ALL)));
 511         $hostname = $this->_validator->getHostnameValidator();
 512         $this->assertNotEquals($oldHostname, $hostname);
 513     }
 514
 515     /**
 516      * Testing setMessage
 517      */
 518     public function testSetSingleMessage()
 519     {
 520         $messages = $this->_validator->getMessageTemplates();
 521         $this->assertNotEquals('TestMessage', $messages[Zend_Validate_EmailAddress::INVALID]);
 522         $this->_validator->setMessage('TestMessage');
 523         $messages = $this->_validator->getMessageTemplates();
 524         $this->assertEquals('TestMessage', $messages[Zend_Validate_EmailAddress::INVALID]);
 525     }
 526
 527     /**
 528      * Testing validateMxSupported
 529      */
 530     public function testValidateMxSupported()
 531     {
 532         if (function_exists('getmxrr')) {
 533             $this->assertTrue($this->_validator->validateMxSupported());
 534         } else {
 535             $this->assertFalse($this->_validator->validateMxSupported());
 536         }
 537     }
 538
 539     /**
 540      * Testing getValidateMx
 541      */
 542     public function testGetValidateMx()
 543     {
 544         $this->assertFalse($this->_validator->getValidateMx());
 545     }
 546
 547     /**
 548      * Testing getDeepMxCheck
 549      */
 550     public function testGetDeepMxCheck()
 551     {
 552         $this->assertFalse($this->_validator->getDeepMxCheck());
 553     }
 554
 555     /**
 556      * Testing getDomainCheck
 557      */
 558     public function testGetDomainCheck()
 559     {
 560         $this->assertTrue($this->_validator->getDomainCheck());
 561     }
 562
 563     public function errorHandler($errno, $errstr)
 564     {
 565         if (strstr($errstr, 'deprecated')) {
 566             $this->multipleOptionsDetected = true;
 567         }
 568     }
 569 }
 570
 571 if (PHPUnit_MAIN_METHOD == 'Zend_Validate_EmailAddressTest::main') {
 572     Zend_Validate_EmailAddressTest::main();
 573 }