tests/Zend/Captcha/FigletTest.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_Captcha
  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 // Call Zend_Captcha_FigletTest::main() if this source file is executed directly.
  24 if (!defined("PHPUnit_MAIN_METHOD")) {
  25     define("PHPUnit_MAIN_METHOD", "Zend_Captcha_FigletTest::main");
  26 }
  27
  28 require_once dirname(__FILE__) . '/../../TestHelper.php';
  29
  30 require_once 'Zend/Form/Element/Captcha.php';
  31 require_once 'Zend/Captcha/Adapter.php';
  32 require_once 'Zend/Config.php';
  33
  34 /**
  35  * @category   Zend
  36  * @package    Zend_Captcha
  37  * @subpackage UnitTests
  38  * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  39  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  40  * @group      Zend_Captcha
  41  */
  42 class Zend_Captcha_FigletTest extends PHPUnit_Framework_TestCase
  43 {
  44     /**
  45      * Runs the test methods of this class.
  46      *
  47      * @return void
  48      */
  49     public static function main()
  50     {
  51         $suite  = new PHPUnit_Framework_TestSuite("Zend_Captcha_FigletTest");
  52         $result = PHPUnit_TextUI_TestRunner::run($suite);
  53     }
  54
  55     /**
  56      * Sets up the fixture, for example, open a network connection.
  57      * This method is called before a test is executed.
  58      *
  59      * @return void
  60      */
  61     public function setUp()
  62     {
  63         if (isset($this->word)) {
  64             unset($this->word);
  65         }
  66
  67         $this->element = new Zend_Form_Element_Captcha(
  68             'captchaF',
  69             array(
  70                 'captcha' => array(
  71                     'Figlet',
  72                     'sessionClass' => 'Zend_Captcha_FigletTest_SessionContainer'
  73                 )
  74             )
  75         );
  76         $this->captcha =  $this->element->getCaptcha();
  77     }
  78
  79     /**
  80      * Tears down the fixture, for example, close a network connection.
  81      * This method is called after a test is executed.
  82      *
  83      * @return void
  84      */
  85     public function tearDown()
  86     {
  87     }
  88
  89     public function testCaptchaAdapterCreated()
  90     {
  91         $this->assertTrue($this->element->getCaptcha() instanceof Zend_Captcha_Adapter);
  92     }
  93
  94     public function getView()
  95     {
  96         require_once 'Zend/View.php';
  97         $view = new Zend_View();
  98         $view->addHelperPath(dirname(__FILE__) . '/../../../../library/Zend/View/Helper');
  99         return $view;
 100     }
 101
 102     public function testCaptchaIsRendered()
 103     {
 104         $html = $this->element->render($this->getView());
 105         $this->assertContains($this->element->getName(), $html);
 106     }
 107
 108     public function testCaptchaHasIdAndInput()
 109     {
 110         $html = $this->element->render($this->getView());
 111         $expect = sprintf('type="hidden" name="%s\[id\]" value="%s"', $this->element->getName(), $this->captcha->getId());
 112         $this->assertRegexp("/<input[^>]*?$expect/", $html, $html);
 113         $expect = sprintf('type="text" name="%s\[input\]"', $this->element->getName());
 114         $this->assertRegexp("/<input[^>]*?$expect/", $html, $html);
 115     }
 116
 117     /*
 118      * @see ZF-8268
 119      * @group ZF-8268
 120      */
 121     public function testLabelIdIsCorrect()
 122     {
 123         require_once 'Zend/Form.php';
 124         $form = new Zend_Form();
 125         $form->setElementsBelongTo('comment');
 126         $this->element->setLabel("My Captcha");
 127         $form->addElement($this->element);
 128         $html = $form->render($this->getView());
 129         $expect = sprintf('for="comment-%s-input"', $this->element->getName());
 130         $this->assertRegexp("/<label [^>]*?$expect/", $html, $html);
 131     }
 132
 133     public function testTimeoutPopulatedByDefault()
 134     {
 135         $ttl = $this->captcha->getTimeout();
 136         $this->assertFalse(empty($ttl));
 137         $this->assertTrue(is_int($ttl));
 138     }
 139
 140     public function testCanSetTimeout()
 141     {
 142         $ttl = $this->captcha->getTimeout();
 143         $this->captcha->setTimeout(3600);
 144         $this->assertNotEquals($ttl, $this->captcha->getTimeout());
 145         $this->assertEquals(3600, $this->captcha->getTimeout());
 146     }
 147
 148     public function testGenerateReturnsId()
 149     {
 150         $id = $this->captcha->generate();
 151         $this->assertFalse(empty($id));
 152         $this->assertTrue(is_string($id));
 153         $this->id = $id;
 154     }
 155
 156     public function testGetWordReturnsWord()
 157     {
 158         $this->captcha->generate();
 159         $word = $this->captcha->getWord();
 160         $this->assertFalse(empty($word));
 161         $this->assertTrue(is_string($word));
 162         $this->assertTrue(strlen($word) == 8);
 163         $this->word = $word;
 164     }
 165
 166     public function testGetWordLength()
 167     {
 168         $this->captcha->setWordLen(4);
 169         $this->captcha->generate();
 170         $word = $this->captcha->getWord();
 171         $this->assertTrue(is_string($word));
 172         $this->assertTrue(strlen($word) == 4);
 173         $this->word = $word;
 174     }
 175
 176     public function testAdapterElementName()
 177     {
 178         $this->assertEquals($this->captcha->getName(),
 179                     $this->element->getName());
 180     }
 181
 182     public function testGenerateIsRandomised()
 183     {
 184         $id1 = $this->captcha->generate();
 185         $word1 = $this->captcha->getWord();
 186         $id2 = $this->captcha->generate();
 187         $word2 = $this->captcha->getWord();
 188
 189         $this->assertFalse(empty($id1));
 190         $this->assertFalse(empty($id2));
 191         $this->assertFalse($id1 == $id2);
 192         $this->assertFalse($word1 == $word2);
 193     }
 194
 195     public function testRenderSetsValue()
 196     {
 197         $this->testCaptchaIsRendered();
 198         $this->assertEquals($this->captcha->getId(),
 199                 $this->element->getValue());
 200     }
 201
 202     public function testLabelIsNull()
 203     {
 204         $this->assertNull($this->element->getLabel());
 205     }
 206
 207     public function testRenderInitializesSessionData()
 208     {
 209         $this->testCaptchaIsRendered();
 210         $session = $this->captcha->getSession();
 211         $this->assertEquals($this->captcha->getTimeout(), $session->setExpirationSeconds);
 212         $this->assertEquals(1, $session->setExpirationHops);
 213         $this->assertEquals($this->captcha->getWord(), $session->word);
 214     }
 215
 216     public function testWordValidates()
 217     {
 218         $this->testCaptchaIsRendered();
 219         $input = array($this->element->getName() => array("id" => $this->captcha->getId(), "input" => $this->captcha->getWord()));
 220         $this->assertTrue($this->element->isValid("", $input));
 221     }
 222
 223     public function testMissingNotValid()
 224     {
 225         $this->testCaptchaIsRendered();
 226         $this->assertFalse($this->element->isValid("", array()));
 227         $input = array($this->element->getName() => array("input" => "blah"));
 228         $this->assertFalse($this->element->isValid("", $input));
 229     }
 230
 231     public function testWrongWordNotValid()
 232     {
 233         $this->testCaptchaIsRendered();
 234         $input = array($this->element->getName() => array("id" => $this->captcha->getId(), "input" => "blah"));
 235         $this->assertFalse($this->element->isValid("", $input));
 236     }
 237
 238     public function testUsesWordCaptchaDecoratorByDefault()
 239     {
 240         $this->assertEquals('Captcha_Word', $this->element->getCaptcha()->getDecorator());
 241     }
 242
 243     public function testCaptchaShouldBeConfigurableViaConfigObject()
 244     {
 245         $options = array(
 246             'name'         => 'foo',
 247             'sessionClass' => 'Zend_Captcha_FigletTest_SessionContainer',
 248             'wordLen'      => 6,
 249             'timeout'      => 300,
 250         );
 251         $config  = new Zend_Config($options);
 252         $captcha = new Zend_Captcha_Figlet($config);
 253         $test = $captcha->getOptions();
 254         $this->assertEquals($options, $test);
 255     }
 256
 257     public function testShouldAllowFigletsLargerThanFourteenCharacters()
 258     {
 259         $this->captcha->setName('foo')
 260                       ->setWordLen(14);
 261         $id = $this->captcha->generate();
 262     }
 263
 264     public function testShouldNotValidateEmptyInputAgainstEmptySession()
 265     {
 266         // Regression Test for ZF-4245
 267         $this->captcha->setName('foo')
 268                       ->setWordLen(6)
 269                       ->setTimeout(300);
 270         $id = $this->captcha->generate();
 271         // Unset the generated word
 272         // we have to reset $this->captcha for that
 273         $this->captcha->getSession()->word = null;
 274         $this->setUp();
 275         $this->captcha->setName('foo')
 276                       ->setWordLen(6)
 277                       ->setTimeout(300);
 278         $empty = array($this->captcha->getName() => array('id' => $id, 'input' => ''));
 279         $this->assertEquals(false, $this->captcha->isValid(null, $empty));
 280     }
 281
 282     /**
 283      * @group ZF-3995
 284      */
 285     public function testIsValidShouldAllowPassingArrayValueAndOmittingContext()
 286     {
 287         $this->testCaptchaIsRendered();
 288         $input = array($this->element->getName() => array("id" => $this->captcha->getId(), "input" => $this->captcha->getWord()));
 289         $this->assertTrue($this->element->isValid($input));
 290     }
 291
 292     /**
 293      * @group ZF-3995
 294      */
 295     public function testIsValidShouldNotRequireValueToBeNestedArray()
 296     {
 297         $this->testCaptchaIsRendered();
 298         $input = array("id" => $this->captcha->getId(), "input" => $this->captcha->getWord());
 299         $this->assertTrue($this->element->isValid($input));
 300     }
 301
 302     /**
 303      * @group ZF-5728
 304      */
 305     public function testSetSessionWorks()
 306     {
 307         if(headers_sent($file, $line)) {
 308             $this->markTestSkipped("Cannot use sessions because headers already sent");
 309         }
 310         require_once 'Zend/Session/Namespace.php';
 311         $session = new Zend_Session_Namespace('captcha');
 312         $this->captcha->setSession($session);
 313         $this->testCaptchaIsRendered();
 314         $input = array("id" => $this->captcha->getId(), "input" => $this->captcha->getWord());
 315         $this->assertTrue($this->element->isValid($input));
 316         $this->assertEquals($session->word, $this->captcha->getWord());
 317     }
 318 }
 319
 320 class Zend_Captcha_FigletTest_SessionContainer
 321 {
 322     protected static $_word;
 323
 324     public function __get($name)
 325     {
 326         if ('word' == $name) {
 327             return self::$_word;
 328         }
 329
 330         return null;
 331     }
 332
 333     public function __set($name, $value)
 334     {
 335         if ('word' == $name) {
 336             self::$_word = $value;
 337         } else {
 338             $this->$name = $value;
 339         }
 340     }
 341
 342     public function __isset($name)
 343     {
 344         if (('word' == $name) && (null !== self::$_word))  {
 345             return true;
 346         }
 347
 348         return false;
 349     }
 350
 351     public function __call($method, $args)
 352     {
 353         switch ($method) {
 354             case 'setExpirationHops':
 355             case 'setExpirationSeconds':
 356                 $this->$method = array_shift($args);
 357                 break;
 358             default:
 359         }
 360     }
 361 }
 362
 363 // Call Zend_Captcha_FigletTest::main() if this source file is executed directly.
 364 if (PHPUnit_MAIN_METHOD == "Zend_Captcha_FigletTest::main") {
 365     Zend_Captcha_FigletTest::main();
 366 }