Subversion Repositories SmartDukaan

<?php

/**

 * CakeValidationSetTest file

 *

 * CakePHP(tm) Tests <http://book.cakephp.org/view/1196/Testing>

 * Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)

 *

 * Licensed under The MIT License

 * For full copyright and license information, please see the LICENSE.txt

 * Redistributions of files must retain the above copyright notice

 *

 * @copyright     Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)

 * @link          http://book.cakephp.org/view/1196/Testing CakePHP(tm) Tests

 * @package       Cake.Test.Case.Model.Validator

 * @since         CakePHP(tm) v 2.2.0

 * @license       http://www.opensource.org/licenses/mit-license.php MIT License

 */

App::uses('CakeValidationSet', 'Model/Validator');

/**

 * CakeValidationSetTest

 *

 * @package       Cake.Test.Case.Model.Validator

 */

class CakeValidationSetTest extends CakeTestCase {

/**

 * override locale to the default (eng).

 *

 * @return void

 */

	public function setUp() {

		parent::setUp();

		Configure::write('Config.language', 'eng');

	}

/**

 * testValidate method

 *

 * @return void

 */

	public function testValidate() {

		$Field = new CakeValidationSet('title', 'notEmpty');

		$data = array(

			'title' => '',

			'body' => 'a body'

		);

		$result = $Field->validate($data);

		$expected = array('This field cannot be left blank');

		$this->assertEquals($expected, $result);

		$Field = new CakeValidationSet('body', 'notEmpty');

		$result = $Field->validate($data);

		$this->assertEmpty($result);

		$Field = new CakeValidationSet('nothere', array(

			'notEmpty' => array(

				'rule' => 'notEmpty',

				'required' => true

			)

		));

		$result = $Field->validate($data);

		$expected = array('notEmpty');

		$this->assertEquals($expected, $result);

		$Field = new CakeValidationSet('body', array(

			'inList' => array(

				'rule' => array('inList', array('test'))

			)

		));

		$result = $Field->validate($data);

		$expected = array('inList');

		$this->assertEquals($expected, $result);

	}

/**

 * testGetRule method

 *

 * @return void

 */

	public function testGetRule() {

		$rules = array('notEmpty' => array('rule' => 'notEmpty', 'message' => 'Can not be empty'));

		$Field = new CakeValidationSet('title', $rules);

		$result = $Field->getRule('notEmpty');

		$this->assertInstanceOf('CakeValidationRule', $result);

		$this->assertEquals('notEmpty', $result->rule);

		$this->assertEquals(null, $result->required);

		$this->assertEquals(false, $result->allowEmpty);

		$this->assertEquals(null, $result->on);

		$this->assertEquals(true, $result->last);

		$this->assertEquals('Can not be empty', $result->message);

	}

/**

 * testGetRules method

 *

 * @return void

 */

	public function testGetRules() {

		$rules = array('notEmpty' => array('rule' => 'notEmpty', 'message' => 'Can not be empty'));

		$Field = new CakeValidationSet('title', $rules);

		$result = $Field->getRules();

		$this->assertEquals(array('notEmpty'), array_keys($result));

		$this->assertInstanceOf('CakeValidationRule', $result['notEmpty']);

	}

/**

 * testSetRule method

 *

 * @return void

 */

	public function testSetRule() {

		$rules = array('notEmpty' => array('rule' => 'notEmpty', 'message' => 'Can not be empty'));

		$Field = new CakeValidationSet('title', $rules);

		$Rule = new CakeValidationRule($rules['notEmpty']);

		$this->assertEquals($Rule, $Field->getRule('notEmpty'));

		$rules = array('validEmail' => array('rule' => 'email', 'message' => 'Invalid email'));

		$Rule = new CakeValidationRule($rules['validEmail']);

		$Field->setRule('validEmail', $Rule);

		$result = $Field->getRules();

		$this->assertEquals(array('notEmpty', 'validEmail'), array_keys($result));

		$rules = array('validEmail' => array('rule' => 'email', 'message' => 'Other message'));

		$Rule = new CakeValidationRule($rules['validEmail']);

		$Field->setRule('validEmail', $Rule);

		$result = $Field->getRules();

		$this->assertEquals(array('notEmpty', 'validEmail'), array_keys($result));

		$result = $Field->getRule('validEmail');

		$this->assertInstanceOf('CakeValidationRule', $result);

		$this->assertEquals('email', $result->rule);

		$this->assertEquals(null, $result->required);

		$this->assertEquals(false, $result->allowEmpty);

		$this->assertEquals(null, $result->on);

		$this->assertEquals(true, $result->last);

		$this->assertEquals('Other message', $result->message);

	}

/**

 * testSetRules method

 *

 * @return void

 */

