tests/Zend/Filter/InflectorTest.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_Filter
  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 // Call Zend_Filter_InflectorTest::main() if this source file is executed directly.
  25 if (!defined('PHPUnit_MAIN_METHOD')) {
  26     define('PHPUnit_MAIN_METHOD', 'Zend_Filter_InflectorTest::main');
  27 }
  28
  29 /**
  30  * Test helper
  31  */
  32 require_once dirname(__FILE__) . '/../../TestHelper.php';
  33
  34 /**
  35  * @see Zend_Filter_Inflector
  36  */
  37 require_once 'Zend/Filter/Inflector.php';
  38
  39 /**
  40  * @see Zend_Config
  41  */
  42 require_once 'Zend/Config.php';
  43
  44
  45 /**
  46  * Test class for Zend_Filter_Inflector.
  47  *
  48  * @category   Zend
  49  * @package    Zend_Filter
  50  * @subpackage UnitTests
  51  * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  52  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  53  * @group      Zend_Filter
  54  */
  55 class Zend_Filter_InflectorTest extends PHPUnit_Framework_TestCase
  56 {
  57     /**
  58      * Runs the test methods of this class.
  59      *
  60      * @return void
  61      */
  62     public static function main()
  63     {
  64         $suite  = new PHPUnit_Framework_TestSuite('Zend_Filter_InflectorTest');
  65         $result = PHPUnit_TextUI_TestRunner::run($suite);
  66     }
  67
  68     /**
  69      * Sets up the fixture, for example, open a network connection.
  70      * This method is called before a test is executed.
  71      *
  72      * @return void
  73      */
  74     public function setUp()
  75     {
  76         $this->inflector = new Zend_Filter_Inflector();
  77         $this->loader    = $this->inflector->getPluginLoader();
  78     }
  79
  80     /**
  81      * Tears down the fixture, for example, close a network connection.
  82      * This method is called after a test is executed.
  83      *
  84      * @return void
  85      */
  86     public function tearDown()
  87     {
  88         $this->loader->clearPaths();
  89     }
  90
  91     public function testGetPluginLoaderReturnsLoaderByDefault()
  92     {
  93         $loader = $this->inflector->getPluginLoader();
  94         $this->assertTrue($loader instanceof Zend_Loader_PluginLoader_Interface);
  95         $paths = $loader->getPaths();
  96         $this->assertEquals(1, count($paths));
  97         $this->assertTrue(array_key_exists('Zend_Filter_', $paths));
  98     }
  99
 100     public function testSetPluginLoaderAllowsSettingAlternatePluginLoader()
 101     {
 102         $defaultLoader = $this->inflector->getPluginLoader();
 103         $loader = new Zend_Loader_PluginLoader();
 104         $this->inflector->setPluginLoader($loader);
 105         $receivedLoader = $this->inflector->getPluginLoader();
 106         $this->assertNotSame($defaultLoader, $receivedLoader);
 107         $this->assertSame($loader, $receivedLoader);
 108     }
 109
 110     public function testAddFilterPrefixPathAddsPathsToPluginLoader()
 111     {
 112         $this->inflector->addFilterPrefixPath('Foo_Bar', 'Zend/View/');
 113         $loader = $this->inflector->getPluginLoader();
 114         $paths  = $loader->getPaths();
 115         $this->assertTrue(array_key_exists('Foo_Bar_', $paths));
 116     }
 117
 118     public function testTargetAccessorsWork()
 119     {
 120         $this->inflector->setTarget('foo/:bar/:baz');
 121         $this->assertEquals('foo/:bar/:baz', $this->inflector->getTarget());
 122     }
 123
 124     public function testTargetInitiallyNull()
 125     {
 126         $this->assertNull($this->inflector->getTarget());
 127     }
 128
 129     public function testPassingTargetToConstructorSetsTarget()
 130     {
 131         $inflector = new Zend_Filter_Inflector('foo/:bar/:baz');
 132         $this->assertEquals('foo/:bar/:baz', $inflector->getTarget());
 133     }
 134
 135     public function testSetTargetByReferenceWorks()
 136     {
 137         $target = 'foo/:bar/:baz';
 138         $this->inflector->setTargetReference($target);
 139         $this->assertEquals('foo/:bar/:baz', $this->inflector->getTarget());
 140         $target .= '/:bat';
 141         $this->assertEquals('foo/:bar/:baz/:bat', $this->inflector->getTarget());
 142     }
 143
 144     public function testSetFilterRuleWithStringRuleCreatesRuleEntryAndFilterObject()
 145     {
 146         $rules = $this->inflector->getRules();
 147         $this->assertEquals(0, count($rules));
 148         $this->inflector->setFilterRule('controller', 'PregReplace');
 149         $rules = $this->inflector->getRules('controller');
 150         $this->assertEquals(1, count($rules));
 151         $filter = $rules[0];
 152         $this->assertTrue($filter instanceof Zend_Filter_Interface);
 153     }
 154
 155     public function testSetFilterRuleWithFilterObjectCreatesRuleEntryWithFilterObject()
 156     {
 157         $rules = $this->inflector->getRules();
 158         $this->assertEquals(0, count($rules));
 159         $filter = new Zend_Filter_PregReplace();
 160         $this->inflector->setFilterRule('controller', $filter);
 161         $rules = $this->inflector->getRules('controller');
 162         $this->assertEquals(1, count($rules));
 163         $received = $rules[0];
 164         $this->assertTrue($received instanceof Zend_Filter_Interface);
 165         $this->assertSame($filter, $received);
 166     }
 167
 168     public function testSetFilterRuleWithArrayOfRulesCreatesRuleEntries()
 169     {
 170         $rules = $this->inflector->getRules();
 171         $this->assertEquals(0, count($rules));
 172         $this->inflector->setFilterRule('controller', array('PregReplace', 'Alpha'));
 173         $rules = $this->inflector->getRules('controller');
 174         $this->assertEquals(2, count($rules));
 175         $this->assertTrue($rules[0] instanceof Zend_Filter_Interface);
 176         $this->assertTrue($rules[1] instanceof Zend_Filter_Interface);
 177     }
 178
 179     public function testAddFilterRuleAppendsRuleEntries()
 180     {
 181         $rules = $this->inflector->getRules();
 182         $this->assertEquals(0, count($rules));
 183         $this->inflector->setFilterRule('controller', 'PregReplace');
 184         $rules = $this->inflector->getRules('controller');
 185         $this->assertEquals(1, count($rules));
 186         $this->inflector->addFilterRule('controller', 'Alpha');
 187         $rules = $this->inflector->getRules('controller');
 188         $this->assertEquals(2, count($rules));
 189     }
 190
 191     public function testSetStaticRuleCreatesScalarRuleEntry()
 192     {
 193         $rules = $this->inflector->getRules();
 194         $this->assertEquals(0, count($rules));
 195         $this->inflector->setStaticRule('controller', 'foobar');
 196         $rules = $this->inflector->getRules('controller');
 197         $this->assertEquals('foobar', $rules);
 198     }
 199
 200     public function testSetStaticRuleMultipleTimesOverwritesEntry()
 201     {
 202         $rules = $this->inflector->getRules();
 203         $this->assertEquals(0, count($rules));
 204         $this->inflector->setStaticRule('controller', 'foobar');
 205         $rules = $this->inflector->getRules('controller');
 206         $this->assertEquals('foobar', $rules);
 207         $this->inflector->setStaticRule('controller', 'bazbat');
 208         $rules = $this->inflector->getRules('controller');
 209         $this->assertEquals('bazbat', $rules);
 210     }
 211
 212     public function testSetStaticRuleReferenceAllowsUpdatingRuleByReference()
 213     {
 214         $rule  = 'foobar';
 215         $rules = $this->inflector->getRules();
 216         $this->assertEquals(0, count($rules));
 217         $this->inflector->setStaticRuleReference('controller', $rule);
 218         $rules = $this->inflector->getRules('controller');
 219         $this->assertEquals('foobar', $rules);
 220         $rule .= '/baz';
 221         $rules = $this->inflector->getRules('controller');
 222         $this->assertEquals('foobar/baz', $rules);
 223     }
 224
 225     public function testAddRulesCreatesAppropriateRuleEntries()
 226     {
 227         $rules = $this->inflector->getRules();
 228         $this->assertEquals(0, count($rules));
 229         $this->inflector->addRules(array(
 230             ':controller' => array('PregReplace', 'Alpha'),
 231             'suffix'      => 'phtml',
 232         ));
 233         $rules = $this->inflector->getRules();
 234         $this->assertEquals(2, count($rules));
 235         $this->assertEquals(2, count($rules['controller']));
 236         $this->assertEquals('phtml', $rules['suffix']);
 237     }
 238
 239     public function testSetRulesCreatesAppropriateRuleEntries()
 240     {
 241         $this->inflector->setStaticRule('some-rules', 'some-value');
 242         $rules = $this->inflector->getRules();
 243         $this->assertEquals(1, count($rules));
 244         $this->inflector->setRules(array(
 245             ':controller' => array('PregReplace', 'Alpha'),
 246             'suffix'      => 'phtml',
 247         ));
 248         $rules = $this->inflector->getRules();
 249         $this->assertEquals(2, count($rules));
 250         $this->assertEquals(2, count($rules['controller']));
 251         $this->assertEquals('phtml', $rules['suffix']);
 252     }
 253
 254     public function testGetRule()
 255     {
 256         $this->inflector->setFilterRule(':controller', array('Alpha', 'StringToLower'));
 257         $this->assertTrue($this->inflector->getRule('controller', 1) instanceof Zend_Filter_StringToLower);
 258         $this->assertFalse($this->inflector->getRule('controller', 2));
 259     }
 260
 261     public function testFilterTransformsStringAccordingToRules()
 262     {
 263         $this->inflector->setTarget(':controller/:action.:suffix')
 264              ->addRules(array(
 265                  ':controller' => array('Word_CamelCaseToDash'),
 266                  ':action'     => array('Word_CamelCaseToDash'),
 267                  'suffix'      => 'phtml'
 268              ));
 269         $filtered = $this->inflector->filter(array(
 270             'controller' => 'FooBar',
 271             'action'     => 'bazBat'
 272         ));
 273         $this->assertEquals('Foo-Bar/baz-Bat.phtml', $filtered);
 274     }
 275
 276     public function testTargetReplacementIdentiferAccessorsWork()
 277     {
 278         $this->assertEquals(':', $this->inflector->getTargetReplacementIdentifier());
 279         $this->inflector->setTargetReplacementIdentifier('?=');
 280         $this->assertEquals('?=', $this->inflector->getTargetReplacementIdentifier());
 281     }
 282
 283     public function testTargetReplacementIdentiferWorksWhenInflected()
 284     {
 285         $this->inflector = new Zend_Filter_Inflector(
 286             '?=##controller/?=##action.?=##suffix',
 287             array(
 288                  ':controller' => array('Word_CamelCaseToDash'),
 289                  ':action'     => array('Word_CamelCaseToDash'),
 290                  'suffix'      => 'phtml'
 291                  ),
 292             null,
 293             '?=##'
 294             );
 295
 296         $filtered = $this->inflector->filter(array(
 297             'controller' => 'FooBar',
 298             'action'     => 'bazBat'
 299         ));
 300
 301         $this->assertEquals('Foo-Bar/baz-Bat.phtml', $filtered);
 302     }
 303
 304     public function testThrowTargetExceptionsAccessorsWork()
 305     {
 306         $this->assertEquals(':', $this->inflector->getTargetReplacementIdentifier());
 307         $this->inflector->setTargetReplacementIdentifier('?=');
 308         $this->assertEquals('?=', $this->inflector->getTargetReplacementIdentifier());
 309     }
 310
 311     public function testThrowTargetExceptionsOnAccessorsWork()
 312     {
 313         $this->assertTrue($this->inflector->isThrowTargetExceptionsOn());
 314         $this->inflector->setThrowTargetExceptionsOn(false);
 315         $this->assertFalse($this->inflector->isThrowTargetExceptionsOn());
 316     }
 317
 318     public function testTargetExceptionThrownWhenTargetSourceNotSatisfied()
 319     {
 320         $this->inflector = new Zend_Filter_Inflector(
 321             '?=##controller/?=##action.?=##suffix',
 322             array(
 323                  ':controller' => array('Word_CamelCaseToDash'),
 324                  ':action'     => array('Word_CamelCaseToDash'),
 325                  'suffix'      => 'phtml'
 326                  ),
 327             true,
 328             '?=##'
 329             );
 330
 331         try {
 332             $filtered = $this->inflector->filter(array('controller' => 'FooBar'));
 333             $this->fail('Exception was not thrown when it was suppose to be.');
 334         } catch (Exception $e) {
 335             $this->assertTrue($e instanceof Zend_Filter_Exception);
 336         }
 337     }
 338
 339     public function testTargetExceptionNotThrownOnIdentifierNotFollowedByCharacter()
 340     {
 341         $this->inflector = new Zend_Filter_Inflector(
 342             'e:\path\to\:controller\:action.:suffix',
 343             array(
 344                  ':controller' => array('Word_CamelCaseToDash', 'StringToLower'),
 345                  ':action'     => array('Word_CamelCaseToDash'),
 346                  'suffix'      => 'phtml'
 347                 ),
 348             true,
 349             ':'
 350             );
 351
 352         try {
 353             $filtered = $this->inflector->filter(array('controller' => 'FooBar', 'action' => 'MooToo'));
 354             $this->assertEquals($filtered, 'e:\path\to\foo-bar\Moo-Too.phtml');
 355         } catch (Exception $e) {
 356             $this->fail($e->getMessage());
 357         }
 358     }
 359
 360     public function getOptions()
 361     {
 362         $options = array(
 363             'target' => '$controller/$action.$suffix',
 364             'throwTargetExceptionsOn' => true,
 365             'targetReplacementIdentifier' => '$',
 366             'rules' => array(
 367                 ':controller' => array(
 368                     'rule1' => 'Word_CamelCaseToUnderscore',
 369                     'rule2' => 'StringToLower',
 370                 ),
 371                 ':action' => array(
 372                     'rule1' => 'Word_CamelCaseToDash',
 373                     'rule2' => 'StringToUpper',
 374                 ),
 375                 'suffix' => 'php'
 376             ),
 377             'filterPrefixPath' => array(
 378                 'Zend_View_Filter' => 'Zend/View/Filter/',
 379                 'Foo_Filter'       => 'foo/filters/'
 380             ),
 381         );
 382         return $options;
 383     }
 384
 385     public function getConfig()
 386     {
 387         $options = $this->getOptions();
 388         return new Zend_Config($options);
 389     }
 390
 391     protected function _testOptions($inflector)
 392     {
 393         $options = $this->getOptions();
 394         $loader  = $inflector->getPluginLoader();
 395         $this->assertEquals($options['target'], $inflector->getTarget());
 396
 397         $viewFilterPath = $loader->getPaths('Zend_View_Filter');
 398         $this->assertEquals($options['filterPrefixPath']['Zend_View_Filter'], $viewFilterPath[0]);
 399         $fooFilterPath = $loader->getPaths('Foo_Filter');
 400         $this->assertEquals($options['filterPrefixPath']['Foo_Filter'], $fooFilterPath[0]);
 401
 402         $this->assertTrue($inflector->isThrowTargetExceptionsOn());
 403
 404         $this->assertEquals($options['targetReplacementIdentifier'], $inflector->getTargetReplacementIdentifier());
 405
 406         $rules = $inflector->getRules();
 407         foreach (array_values($options['rules'][':controller']) as $key => $rule) {
 408             $class = get_class($rules['controller'][$key]);
 409             $this->assertContains($rule, $class);
 410         }
 411         foreach (array_values($options['rules'][':action']) as $key => $rule) {
 412             $class = get_class($rules['action'][$key]);
 413             $this->assertContains($rule, $class);
 414         }
 415         $this->assertEquals($options['rules']['suffix'], $rules['suffix']);
 416     }
 417
 418     public function testPassingConfigObjectToConstructorSetsStateAndRules()
 419     {
 420         $config = $this->getConfig();
 421         $inflector = new Zend_Filter_Inflector($config);
 422         $this->_testOptions($inflector);
 423     }
 424
 425     public function testSetConfigSetsStateAndRules()
 426     {
 427         $config = $this->getConfig();
 428         $inflector = new Zend_Filter_Inflector();
 429         $inflector->setConfig($config);
 430         $this->_testOptions($inflector);
 431     }
 432
 433     /**
 434      * Added str_replace('\\', '\\\\', ..) to all processedParts values to disable backreferences
 435      *
 436      * @issue ZF-2538 Zend_Filter_Inflector::filter() fails with all numeric folder on Windows
 437      */
 438     public function testCheckInflectorWithPregBackreferenceLikeParts()
 439     {
 440
 441         $this->inflector = new Zend_Filter_Inflector(
 442             ':moduleDir' . DIRECTORY_SEPARATOR . ':controller' . DIRECTORY_SEPARATOR . ':action.:suffix',
 443             array(
 444                 ':controller' => array('Word_CamelCaseToDash', 'StringToLower'),
 445                 ':action'     => array('Word_CamelCaseToDash'),
 446                 'suffix'      => 'phtml'
 447                 ),
 448             true,
 449             ':'
 450             );
 451
 452         $this->inflector->setStaticRule('moduleDir', 'C:\htdocs\public\cache\00\01\42\app\modules');
 453
 454         try {
 455             $filtered = $this->inflector->filter(array(
 456                 'controller' => 'FooBar',
 457                 'action' => 'MooToo'
 458                 ));
 459             $this->assertEquals($filtered, 'C:\htdocs\public\cache\00\01\42\app\modules' . DIRECTORY_SEPARATOR . 'foo-bar' . DIRECTORY_SEPARATOR . 'Moo-Too.phtml');
 460         } catch (Exception $e) {
 461             $this->fail($e->getMessage());
 462         }
 463     }
 464
 465     /**
 466      * @issue ZF-2522
 467      */
 468     public function testTestForFalseInConstructorParams()
 469     {
 470         $inflector = new Zend_Filter_Inflector('something', array(), false, false);
 471         $this->assertFalse($inflector->isThrowTargetExceptionsOn());
 472         $this->assertEquals($inflector->getTargetReplacementIdentifier(), ':');
 473
 474         $inflector = new Zend_Filter_Inflector('something', array(), false, '#');
 475         $this->assertEquals($inflector->getTargetReplacementIdentifier(), '#');
 476     }
 477
 478     /**
 479      * @issue ZF-2964
 480      */
 481     public function testNoInflectableTarget()
 482     {
 483         $inflector = new Zend_Filter_Inflector('abc');
 484         $inflector->addRules(array(':foo' => array()));
 485         $this->assertEquals($inflector->filter(array('fo' => 'bar')), 'abc');
 486     }
 487
 488     /**
 489      * @issue ZF-7544
 490      */
 491     public function testAddFilterRuleMultipleTimes()
 492     {
 493         $rules = $this->inflector->getRules();
 494         $this->assertEquals(0, count($rules));
 495         $this->inflector->setFilterRule('controller', 'PregReplace');
 496         $rules = $this->inflector->getRules('controller');
 497         $this->assertEquals(1, count($rules));
 498         $this->inflector->addFilterRule('controller', array('Alpha', 'StringToLower'));
 499         $rules = $this->inflector->getRules('controller');
 500         $this->assertEquals(3, count($rules));
 501         $this->_context = 'StringToLower';
 502         $this->inflector->setStaticRuleReference('context' , $this->_context);
 503         $this->inflector->addFilterRule('controller', array('Alpha', 'StringToLower'));
 504         $rules = $this->inflector->getRules('controller');
 505         $this->assertEquals(5, count($rules));
 506     }
 507
 508     /**
 509      * @group ZF-8997
 510      */
 511     public function testPassingArrayToConstructorSetsStateAndRules()
 512     {
 513         $options = $this->getOptions();
 514         $inflector = new Zend_Filter_Inflector($options);
 515         $this->_testOptions($inflector);
 516     }
 517
 518     /**
 519      * @group ZF-8997
 520      */
 521     public function testPassingArrayToSetConfigSetsStateAndRules()
 522     {
 523         $options = $this->getOptions();
 524         $inflector = new Zend_Filter_Inflector();
 525         $inflector->setOptions($options);
 526         $this->_testOptions($inflector);
 527     }
 528
 529     /**
 530      * @group ZF-8997
 531      */
 532     public function testPassingZendConfigObjectToConstructorSetsStateAndRules()
 533     {
 534         $config = $this->getConfig();
 535         $inflector = new Zend_Filter_Inflector($config);
 536         $this->_testOptions($inflector);
 537     }
 538
 539     /**
 540      * @group ZF-8997
 541      */
 542     public function testPassingZendConfigObjectToSetConfigSetsStateAndRules()
 543     {
 544         $config = $this->getConfig();
 545         $inflector = new Zend_Filter_Inflector();
 546         $inflector->setOptions($config);
 547         $this->_testOptions($inflector);
 548     }
 549 }
 550
 551 // Call Zend_Filter_InflectorTest::main() if this source file is executed directly.
 552 if (PHPUnit_MAIN_METHOD == 'Zend_Filter_InflectorTest::main') {
 553     Zend_Filter_InflectorTest::main();
 554 }