tests/Zend/Loader/AutoloaderTest.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_Loader
  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_Loader_AutoloaderTest::main');
  25 }
  26
  27 /**
  28  * Test helper
  29  */
  30 require_once dirname(__FILE__) . '/../../TestHelper.php';
  31
  32 /**
  33  * @see Zend_Loader_Autoloader
  34  */
  35 require_once 'Zend/Loader/Autoloader.php';
  36
  37 /**
  38  * @see Zend_Loader_Autoloader_Interface
  39  */
  40 require_once 'Zend/Loader/Autoloader/Interface.php';
  41
  42 /**
  43  * @category   Zend
  44  * @package    Zend_Loader
  45  * @subpackage UnitTests
  46  * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  47  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  48  * @group      Zend_Loader
  49  */
  50 class Zend_Loader_AutoloaderTest extends PHPUnit_Framework_TestCase
  51 {
  52     public static function main()
  53     {
  54         $suite  = new PHPUnit_Framework_TestSuite(__CLASS__);
  55         $result = PHPUnit_TextUI_TestRunner::run($suite);
  56     }
  57
  58     public function setUp()
  59     {
  60         // Store original autoloaders
  61         $this->loaders = spl_autoload_functions();
  62         if (!is_array($this->loaders)) {
  63             // spl_autoload_functions does not return empty array when no
  64             // autoloaders registered...
  65             $this->loaders = array();
  66         }
  67
  68         // Store original include_path
  69         $this->includePath = get_include_path();
  70
  71         Zend_Loader_Autoloader::resetInstance();
  72         $this->autoloader = Zend_Loader_Autoloader::getInstance();
  73
  74         // initialize 'error' member for tests that utilize error handling
  75         $this->error = null;
  76     }
  77
  78     public function tearDown()
  79     {
  80         // Restore original autoloaders
  81         $loaders = spl_autoload_functions();
  82         foreach ($loaders as $loader) {
  83             spl_autoload_unregister($loader);
  84         }
  85
  86         foreach ($this->loaders as $loader) {
  87             spl_autoload_register($loader);
  88         }
  89
  90         // Retore original include_path
  91         set_include_path($this->includePath);
  92
  93         // Reset autoloader instance so it doesn't affect other tests
  94         Zend_Loader_Autoloader::resetInstance();
  95     }
  96
  97     public function testAutoloaderShouldBeSingleton()
  98     {
  99         $autoloader = Zend_Loader_Autoloader::getInstance();
 100         $this->assertSame($this->autoloader, $autoloader);
 101     }
 102
 103     public function testSingletonInstanceShouldAllowReset()
 104     {
 105         Zend_Loader_Autoloader::resetInstance();
 106         $autoloader = Zend_Loader_Autoloader::getInstance();
 107         $this->assertNotSame($this->autoloader, $autoloader);
 108     }
 109
 110     public function testAutoloaderShouldRegisterItselfWithSplAutoloader()
 111     {
 112         $autoloaders = spl_autoload_functions();
 113         $found = false;
 114         foreach ($autoloaders as $loader) {
 115             if (is_array($loader)) {
 116                 if (('autoload' == $loader[1]) && ($loader[0] === get_class($this->autoloader))) {
 117                     $found = true;
 118                     break;
 119                 }
 120             }
 121         }
 122         $this->assertTrue($found, 'Autoloader instance not found in spl_autoload stack: ' . var_export($autoloaders, 1));
 123     }
 124
 125     public function testDefaultAutoloaderShouldBeZendLoader()
 126     {
 127         $this->assertSame(array('Zend_Loader', 'loadClass'), $this->autoloader->getDefaultAutoloader());
 128     }
 129
 130     public function testDefaultAutoloaderShouldBeMutable()
 131     {
 132         $this->autoloader->setDefaultAutoloader(array($this, 'autoload'));
 133         $this->assertSame(array($this, 'autoload'), $this->autoloader->getDefaultAutoloader());
 134     }
 135
 136     /**
 137      * @expectedException Zend_Loader_Exception
 138      */
 139     public function testSpecifyingInvalidDefaultAutoloaderShouldRaiseException()
 140     {
 141         $this->autoloader->setDefaultAutoloader(uniqid());
 142     }
 143
 144     public function testZfNamespacesShouldBeRegisteredByDefault()
 145     {
 146         $namespaces = $this->autoloader->getRegisteredNamespaces();
 147         $this->assertContains('Zend_', $namespaces);
 148         $this->assertContains('ZendX_', $namespaces);
 149     }
 150
 151     public function testAutoloaderShouldAllowRegisteringArbitraryNamespaces()
 152     {
 153         $this->autoloader->registerNamespace('Phly_');
 154         $namespaces = $this->autoloader->getRegisteredNamespaces();
 155         $this->assertContains('Phly_', $namespaces);
 156     }
 157
 158     public function testAutoloaderShouldAllowRegisteringMultipleNamespacesAtOnce()
 159     {
 160         $this->autoloader->registerNamespace(array('Phly_', 'Solar_'));
 161         $namespaces = $this->autoloader->getRegisteredNamespaces();
 162         $this->assertContains('Phly_', $namespaces);
 163         $this->assertContains('Solar_', $namespaces);
 164     }
 165
 166     /**
 167      * @expectedException Zend_Loader_Exception
 168      */
 169     public function testRegisteringInvalidNamespaceSpecShouldRaiseException()
 170     {
 171         $o = new stdClass;
 172         $this->autoloader->registerNamespace($o);
 173     }
 174
 175     public function testAutoloaderShouldAllowUnregisteringNamespaces()
 176     {
 177         $this->autoloader->unregisterNamespace('Zend');
 178         $namespaces = $this->autoloader->getRegisteredNamespaces();
 179         $this->assertNotContains('Zend', $namespaces);
 180     }
 181
 182     public function testAutoloaderShouldAllowUnregisteringMultipleNamespacesAtOnce()
 183     {
 184         $this->autoloader->unregisterNamespace(array('Zend', 'ZendX'));
 185         $namespaces = $this->autoloader->getRegisteredNamespaces();
 186         $this->assertNotContains('Zend', $namespaces);
 187         $this->assertNotContains('ZendX', $namespaces);
 188     }
 189
 190     /**
 191      * @expectedException Zend_Loader_Exception
 192      */
 193     public function testUnregisteringInvalidNamespaceSpecShouldRaiseException()
 194     {
 195         $o = new stdClass;
 196         $this->autoloader->unregisterNamespace($o);
 197     }
 198
 199     /**
 200      * @group ZF-6536
 201      */
 202     public function testWarningSuppressionShouldBeDisabledByDefault()
 203     {
 204         $this->assertFalse($this->autoloader->suppressNotFoundWarnings());
 205     }
 206
 207     public function testAutoloaderSuppressNotFoundWarningsFlagShouldBeMutable()
 208     {
 209         $this->autoloader->suppressNotFoundWarnings(true);
 210         $this->assertTrue($this->autoloader->suppressNotFoundWarnings());
 211     }
 212
 213     public function testFallbackAutoloaderFlagShouldBeOffByDefault()
 214     {
 215         $this->assertFalse($this->autoloader->isFallbackAutoloader());
 216     }
 217
 218     public function testFallbackAutoloaderFlagShouldBeMutable()
 219     {
 220         $this->autoloader->setFallbackAutoloader(true);
 221         $this->assertTrue($this->autoloader->isFallbackAutoloader());
 222     }
 223
 224     public function testUnshiftAutoloaderShouldAddToTopOfAutoloaderStack()
 225     {
 226         $this->autoloader->unshiftAutoloader('require');
 227         $autoloaders = $this->autoloader->getAutoloaders();
 228         $test = array_shift($autoloaders);
 229         $this->assertEquals('require', $test);
 230     }
 231
 232     public function testUnshiftAutoloaderWithoutNamespaceShouldRegisterAsEmptyNamespace()
 233     {
 234         $this->autoloader->unshiftAutoloader('require');
 235         $autoloaders = $this->autoloader->getNamespaceAutoloaders('');
 236         $test = array_shift($autoloaders);
 237         $this->assertEquals('require', $test);
 238     }
 239
 240     public function testUnshiftAutoloaderShouldAllowSpecifyingSingleNamespace()
 241     {
 242         $this->autoloader->unshiftAutoloader('require', 'Foo');
 243         $autoloaders = $this->autoloader->getNamespaceAutoloaders('Foo');
 244         $test = array_shift($autoloaders);
 245         $this->assertEquals('require', $test);
 246     }
 247
 248     public function testUnshiftAutoloaderShouldAllowSpecifyingMultipleNamespaces()
 249     {
 250         $this->autoloader->unshiftAutoloader('require', array('Foo', 'Bar'));
 251
 252         $autoloaders = $this->autoloader->getNamespaceAutoloaders('Foo');
 253         $test = array_shift($autoloaders);
 254         $this->assertEquals('require', $test);
 255
 256         $autoloaders = $this->autoloader->getNamespaceAutoloaders('Bar');
 257         $test = array_shift($autoloaders);
 258         $this->assertEquals('require', $test);
 259     }
 260
 261     public function testPushAutoloaderShouldAddToEndOfAutoloaderStack()
 262     {
 263         $this->autoloader->pushAutoloader('require');
 264         $autoloaders = $this->autoloader->getAutoloaders();
 265         $test = array_pop($autoloaders);
 266         $this->assertEquals('require', $test);
 267     }
 268
 269     public function testPushAutoloaderWithoutNamespaceShouldRegisterAsEmptyNamespace()
 270     {
 271         $this->autoloader->pushAutoloader('require');
 272         $autoloaders = $this->autoloader->getNamespaceAutoloaders('');
 273         $test = array_pop($autoloaders);
 274         $this->assertEquals('require', $test);
 275     }
 276
 277     public function testPushAutoloaderShouldAllowSpecifyingSingleNamespace()
 278     {
 279         $this->autoloader->pushAutoloader('require', 'Foo');
 280         $autoloaders = $this->autoloader->getNamespaceAutoloaders('Foo');
 281         $test = array_pop($autoloaders);
 282         $this->assertEquals('require', $test);
 283     }
 284
 285     public function testPushAutoloaderShouldAllowSpecifyingMultipleNamespaces()
 286     {
 287         $this->autoloader->pushAutoloader('require', array('Foo', 'Bar'));
 288
 289         $autoloaders = $this->autoloader->getNamespaceAutoloaders('Foo');
 290         $test = array_pop($autoloaders);
 291         $this->assertEquals('require', $test);
 292
 293         $autoloaders = $this->autoloader->getNamespaceAutoloaders('Bar');
 294         $test = array_pop($autoloaders);
 295         $this->assertEquals('require', $test);
 296     }
 297
 298     public function testAutoloaderShouldAllowRemovingConcreteAutoloadersFromStackByCallback()
 299     {
 300         $this->autoloader->pushAutoloader('require');
 301         $this->autoloader->removeAutoloader('require');
 302         $autoloaders = $this->autoloader->getAutoloaders();
 303         $this->assertNotContains('require', $autoloaders);
 304     }
 305
 306     public function testRemovingAutoloaderShouldAlsoRemoveAutoloaderFromNamespacedAutoloaders()
 307     {
 308         $this->autoloader->pushAutoloader('require', array('Foo', 'Bar'))
 309                          ->pushAutoloader('include');
 310         $this->autoloader->removeAutoloader('require');
 311         $test = $this->autoloader->getNamespaceAutoloaders('Foo');
 312         $this->assertTrue(empty($test));
 313         $test = $this->autoloader->getNamespaceAutoloaders('Bar');
 314         $this->assertTrue(empty($test));
 315     }
 316
 317     public function testAutoloaderShouldAllowRemovingCallbackFromSpecifiedNamespaces()
 318     {
 319         $this->autoloader->pushAutoloader('require', array('Foo', 'Bar'))
 320                          ->pushAutoloader('include');
 321         $this->autoloader->removeAutoloader('require', 'Foo');
 322         $test = $this->autoloader->getNamespaceAutoloaders('Foo');
 323         $this->assertTrue(empty($test));
 324         $test = $this->autoloader->getNamespaceAutoloaders('Bar');
 325         $this->assertFalse(empty($test));
 326     }
 327
 328     public function testAutoloadShouldReturnFalseWhenNamespaceIsNotRegistered()
 329     {
 330         $this->assertFalse(Zend_Loader_Autoloader::autoload('Foo_Bar'));
 331     }
 332
 333     public function testAutoloadShouldReturnFalseWhenNamespaceIsNotRegisteredButClassfileExists()
 334     {
 335         $this->addTestIncludePath();
 336         $this->assertFalse(Zend_Loader_Autoloader::autoload('ZendLoaderAutoloader_Foo'));
 337     }
 338
 339     public function testAutoloadShouldLoadClassWhenNamespaceIsRegisteredAndClassfileExists()
 340     {
 341         $this->addTestIncludePath();
 342         $this->autoloader->registerNamespace('ZendLoaderAutoloader');
 343         $result = Zend_Loader_Autoloader::autoload('ZendLoaderAutoloader_Foo');
 344         $this->assertFalse($result === false);
 345         $this->assertTrue(class_exists('ZendLoaderAutoloader_Foo', false));
 346     }
 347
 348     public function testAutoloadShouldNotSuppressFileNotFoundWarningsWhenFlagIsDisabled()
 349     {
 350         $this->addTestIncludePath();
 351         $this->autoloader->suppressNotFoundWarnings(false);
 352         $this->autoloader->registerNamespace('ZendLoaderAutoloader');
 353         set_error_handler(array($this, 'handleErrors'));
 354         $this->assertFalse(Zend_Loader_Autoloader::autoload('ZendLoaderAutoloader_Bar'));
 355         restore_error_handler();
 356         $this->assertNotNull($this->error);
 357     }
 358
 359     public function testAutoloadShouldReturnTrueIfFunctionBasedAutoloaderMatchesAndReturnsNonFalseValue()
 360     {
 361         $this->autoloader->pushAutoloader('ZendLoaderAutoloader_Autoload');
 362         $this->assertTrue(Zend_Loader_Autoloader::autoload('ZendLoaderAutoloader_Foo_Bar'));
 363     }
 364
 365     public function testAutoloadShouldReturnTrueIfMethodBasedAutoloaderMatchesAndReturnsNonFalseValue()
 366     {
 367         $this->autoloader->pushAutoloader(array($this, 'autoload'));
 368         $this->assertTrue(Zend_Loader_Autoloader::autoload('ZendLoaderAutoloader_Foo_Bar'));
 369     }
 370
 371     public function testAutoloadShouldReturnTrueIfAutoloaderImplementationReturnsNonFalseValue()
 372     {
 373         $this->autoloader->pushAutoloader(new Zend_Loader_AutoloaderTest_Autoloader());
 374         $this->assertTrue(Zend_Loader_Autoloader::autoload('ZendLoaderAutoloader_Foo_Bar'));
 375     }
 376
 377     public function testUsingAlternateDefaultLoaderShouldOverrideUsageOfZendLoader()
 378     {
 379         $this->autoloader->setDefaultAutoloader(array($this, 'autoload'));
 380         $class = $this->autoloader->autoload('Zend_ThisClass_WilNever_Exist');
 381         $this->assertEquals('Zend_ThisClass_WilNever_Exist', $class);
 382         $this->assertFalse(class_exists($class, false));
 383     }
 384
 385     public function addTestIncludePath()
 386     {
 387         set_include_path(dirname(__FILE__) . '/_files/' . PATH_SEPARATOR . $this->includePath);
 388     }
 389
 390     public function handleErrors($errno, $errstr)
 391     {
 392         $this->error = $errstr;
 393     }
 394
 395     public function autoload($class)
 396     {
 397         return $class;
 398     }
 399 }
 400
 401 function ZendLoaderAutoloader_Autoload($class)
 402 {
 403     return $class;
 404 }
 405
 406 class Zend_Loader_AutoloaderTest_Autoloader implements Zend_Loader_Autoloader_Interface
 407 {
 408     public function autoload($class)
 409     {
 410         return $class;
 411     }
 412 }
 413
 414 if (PHPUnit_MAIN_METHOD == 'Zend_Loader_AutoloaderTest::main') {
 415     Zend_Loader_AutoloaderTest::main();
 416 }