	public function testSetRules() {

		$rule = array('notEmpty' => array('rule' => 'notEmpty', 'message' => 'Can not be empty'));

		$Field = new CakeValidationSet('title', $rule);

		$RuleEmpty = new CakeValidationRule($rule['notEmpty']);

		$rule = array('validEmail' => array('rule' => 'email', 'message' => 'Invalid email'));

		$RuleEmail = new CakeValidationRule($rule['validEmail']);

		$rules = array('validEmail' => $RuleEmail);

		$Field->setRules($rules, false);

		$result = $Field->getRules();

		$this->assertEquals(array('validEmail'), array_keys($result));

		$Field->setRules(array('validEmail' => $rule), false);

		$result = $Field->getRules();

		$this->assertEquals(array('validEmail'), array_keys($result));

		$this->assertTrue(array_pop($result) instanceof CakeValidationRule);

		$rules = array('notEmpty' => $RuleEmpty);

		$Field->setRules($rules, true);

		$result = $Field->getRules();

		$this->assertEquals(array('validEmail', 'notEmpty'), array_keys($result));

		$rules = array('notEmpty' => array('rule' => 'notEmpty'));

		$Field->setRules($rules, true);

		$result = $Field->getRules();

		$this->assertEquals(array('validEmail', 'notEmpty'), array_keys($result));

		$this->assertTrue(array_pop($result) instanceof CakeValidationRule);

		$this->assertTrue(array_pop($result) instanceof CakeValidationRule);

	}

/**

 * Tests getting a rule from the set using array access

 *

 * @return void

 */

	public function testArrayAccessGet() {

		$Set = new CakeValidationSet('title', array(

			'notEmpty' => array('rule' => 'notEmpty', 'required' => true),

			'numeric' => array('rule' => 'numeric'),

			'other' => array('rule' => array('other', 1)),

		));

		$rule = $Set['notEmpty'];

		$this->assertInstanceOf('CakeValidationRule', $rule);

		$this->assertEquals('notEmpty', $rule->rule);

		$rule = $Set['numeric'];

		$this->assertInstanceOf('CakeValidationRule', $rule);

		$this->assertEquals('numeric', $rule->rule);

		$rule = $Set['other'];

		$this->assertInstanceOf('CakeValidationRule', $rule);

		$this->assertEquals(array('other', 1), $rule->rule);

	}

/**

 * Tests checking a rule from the set using array access

 *

 * @return void

 */

	public function testArrayAccessExists() {

		$Set = new CakeValidationSet('title', array(

			'notEmpty' => array('rule' => 'notEmpty', 'required' => true),

			'numeric' => array('rule' => 'numeric'),

			'other' => array('rule' => array('other', 1)),

		));

		$this->assertTrue(isset($Set['notEmpty']));

		$this->assertTrue(isset($Set['numeric']));

		$this->assertTrue(isset($Set['other']));

		$this->assertFalse(isset($Set['fail']));

	}

/**

 * Tests setting a rule in the set using array access

 *

 * @return void

 */

	public function testArrayAccessSet() {

		$Set = new CakeValidationSet('title', array(

			'notEmpty' => array('rule' => 'notEmpty', 'required' => true),

		));

		$this->assertFalse(isset($Set['other']));

		$Set['other'] = array('rule' => array('other', 1));

		$rule = $Set['other'];

		$this->assertInstanceOf('CakeValidationRule', $rule);

		$this->assertEquals(array('other', 1), $rule->rule);

		$this->assertFalse(isset($Set['numeric']));

		$Set['numeric'] = new CakeValidationRule(array('rule' => 'numeric'));

		$rule = $Set['numeric'];

		$this->assertInstanceOf('CakeValidationRule', $rule);

		$this->assertEquals('numeric', $rule->rule);

	}

/**

 * Tests unseting a rule from the set using array access

 *

 * @return void

 */

	public function testArrayAccessUnset() {

		$Set = new CakeValidationSet('title', array(

			'notEmpty' => array('rule' => 'notEmpty', 'required' => true),

			'numeric' => array('rule' => 'numeric'),

			'other' => array('rule' => array('other', 1)),

		));

		unset($Set['notEmpty']);

		$this->assertFalse(isset($Set['notEmpty']));

		unset($Set['numeric']);

		$this->assertFalse(isset($Set['notEmpty']));

		unset($Set['other']);

		$this->assertFalse(isset($Set['notEmpty']));

	}

/**

 * Tests it is possible to iterate a validation set object

 *

 * @return void

 */

	public function testIterator() {

		$Set = new CakeValidationSet('title', array(

			'notEmpty' => array('rule' => 'notEmpty', 'required' => true),

			'numeric' => array('rule' => 'numeric'),

			'other' => array('rule' => array('other', 1)),

		));

		$i = 0;

		foreach ($Set as $name => $rule) {

			if ($i === 0) {

				$this->assertEquals('notEmpty', $name);

			}

			if ($i === 1) {

				$this->assertEquals('numeric', $name);

			}

			if ($i === 2) {

				$this->assertEquals('other', $name);

			}

			$this->assertInstanceOf('CakeValidationRule', $rule);

			$i++;

		}

		$this->assertEquals(3, $i);

	}

/**

 * Tests countable interface

 *

 * @return void

 */

	public function testCount() {

		$Set = new CakeValidationSet('title', array(

			'notEmpty' => array('rule' => 'notEmpty', 'required' => true),

			'numeric' => array('rule' => 'numeric'),

			'other' => array('rule' => array('other', 1)),

		));

		$this->assertCount(3, $Set);

		unset($Set['other']);

		$this->assertCount(2, $Set);

	}

/**

 * Test removeRule method

 *

 * @return void

 */

	public function testRemoveRule() {

		$Set = new CakeValidationSet('title', array(

			'notEmpty' => array('rule' => 'notEmpty', 'required' => true),

			'numeric' => array('rule' => 'numeric'),

			'other' => array('rule' => array('other', 1)),

		));

		$Set->removeRule('notEmpty');

		$this->assertFalse(isset($Set['notEmpty']));

		$Set->removeRule('numeric');

		$this->assertFalse(isset($Set['numeric']));

		$Set->removeRule('other');

		$this->assertFalse(isset($Set['other']));

	}

}