Initial commit

lib/Cake/Test/Case/Model/AclNodeTest.php

@@ -0,0 +1,356 @@
+<?php
+/**
+ * AclNodeTest file
+ *
+ * CakePHP(tm) Tests <http://book.cakephp.org/2.0/en/development/testing.html>
+ * 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/2.0/en/development/testing.html CakePHP(tm) Tests
+ * @package       Cake.Test.Case.Model
+ * @since         CakePHP(tm) v 1.2.0.4206
+ * @license       http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+
+App::uses('DbAcl', 'Controller/Component/Acl');
+App::uses('AclNode', 'Model');
+
+/**
+ * DB ACL wrapper test class
+ *
+ * @package       Cake.Test.Case.Model
+ */
+class DbAclNodeTestBase extends AclNode {
+
+/**
+ * useDbConfig property
+ *
+ * @var string
+ */
+	public $useDbConfig = 'test';
+
+/**
+ * cacheSources property
+ *
+ * @var bool
+ */
+	public $cacheSources = false;
+}
+
+/**
+ * Aro Test Wrapper
+ *
+ * @package       Cake.Test.Case.Model
+ */
+class DbAroTest extends DbAclNodeTestBase {
+
+/**
+ * useTable property
+ *
+ * @var string
+ */
+	public $useTable = 'aros';
+
+/**
+ * hasAndBelongsToMany property
+ *
+ * @var array
+ */
+	public $hasAndBelongsToMany = array('DbAcoTest' => array('with' => 'DbPermissionTest'));
+}
+
+/**
+ * Aco Test Wrapper
+ *
+ * @package       Cake.Test.Case.Model
+ */
+class DbAcoTest extends DbAclNodeTestBase {
+
+/**
+ * useTable property
+ *
+ * @var string
+ */
+	public $useTable = 'acos';
+
+/**
+ * hasAndBelongsToMany property
+ *
+ * @var array
+ */
+	public $hasAndBelongsToMany = array('DbAroTest' => array('with' => 'DbPermissionTest'));
+}
+
+/**
+ * Permission Test Wrapper
+ *
+ * @package       Cake.Test.Case.Model
+ */
+class DbPermissionTest extends CakeTestModel {
+
+/**
+ * useTable property
+ *
+ * @var string
+ */
+	public $useTable = 'aros_acos';
+
+/**
+ * cacheQueries property
+ *
+ * @var bool
+ */
+	public $cacheQueries = false;
+
+/**
+ * belongsTo property
+ *
+ * @var array
+ */
+	public $belongsTo = array('DbAroTest' => array('foreignKey' => 'aro_id'), 'DbAcoTest' => array('foreignKey' => 'aco_id'));
+}
+
+/**
+ * DboActionTest class
+ *
+ * @package       Cake.Test.Case.Model
+ */
+class DbAcoActionTest extends CakeTestModel {
+
+/**
+ * useTable property
+ *
+ * @var string
+ */
+	public $useTable = 'aco_actions';
+
+/**
+ * belongsTo property
+ *
+ * @var array
+ */
+	public $belongsTo = array('DbAcoTest' => array('foreignKey' => 'aco_id'));
+}
+
+/**
+ * DbAroUserTest class
+ *
+ * @package       Cake.Test.Case.Model
+ */
+class DbAroUserTest extends CakeTestModel {
+
+/**
+ * name property
+ *
+ * @var string
+ */
+	public $name = 'AuthUser';
+
+/**
+ * useTable property
+ *
+ * @var string
+ */
+	public $useTable = 'auth_users';
+
+/**
+ * bindNode method
+ *
+ * @param string|array|Model $ref
+ * @return void
+ */
+	public function bindNode($ref = null) {
+		if (Configure::read('DbAclbindMode') === 'string') {
+			return 'ROOT/admins/Gandalf';
+		} elseif (Configure::read('DbAclbindMode') === 'array') {
+			return array('DbAroTest' => array('DbAroTest.model' => 'AuthUser', 'DbAroTest.foreign_key' => 2));
+		}
+	}
+
+}
+
+/**
+ * TestDbAcl class
+ *
+ * @package       Cake.Test.Case.Model
+ */
+class TestDbAcl extends DbAcl {
+
+/**
+ * construct method
+ *
+ */
+	public function __construct() {
+		$this->Aro = new DbAroTest();
+		$this->Aro->Permission = new DbPermissionTest();
+		$this->Aco = new DbAcoTest();
+		$this->Aro->Permission = new DbPermissionTest();
+	}
+
+}
+
+/**
+ * AclNodeTest class
+ *
+ * @package       Cake.Test.Case.Model
+ */
+class AclNodeTest extends CakeTestCase {
+
+/**
+ * fixtures property
+ *
+ * @var array
+ */
+	public $fixtures = array('core.aro', 'core.aco', 'core.aros_aco', 'core.aco_action', 'core.auth_user');
+
+/**
+ * setUp method
+ *
+ * @return void
+ */
+	public function setUp() {
+		parent::setUp();
+		Configure::write('Acl.classname', 'TestDbAcl');
+		Configure::write('Acl.database', 'test');
+	}
+
+/**
+ * testNode method
+ *
+ * @return void
+ */
+	public function testNode() {
+		$Aco = new DbAcoTest();
+		$result = Hash::extract($Aco->node('Controller1'), '{n}.DbAcoTest.id');
+		$expected = array(2, 1);
+		$this->assertEquals($expected, $result);
+
+		$result = Hash::extract($Aco->node('Controller1/action1'), '{n}.DbAcoTest.id');
+		$expected = array(3, 2, 1);
+		$this->assertEquals($expected, $result);
+
+		$result = Hash::extract($Aco->node('Controller2/action1'), '{n}.DbAcoTest.id');
+		$expected = array(7, 6, 1);
+		$this->assertEquals($expected, $result);
+
+		$result = Hash::extract($Aco->node('Controller1/action2'), '{n}.DbAcoTest.id');
+		$expected = array(5, 2, 1);
+		$this->assertEquals($expected, $result);
+
+		$result = Hash::extract($Aco->node('Controller1/action1/record1'), '{n}.DbAcoTest.id');
+		$expected = array(4, 3, 2, 1);
+		$this->assertEquals($expected, $result);
+
+		$result = Hash::extract($Aco->node('Controller2/action1/record1'), '{n}.DbAcoTest.id');
+		$expected = array(8, 7, 6, 1);
+		$this->assertEquals($expected, $result);
+
+		$this->assertFalse($Aco->node('Controller2/action3'));
+
+		$this->assertFalse($Aco->node('Controller2/action3/record5'));
+
+		$result = $Aco->node('');
+		$this->assertEquals(null, $result);
+	}
+
+/**
+ * test that node() doesn't dig deeper than it should.
+ *
+ * @return void
+ */
+	public function testNodeWithDuplicatePathSegments() {
+		$Aco = new DbAcoTest();
+		$nodes = $Aco->node('ROOT/Users');
+		$this->assertEquals(1, $nodes[0]['DbAcoTest']['parent_id'], 'Parent id does not point at ROOT. %s');
+	}
+
+/**
+ * testNodeArrayFind method
+ *
+ * @return void
+ */
+	public function testNodeArrayFind() {
+		$Aro = new DbAroTest();
+		Configure::write('DbAclbindMode', 'string');
+		$result = Hash::extract($Aro->node(array('DbAroUserTest' => array('id' => '1', 'foreign_key' => '1'))), '{n}.DbAroTest.id');
+		$expected = array(3, 2, 1);
+		$this->assertEquals($expected, $result);
+
+		Configure::write('DbAclbindMode', 'array');
+		$result = Hash::extract($Aro->node(array('DbAroUserTest' => array('id' => 4, 'foreign_key' => 2))), '{n}.DbAroTest.id');
+		$expected = array(4);
+		$this->assertEquals($expected, $result);
+	}
+
+/**
+ * testNodeObjectFind method
+ *
+ * @return void
+ */
+	public function testNodeObjectFind() {
+		$Aro = new DbAroTest();
+		$Model = new DbAroUserTest();
+		$Model->id = 1;
+		$result = Hash::extract($Aro->node($Model), '{n}.DbAroTest.id');
+		$expected = array(3, 2, 1);
+		$this->assertEquals($expected, $result);
+
+		$Model->id = 2;
+		$result = Hash::extract($Aro->node($Model), '{n}.DbAroTest.id');
+		$expected = array(4, 2, 1);
+		$this->assertEquals($expected, $result);
+	}
+
+/**
+ * testNodeAliasParenting method
+ *
+ * @return void
+ */
+	public function testNodeAliasParenting() {
+		$Aco = ClassRegistry::init('DbAcoTest');
+		$db = $Aco->getDataSource();
+		$db->truncate($Aco);
+
+		$Aco->create(array('model' => null, 'foreign_key' => null, 'parent_id' => null, 'alias' => 'Application'));
+		$Aco->save();
+
+		$Aco->create(array('model' => null, 'foreign_key' => null, 'parent_id' => $Aco->id, 'alias' => 'Pages'));
+		$Aco->save();
+
+		$result = $Aco->find('all');
+		$expected = array(
+			array('DbAcoTest' => array('id' => '1', 'parent_id' => null, 'model' => null, 'foreign_key' => null, 'alias' => 'Application', 'lft' => '1', 'rght' => '4'), 'DbAroTest' => array()),
+			array('DbAcoTest' => array('id' => '2', 'parent_id' => '1', 'model' => null, 'foreign_key' => null, 'alias' => 'Pages', 'lft' => '2', 'rght' => '3'), 'DbAroTest' => array())
+		);
+		$this->assertEquals($expected, $result);
+	}
+
+/**
+ * testNodeActionAuthorize method
+ *
+ * @return void
+ */
+	public function testNodeActionAuthorize() {
+		App::build(array(
+			'Plugin' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'Plugin' . DS)
+		), App::RESET);
+		CakePlugin::load('TestPlugin');
+
+		$Aro = new DbAroTest();
+		$Aro->create();
+		$Aro->save(array('model' => 'TestPluginAuthUser', 'foreign_key' => 1));
+		$result = $Aro->id;
+		$expected = 5;
+		$this->assertEquals($expected, $result);
+
+		$node = $Aro->node(array('TestPlugin.TestPluginAuthUser' => array('id' => 1, 'user' => 'mariano')));
+		$result = Hash::get($node, '0.DbAroTest.id');
+		$expected = $Aro->id;
+		$this->assertEquals($expected, $result);
+		CakePlugin::unload('TestPlugin');
+	}
+}

lib/Cake/Test/Case/Model/Behavior/AclBehaviorTest.php

@@ -0,0 +1,484 @@
+<?php
+/**
+ * AclBehaviorTest file
+ *
+ * Test the Acl Behavior
+ *
+ * CakePHP : Rapid Development Framework (http://cakephp.org)
+ * 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://cakephp.org CakePHP Project
+ * @package       Cake.Test.Case.Model.Behavior
+ * @since         CakePHP v 1.2.0.4487
+ * @license       http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+
+App::uses('AclBehavior', 'Model/Behavior');
+App::uses('Aco', 'Model');
+App::uses('Aro', 'Model');
+App::uses('AclNode', 'Model');
+App::uses('DbAcl', 'Model');
+
+/**
+ * Test Person class - self joined model
+ *
+ * @package       Cake.Test.Case.Model.Behavior
+ */
+class AclPerson extends CakeTestModel {
+
+/**
+ * useTable property
+ *
+ * @var string
+ */
+	public $useTable = 'people';
+
+/**
+ * actsAs property
+ *
+ * @var array
+ */
+	public $actsAs = array('Acl' => 'both');
+
+/**
+ * belongsTo property
+ *
+ * @var array
+ */
+	public $belongsTo = array(
+		'Mother' => array(
+			'className' => 'AclPerson',
+			'foreignKey' => 'mother_id',
+		)
+	);
+
+/**
+ * hasMany property
+ *
+ * @var array
+ */
+	public $hasMany = array(
+		'Child' => array(
+			'className' => 'AclPerson',
+			'foreignKey' => 'mother_id'
+		)
+	);
+
+/**
+ * parentNode method
+ *
+ * @return void
+ */
+	public function parentNode() {
+		if (!$this->id && empty($this->data)) {
+			return null;
+		}
+		if (isset($this->data['AclPerson']['mother_id'])) {
+			$motherId = $this->data['AclPerson']['mother_id'];
+		} else {
+			$motherId = $this->field('mother_id');
+		}
+		if (!$motherId) {
+			return null;
+		}
+		return array('AclPerson' => array('id' => $motherId));
+	}
+
+}
+
+/**
+ * AclUser class
+ *
+ * @package       Cake.Test.Case.Model.Behavior
+ */
+class AclUser extends CakeTestModel {
+
+/**
+ * name property
+ *
+ * @var string
+ */
+	public $name = 'User';
+
+/**
+ * useTable property
+ *
+ * @var string
+ */
+	public $useTable = 'users';
+
+/**
+ * actsAs property
+ *
+ * @var array
+ */
+	public $actsAs = array('Acl' => array('type' => 'requester'));
+
+/**
+ * parentNode
+ *
+ * @return null
+ */
+	public function parentNode() {
+		return null;
+	}
+
+}
+
+/**
+ * AclPost class
+ *
+ * @package       Cake.Test.Case.Model.Behavior
+ */
+class AclPost extends CakeTestModel {
+
+/**
+ * name property
+ *
+ * @var string
+ */
+	public $name = 'Post';
+
+/**
+ * useTable property
+ *
+ * @var string
+ */
+	public $useTable = 'posts';
+
+/**
+ * actsAs property
+ *
+ * @var array
+ */
+	public $actsAs = array('Acl' => array('type' => 'Controlled'));
+
+/**
+ * parentNode
+ *
+ * @return null
+ */
+	public function parentNode() {
+		return null;
+	}
+
+}
+
+/**
+ * AclBehaviorTest class
+ *
+ * @package       Cake.Test.Case.Model.Behavior
+ */
+class AclBehaviorTest extends CakeTestCase {
+
+/**
+ * Aco property
+ *
+ * @var Aco
+ */
+	public $Aco;
+
+/**
+ * Aro property
+ *
+ * @var Aro
+ */
+	public $Aro;
+
+/**
+ * fixtures property
+ *
+ * @var array
+ */
+	public $fixtures = array('core.person', 'core.user', 'core.post', 'core.aco', 'core.aro', 'core.aros_aco');
+
+/**
+ * Set up the test
+ *
+ * @return void
+ */
+	public function setUp() {
+		parent::setUp();
+		Configure::write('Acl.database', 'test');
+
+		$this->Aco = new Aco();
+		$this->Aro = new Aro();
+	}
+
+/**
+ * tearDown method
+ *
+ * @return void
+ */
+	public function tearDown() {
+		parent::tearDown();
+		unset($this->Aro, $this->Aco);
+	}
+
+/**
+ * Test Setup of AclBehavior
+ *
+ * @return void
+ */
+	public function testSetup() {
+		parent::setUp();
+		$User = new AclUser();
+		$this->assertTrue(isset($User->Behaviors->Acl->settings['User']));
+		$this->assertEquals('requester', $User->Behaviors->Acl->settings['User']['type']);
+		$this->assertTrue(is_object($User->Aro));
+
+		$Post = new AclPost();
+		$this->assertTrue(isset($Post->Behaviors->Acl->settings['Post']));
+		$this->assertEquals('controlled', $Post->Behaviors->Acl->settings['Post']['type']);
+		$this->assertTrue(is_object($Post->Aco));
+	}
+
+/**
+ * Test Setup of AclBehavior as both requester and controlled
+ *
+ * @return void
+ */
+	public function testSetupMulti() {
+		$User = new AclPerson();
+		$this->assertTrue(isset($User->Behaviors->Acl->settings['AclPerson']));
+		$this->assertEquals('both', $User->Behaviors->Acl->settings['AclPerson']['type']);
+		$this->assertTrue(is_object($User->Aro));
+		$this->assertTrue(is_object($User->Aco));
+	}
+
+/**
+ * test After Save
+ *
+ * @return void
+ */
+	public function testAfterSave() {
+		$Post = new AclPost();
+		$data = array(
+			'Post' => array(
+				'author_id' => 1,
+				'title' => 'Acl Post',
+				'body' => 'post body',
+				'published' => 1
+			),
+		);
+		$Post->save($data);
+		$result = $this->Aco->find('first', array(
+			'conditions' => array('Aco.model' => 'Post', 'Aco.foreign_key' => $Post->id)
+		));
+		$this->assertTrue(is_array($result));
+		$this->assertEquals('Post', $result['Aco']['model']);
+		$this->assertEquals($Post->id, $result['Aco']['foreign_key']);
+
+		$aroData = array(
+			'Aro' => array(
+				'model' => 'AclPerson',
+				'foreign_key' => 2,
+				'parent_id' => null
+			)
+		);
+		$this->Aro->save($aroData);
+
+		$acoData = array(
+			'Aco' => array(
+				'model' => 'AclPerson',
+				'foreign_key' => 2,
+				'parent_id' => null
+			)
+		);
+		$this->Aco->save($acoData);
+
+		$Person = new AclPerson();
+		$data = array(
+			'AclPerson' => array(
+				'name' => 'Trent',
+				'mother_id' => 2,
+				'father_id' => 3,
+			),
+		);
+		$Person->save($data);
+		$result = $this->Aro->find('first', array(
+			'conditions' => array('Aro.model' => 'AclPerson', 'Aro.foreign_key' => $Person->id)
+		));
+		$this->assertTrue(is_array($result));
+		$this->assertEquals(5, $result['Aro']['parent_id']);
+
+		$node = $Person->node(array('model' => 'AclPerson', 'foreign_key' => 8), 'Aro');
+		$this->assertEquals(2, count($node));
+		$this->assertEquals(5, $node[0]['Aro']['parent_id']);
+		$this->assertEquals(null, $node[1]['Aro']['parent_id']);
+
+		$aroData = array(
+			'Aro' => array(
+			'model' => 'AclPerson',
+				'foreign_key' => 1,
+				'parent_id' => null
+			)
+		);
+		$this->Aro->create();
+		$this->Aro->save($aroData);
+		$acoData = array(
+			'Aco' => array(
+				'model' => 'AclPerson',
+				'foreign_key' => 1,
+				'parent_id' => null
+		));
+		$this->Aco->create();
+		$this->Aco->save($acoData);
+		$Person->read(null, 8);
+		$Person->set('mother_id', 1);
+		$Person->save();
+		$result = $this->Aro->find('first', array(
+			'conditions' => array('Aro.model' => 'AclPerson', 'Aro.foreign_key' => $Person->id)
+		));
+		$this->assertTrue(is_array($result));
+		$this->assertEquals(7, $result['Aro']['parent_id']);
+
+		$node = $Person->node(array('model' => 'AclPerson', 'foreign_key' => 8), 'Aro');
+		$this->assertEquals(2, count($node));
+		$this->assertEquals(7, $node[0]['Aro']['parent_id']);
+		$this->assertEquals(null, $node[1]['Aro']['parent_id']);
+	}
+
+/**
+ * test that an afterSave on an update does not cause parent_id to become null.
+ *
+ * @return void
+ */
+	public function testAfterSaveUpdateParentIdNotNull() {
+		$aroData = array(
+			'Aro' => array(
+				'model' => 'AclPerson',
+				'foreign_key' => 2,
+				'parent_id' => null
+			)
+		);
+		$this->Aro->save($aroData);
+
+		$acoData = array(
+			'Aco' => array(
+				'model' => 'AclPerson',
+				'foreign_key' => 2,
+				'parent_id' => null
+			)
+		);
+		$this->Aco->save($acoData);
+
+		$Person = new AclPerson();
+		$data = array(
+			'AclPerson' => array(
+				'name' => 'Trent',
+				'mother_id' => 2,
+				'father_id' => 3,
+			),
+		);
+		$Person->save($data);
+		$result = $this->Aro->find('first', array(
+			'conditions' => array('Aro.model' => 'AclPerson', 'Aro.foreign_key' => $Person->id)
+		));
+		$this->assertTrue(is_array($result));
+		$this->assertEquals(5, $result['Aro']['parent_id']);
+
+		$Person->save(array('id' => $Person->id, 'name' => 'Bruce'));
+		$result = $this->Aro->find('first', array(
+			'conditions' => array('Aro.model' => 'AclPerson', 'Aro.foreign_key' => $Person->id)
+		));
+		$this->assertEquals(5, $result['Aro']['parent_id']);
+	}
+
+/**
+ * Test After Delete
+ *
+ * @return void
+ */
+	public function testAfterDelete() {
+		$aroData = array(
+			'Aro' => array(
+				'model' => 'AclPerson',
+				'foreign_key' => 2,
+				'parent_id' => null
+			)
+		);
+		$this->Aro->save($aroData);
+
+		$acoData = array(
+			'Aco' => array(
+				'model' => 'AclPerson',
+				'foreign_key' => 2,
+				'parent_id' => null
+			)
+		);
+		$this->Aco->save($acoData);
+		$Person = new AclPerson();
+
+		$data = array(
+			'AclPerson' => array(
+				'name' => 'Trent',
+				'mother_id' => 2,
+				'father_id' => 3,
+			),
+		);
+		$Person->save($data);
+		$id = $Person->id;
+		$node = $Person->node(null, 'Aro');
+		$this->assertEquals(2, count($node));
+		$this->assertEquals(5, $node[0]['Aro']['parent_id']);
+		$this->assertEquals(null, $node[1]['Aro']['parent_id']);
+
+		$Person->delete($id);
+		$result = $this->Aro->find('first', array(
+			'conditions' => array('Aro.model' => 'AclPerson', 'Aro.foreign_key' => $id)
+		));
+		$this->assertTrue(empty($result));
+		$result = $this->Aro->find('first', array(
+			'conditions' => array('Aro.model' => 'AclPerson', 'Aro.foreign_key' => 2)
+		));
+		$this->assertFalse(empty($result));
+
+		$data = array(
+			'AclPerson' => array(
+				'name' => 'Trent',
+				'mother_id' => 2,
+				'father_id' => 3,
+			),
+		);
+		$Person->save($data);
+		$id = $Person->id;
+		$Person->delete(2);
+		$result = $this->Aro->find('first', array(
+			'conditions' => array('Aro.model' => 'AclPerson', 'Aro.foreign_key' => $id)
+		));
+		$this->assertTrue(empty($result));
+
+		$result = $this->Aro->find('first', array(
+			'conditions' => array('Aro.model' => 'AclPerson', 'Aro.foreign_key' => 2)
+		));
+		$this->assertTrue(empty($result));
+	}
+
+/**
+ * Test Node()
+ *
+ * @return void
+ */
+	public function testNode() {
+		$Person = new AclPerson();
+		$aroData = array(
+			'Aro' => array(
+				'model' => 'AclPerson',
+				'foreign_key' => 2,
+				'parent_id' => null
+			)
+		);
+		$this->Aro->save($aroData);
+
+		$Person->id = 2;
+		$result = $Person->node(null, 'Aro');
+		$this->assertTrue(is_array($result));
+		$this->assertEquals(1, count($result));
+	}
+}

lib/Cake/Test/Case/Model/Behavior/TreeBehaviorAfterTest.php

@@ -0,0 +1,75 @@
+<?php
+/**
+ * TreeBehaviorAfterTest file
+ *
+ * CakePHP(tm) Tests <http://book.cakephp.org/2.0/en/development/testing.html>
+ * 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/2.0/en/development/testing.html CakePHP(tm) Tests
+ * @package       Cake.Test.Case.Model.Behavior
+ * @since         CakePHP(tm) v 1.2.0.5330
+ * @license       http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+
+App::uses('Model', 'Model');
+App::uses('AppModel', 'Model');
+
+require_once dirname(dirname(__FILE__)) . DS . 'models.php';
+
+/**
+ * TreeBehaviorAfterTest class
+ *
+ * @package       Cake.Test.Case.Model.Behavior
+ */
+class TreeBehaviorAfterTest extends CakeTestCase {
+
+/**
+ * Whether backup global state for each test method or not
+ *
+ * @var bool
+ */
+	public $backupGlobals = false;
+
+/**
+ * settings property
+ *
+ * @var array
+ */
+	public $settings = array(
+		'modelClass' => 'AfterTree',
+		'leftField' => 'lft',
+		'rightField' => 'rght',
+		'parentField' => 'parent_id'
+	);
+
+/**
+ * fixtures property
+ *
+ * @var array
+ */
+	public $fixtures = array('core.after_tree');
+
+/**
+ * Tests the afterSave callback in the model
+ *
+ * @return void
+ */
+	public function testAftersaveCallback() {
+		$this->Tree = new AfterTree();
+		$this->Tree->order = null;
+
+		$expected = array('AfterTree' => array('name' => 'Six and One Half Changed in AfterTree::afterSave() but not in database', 'parent_id' => 6, 'lft' => 11, 'rght' => 12));
+		$result = $this->Tree->save(array('AfterTree' => array('name' => 'Six and One Half', 'parent_id' => 6)));
+		$expected['AfterTree']['id'] = $this->Tree->id;
+		$this->assertEquals($expected, $result);
+
+		$expected = array('AfterTree' => array('name' => 'Six and One Half', 'parent_id' => 6, 'lft' => 11, 'rght' => 12, 'id' => 8));
+		$result = $this->Tree->find('all');
+		$this->assertEquals($expected, $result[7]);
+	}
+}

lib/Cake/Test/Case/Model/Behavior/TreeBehaviorScopedTest.php

@@ -0,0 +1,591 @@
+<?php
+/**
+ * TreeBehaviorScopedTest file
+ *
+ * A tree test using scope
+ *
+ * CakePHP(tm) Tests <http://book.cakephp.org/2.0/en/development/testing.html>
+ * 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/2.0/en/development/testing.html CakePHP(tm) Tests
+ * @package       Cake.Test.Case.Model.Behavior
+ * @since         CakePHP(tm) v 1.2.0.5330
+ * @license       http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+
+App::uses('Model', 'Model');
+App::uses('AppModel', 'Model');
+
+require_once dirname(dirname(__FILE__)) . DS . 'models.php';
+
+/**
+ * TreeBehaviorScopedTest class
+ *
+ * @package       Cake.Test.Case.Model.Behavior
+ */
+class TreeBehaviorScopedTest extends CakeTestCase {
+
+/**
+ * Whether backup global state for each test method or not
+ *
+ * @var bool
+ */
+	public $backupGlobals = false;
+
+/**
+ * settings property
+ *
+ * @var array
+ */
+	public $settings = array(
+		'modelClass' => 'FlagTree',
+		'leftField' => 'lft',
+		'rightField' => 'rght',
+		'parentField' => 'parent_id'
+	);
+
+/**
+ * fixtures property
+ *
+ * @var array
+ */
+	public $fixtures = array('core.flag_tree', 'core.ad', 'core.campaign', 'core.translate', 'core.number_tree_two');
+
+/**
+ * testStringScope method
+ *
+ * @return void
+ */
+	public function testStringScope() {
+		$this->Tree = new FlagTree();
+		$this->Tree->order = null;
+		$this->Tree->initialize(2, 3);
+
+		$this->Tree->id = 1;
+		$this->Tree->saveField('flag', 1);
+		$this->Tree->id = 2;
+		$this->Tree->saveField('flag', 1);
+
+		$result = $this->Tree->children();
+		$expected = array(
+			array('FlagTree' => array('id' => '3', 'name' => '1.1.1', 'parent_id' => '2', 'lft' => '3', 'rght' => '4', 'flag' => '0')),
+			array('FlagTree' => array('id' => '4', 'name' => '1.1.2', 'parent_id' => '2', 'lft' => '5', 'rght' => '6', 'flag' => '0')),
+			array('FlagTree' => array('id' => '5', 'name' => '1.1.3', 'parent_id' => '2', 'lft' => '7', 'rght' => '8', 'flag' => '0'))
+		);
+		$this->assertEquals($expected, $result);
+
+		$this->Tree->Behaviors->load('Tree', array('scope' => 'FlagTree.flag = 1'));
+		$this->assertEquals(array(), $this->Tree->children());
+
+		$this->Tree->id = 1;
+		$this->Tree->Behaviors->load('Tree', array('scope' => 'FlagTree.flag = 1'));
+
+		$result = $this->Tree->children();
+		$expected = array(array('FlagTree' => array('id' => '2', 'name' => '1.1', 'parent_id' => '1', 'lft' => '2', 'rght' => '9', 'flag' => '1')));
+		$this->assertEquals($expected, $result);
+
+		$this->assertTrue($this->Tree->delete());
+		$this->assertEquals(11, $this->Tree->find('count'));
+	}
+
+/**
+ * testArrayScope method
+ *
+ * @return void
+ */
+	public function testArrayScope() {
+		$this->Tree = new FlagTree();
+		$this->Tree->order = null;
+		$this->Tree->initialize(2, 3);
+
+		$this->Tree->id = 1;
+		$this->Tree->saveField('flag', 1);
+		$this->Tree->id = 2;
+		$this->Tree->saveField('flag', 1);
+
+		$result = $this->Tree->children();
+		$expected = array(
+			array('FlagTree' => array('id' => '3', 'name' => '1.1.1', 'parent_id' => '2', 'lft' => '3', 'rght' => '4', 'flag' => '0')),
+			array('FlagTree' => array('id' => '4', 'name' => '1.1.2', 'parent_id' => '2', 'lft' => '5', 'rght' => '6', 'flag' => '0')),
+			array('FlagTree' => array('id' => '5', 'name' => '1.1.3', 'parent_id' => '2', 'lft' => '7', 'rght' => '8', 'flag' => '0'))
+		);
+		$this->assertEquals($expected, $result);
+
+		$this->Tree->Behaviors->load('Tree', array('scope' => array('FlagTree.flag' => 1)));
+		$this->assertEquals(array(), $this->Tree->children());
+
+		$this->Tree->id = 1;
+		$this->Tree->Behaviors->load('Tree', array('scope' => array('FlagTree.flag' => 1)));
+
+		$result = $this->Tree->children();
+		$expected = array(array('FlagTree' => array('id' => '2', 'name' => '1.1', 'parent_id' => '1', 'lft' => '2', 'rght' => '9', 'flag' => '1')));
+		$this->assertEquals($expected, $result);
+
+		$this->assertTrue($this->Tree->delete());
+		$this->assertEquals(11, $this->Tree->find('count'));
+	}
+
+/**
+ * testSaveWithParentAndInvalidScope method
+ *
+ * Attempting to save an invalid data should not trigger an `Undefined offset`
+ * error
+ *
+ * @return void
+ */
+	public function testSaveWithParentAndInvalidScope() {
+		$this->Tree = new FlagTree();
+		$this->Tree->order = null;
+		$data = $this->Tree->create(array(
+			'name' => 'Flag',
+		));
+		$tree = $this->Tree->save($data);
+		$this->Tree->Behaviors->load('Tree', array(
+			'scope' => array('FlagTree.flag' => 100)
+		));
+		$tree['FlagTree']['parent_id'] = 1;
+		$result = $this->Tree->save($tree);
+		$this->assertFalse($result);
+	}
+
+/**
+ * testMoveUpWithScope method
+ *
+ * @return void
+ */
+	public function testMoveUpWithScope() {
+		$this->Ad = new Ad();
+		$this->Ad->order = null;
+		$this->Ad->Behaviors->load('Tree', array('scope' => 'Campaign'));
+		$this->Ad->moveUp(6);
+
+		$this->Ad->id = 4;
+		$result = $this->Ad->children();
+		$this->assertEquals(array(6, 5), Hash::extract($result, '{n}.Ad.id'));
+		$this->assertEquals(array(2, 2), Hash::extract($result, '{n}.Campaign.id'));
+	}
+
+/**
+ * testMoveDownWithScope method
+ *
+ * @return void
+ */
+	public function testMoveDownWithScope() {
+		$this->Ad = new Ad();
+		$this->Ad->order = null;
+		$this->Ad->Behaviors->load('Tree', array('scope' => 'Campaign'));
+		$this->Ad->moveDown(6);
+
+		$this->Ad->id = 4;
+		$result = $this->Ad->children();
+		$this->assertEquals(array(5, 6), Hash::extract($result, '{n}.Ad.id'));
+		$this->assertEquals(array(2, 2), Hash::extract($result, '{n}.Campaign.id'));
+	}
+
+/**
+ * Tests the interaction (non-interference) between TreeBehavior and other behaviors with respect
+ * to callback hooks
+ *
+ * @return void
+ */
+	public function testTranslatingTree() {
+		$this->Tree = new FlagTree();
+		$this->Tree->order = null;
+		$this->Tree->cacheQueries = false;
+		$this->Tree->Behaviors->load('Translate', array('title'));
+
+		//Save
+		$this->Tree->create();
+		$this->Tree->locale = 'eng';
+		$data = array('FlagTree' => array(
+			'title' => 'name #1',
+			'name' => 'test',
+			'locale' => 'eng',
+			'parent_id' => null,
+		));
+		$this->Tree->save($data);
+		$result = $this->Tree->find('all');
+		$expected = array(array('FlagTree' => array(
+			'id' => 1,
+			'title' => 'name #1',
+			'name' => 'test',
+			'parent_id' => null,
+			'lft' => 1,
+			'rght' => 2,
+			'flag' => 0,
+			'locale' => 'eng',
+		)));
+		$this->assertEquals($expected, $result);
+
+		// update existing record, same locale
+		$this->Tree->create();
+		$data['FlagTree']['title'] = 'Named 2';
+		$this->Tree->id = 1;
+		$this->Tree->save($data);
+		$result = $this->Tree->find('all');
+		$expected = array(array('FlagTree' => array(
+			'id' => 1,
+			'title' => 'Named 2',
+			'name' => 'test',
+			'parent_id' => null,
+			'lft' => 1,
+			'rght' => 2,
+			'flag' => 0,
+			'locale' => 'eng',
+		)));
+		$this->assertEquals($expected, $result);
+
+		// update different locale, same record
+		$this->Tree->create();
+		$this->Tree->locale = 'deu';
+		$this->Tree->id = 1;
+		$data = array('FlagTree' => array(
+			'id' => 1,
+			'parent_id' => null,
+			'title' => 'namen #1',
+			'name' => 'test',
+			'locale' => 'deu',
+		));
+		$this->Tree->save($data);
+
+		$this->Tree->locale = 'deu';
+		$result = $this->Tree->find('all');
+		$expected = array(
+			array(
+				'FlagTree' => array(
+					'id' => 1,
+					'title' => 'namen #1',
+					'name' => 'test',
+					'parent_id' => null,
+					'lft' => 1,
+					'rght' => 2,
+					'flag' => 0,
+					'locale' => 'deu',
+				)
+			)
+		);
+		$this->assertEquals($expected, $result);
+
+		// Save with bindTranslation
+		$this->Tree->locale = 'eng';
+		$data = array(
+			'title' => array('eng' => 'New title', 'spa' => 'Nuevo leyenda'),
+			'name' => 'test',
+			'parent_id' => null
+		);
+		$this->Tree->create($data);
+		$this->Tree->save();
+
+		$this->Tree->unbindTranslation();
+		$translations = array('title' => 'Title');
+		$this->Tree->bindTranslation($translations, false);
+		$this->Tree->locale = array('eng', 'spa');
+
+		$result = $this->Tree->read();
+		$expected = array(
+			'FlagTree' => array(
+				'id' => 2,
+				'parent_id' => null,
+				'locale' => 'eng',
+				'name' => 'test',
+				'title' => 'New title',
+				'flag' => 0,
+				'lft' => 3,
+				'rght' => 4
+			),
+			'Title' => array(
+				array('id' => 21, 'locale' => 'eng', 'model' => 'FlagTree', 'foreign_key' => 2, 'field' => 'title', 'content' => 'New title'),
+				array('id' => 22, 'locale' => 'spa', 'model' => 'FlagTree', 'foreign_key' => 2, 'field' => 'title', 'content' => 'Nuevo leyenda')
+			),
+		);
+		$this->assertEquals($expected, $result);
+	}
+
+/**
+ * testGenerateTreeListWithSelfJoin method
+ *
+ * @return void
+ */
+	public function testAliasesWithScopeInTwoTreeAssociations() {
+		extract($this->settings);
+		$this->Tree = new $modelClass();
+		$this->Tree->order = null;
+		$this->Tree->initialize(2, 2);
+
+		$this->TreeTwo = new NumberTreeTwo();
+		$this->TreeTwo->order = null;
+
+		$record = $this->Tree->find('first');
+
+		$this->Tree->bindModel(array(
+			'hasMany' => array(
+				'SecondTree' => array(
+					'className' => 'NumberTreeTwo',
+					'foreignKey' => 'number_tree_id'
+				)
+			)
+		));
+		$this->TreeTwo->bindModel(array(
+			'belongsTo' => array(
+				'FirstTree' => array(
+					'className' => $modelClass,
+					'foreignKey' => 'number_tree_id'
+				)
+			)
+		));
+		$this->TreeTwo->Behaviors->load('Tree', array(
+			'scope' => 'FirstTree'
+		));
+
+		$data = array(
+			'NumberTreeTwo' => array(
+				'name' => 'First',
+				'number_tree_id' => $record['FlagTree']['id']
+			)
+		);
+		$this->TreeTwo->create();
+		$result = $this->TreeTwo->save($data);
+		$this->assertFalse(empty($result));
+
+		$result = $this->TreeTwo->find('first');
+		$expected = array('NumberTreeTwo' => array(
+			'id' => 1,
+			'name' => 'First',
+			'number_tree_id' => $record['FlagTree']['id'],
+			'parent_id' => null,
+			'lft' => 1,
+			'rght' => 2
+		));
+		$this->assertEquals($expected, $result);
+	}
+
+/**
+ * testGenerateTreeListWithScope method
+ *
+ * @return void
+ */
+	public function testGenerateTreeListWithScope() {
+		extract($this->settings);
+		$this->Tree = new $modelClass();
+		$this->Tree->order = null;
+		$this->Tree->initialize(2, 3);
+
+		$this->Tree->id = 1;
+		$this->Tree->saveField('flag', 1);
+		$this->Tree->id = 2;
+		$this->Tree->saveField('flag', 1);
+
+		$this->Tree->Behaviors->load('Tree', array('scope' => array('FlagTree.flag' => 1)));
+
+		$result = $this->Tree->generateTreeList();
+		$expected = array(
+			1 => '1. Root',
+			2 => '_1.1'
+		);
+		$this->assertEquals($expected, $result);
+
+		// As string.
+		$this->Tree->Behaviors->load('Tree', array('scope' => 'FlagTree.flag = 1'));
+
+		$result = $this->Tree->generateTreeList();
+		$this->assertEquals($expected, $result);
+
+		// Merging conditions.
+		$result = $this->Tree->generateTreeList(array('FlagTree.id >' => 1));
+		$expected = array(
+			2 => '1.1'
+		);
+		$this->assertEquals($expected, $result);
+	}
+
+/**
+ * testRecoverUsingParentMode method
+ *
+ * @return void
+ */
+	public function testRecoverUsingParentMode() {
+		extract($this->settings);
+		$this->Tree = new $modelClass();
+		$this->Tree->order = null;
+		$this->Tree->initialize(2, 3);
+
+		$this->Tree->Behaviors->load('Tree', array('scope' => 'FlagTree.flag = 1'));
+		$this->Tree->Behaviors->disable('Tree');
+
+		$this->Tree->create();
+		$this->Tree->save(array('name' => 'Main', $parentField => null, $leftField => 0, $rightField => 0, 'flag' => 1));
+		$node1 = $this->Tree->id;
+
+		$this->Tree->create();
+		$this->Tree->save(array('name' => 'About Us', $parentField => $node1, $leftField => 0, $rightField => 0, 'flag' => 1));
+		$node11 = $this->Tree->id;
+
+		$this->Tree->create();
+		$this->Tree->save(array('name' => 'Programs', $parentField => $node1, $leftField => 0, $rightField => 0, 'flag' => 1));
+		$node12 = $this->Tree->id;
+
+		$this->Tree->create();
+		$this->Tree->save(array('name' => 'Mission and History', $parentField => $node11, $leftField => 0, $rightField => 0, 'flag' => 1));
+
+		$this->Tree->create();
+		$this->Tree->save(array('name' => 'Overview', $parentField => $node12, $leftField => 0, $rightField => 0, 'flag' => 1));
+
+		$this->Tree->Behaviors->enable('Tree');
+
+		$result = $this->Tree->verify();
+		$this->assertNotSame($result, true);
+
+		$result = $this->Tree->recover();
+		$this->assertTrue($result);
+
+		$result = $this->Tree->verify();
+		$this->assertTrue($result);
+
+		$result = $this->Tree->find('first', array(
+			'fields' => array('name', $parentField, $leftField, $rightField, 'flag'),
+			'conditions' => array('name' => 'Main'),
+			'recursive' => -1
+		));
+		$expected = array(
+			$modelClass => array(
+				'name' => 'Main',
+				$parentField => null,
+				$leftField => 1,
+				$rightField => 10,
+				'flag' => 1
+			)
+		);
+		$this->assertEquals($expected, $result);
+	}
+
+/**
+ * testRecoverFromMissingParent method
+ *
+ * @return void
+ */
+	public function testRecoverFromMissingParent() {
+		extract($this->settings);
+		$this->Tree = new $modelClass();
+		$this->Tree->order = null;
+		$this->Tree->initialize(2, 2);
+
+		$this->Tree->id = 1;
+		$this->Tree->saveField('flag', 1);
+		$this->Tree->id = 2;
+		$this->Tree->saveField('flag', 1);
+
+		$this->Tree->Behaviors->load('Tree', array('scope' => array('FlagTree.flag' => 1)));
+
+		$result = $this->Tree->findByName('1.1');
+		$this->Tree->updateAll(array($parentField => 999999), array('id' => $result[$modelClass]['id']));
+
+		$result = $this->Tree->verify();
+		$this->assertNotSame($result, true);
+
+		$result = $this->Tree->recover();
+		$this->assertTrue($result);
+
+		$result = $this->Tree->verify();
+		$this->assertTrue($result);
+	}
+
+/**
+ * testDetectInvalidParents method
+ *
+ * @return void
+ */
+	public function testDetectInvalidParents() {
+		extract($this->settings);
+		$this->Tree = new $modelClass();
+		$this->Tree->order = null;
+		$this->Tree->initialize(2, 2);
+
+		$this->Tree->id = 1;
+		$this->Tree->saveField('flag', 1);
+		$this->Tree->id = 2;
+		$this->Tree->saveField('flag', 1);
+
+		$this->Tree->Behaviors->load('Tree', array('scope' => array('FlagTree.flag' => 1)));
+
+		$this->Tree->updateAll(array($parentField => null));
+
+		$result = $this->Tree->verify();
+		$this->assertNotSame($result, true);
+
+		$result = $this->Tree->recover();
+		$this->assertTrue($result);
+
+		$result = $this->Tree->verify();
+		$this->assertTrue($result);
+	}
+
+/**
+ * testDetectInvalidLftsRghts method
+ *
+ * @return void
+ */
+	public function testDetectInvalidLftsRghts() {
+		extract($this->settings);
+		$this->Tree = new $modelClass();
+		$this->Tree->order = null;
+		$this->Tree->initialize(2, 2);
+
+		$this->Tree->id = 1;
+		$this->Tree->saveField('flag', 1);
+		$this->Tree->id = 2;
+		$this->Tree->saveField('flag', 1);
+
+		$this->Tree->Behaviors->load('Tree', array('scope' => array('FlagTree.flag' => 1)));
+
+		$this->Tree->updateAll(array($leftField => 0, $rightField => 0));
+
+		$result = $this->Tree->verify();
+		$this->assertNotSame($result, true);
+
+		$this->Tree->recover();
+
+		$result = $this->Tree->verify();
+		$this->assertTrue($result);
+	}
+
+/**
+ * Reproduces a situation where a single node has lft= rght, and all other lft and rght fields follow sequentially
+ *
+ * @return void
+ */
+	public function testDetectEqualLftsRghts() {
+		extract($this->settings);
+		$this->Tree = new $modelClass();
+		$this->Tree->order = null;
+		$this->Tree->initialize(1, 3);
+
+		$this->Tree->id = 1;
+		$this->Tree->saveField('flag', 1);
+		$this->Tree->id = 2;
+		$this->Tree->saveField('flag', 1);
+
+		$this->Tree->Behaviors->load('Tree', array('scope' => array('FlagTree.flag' => 1)));
+
+		$result = $this->Tree->findByName('1.1');
+		$this->Tree->updateAll(array($rightField => $result[$modelClass][$leftField]), array('id' => $result[$modelClass]['id']));
+		$this->Tree->updateAll(array($leftField => $this->Tree->escapeField($leftField) . ' -1'),
+			array($leftField . ' >' => $result[$modelClass][$leftField]));
+		$this->Tree->updateAll(array($rightField => $this->Tree->escapeField($rightField) . ' -1'),
+			array($rightField . ' >' => $result[$modelClass][$leftField]));
+
+		$result = $this->Tree->verify();
+		$this->assertNotSame($result, true);
+
+		$result = $this->Tree->recover();
+		$this->assertTrue($result);
+
+		$result = $this->Tree->verify();
+		$this->assertTrue($result);
+	}
+
+}

lib/Cake/Test/Case/Model/Behavior/TreeBehaviorTest.php

@@ -0,0 +1,42 @@
+<?php
+/**
+ * Tree Behavior test file - runs all the tree behavior tests
+ *
+ * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
+ * 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://cakephp.org CakePHP(tm) Project
+ * @package       Cake.Test.Case.Model.Behavior
+ * @since         CakePHP(tm) v 2.0
+ * @license       http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+
+/**
+ * Tree Behavior test
+ *
+ * A test group to run all the component parts
+ *
+ * @package       Cake.Test.Case.Model.Behavior
+ */
+class TreeBehaviorTest extends PHPUnit_Framework_TestSuite {
+
+/**
+ * suite method, defines tests for this suite.
+ *
+ * @return void
+ */
+	public static function suite() {
+		$suite = new CakeTestSuite('TreeBehavior tests');
+
+		$suite->addTestFile(CORE_TEST_CASES . DS . 'Model' . DS . 'Behavior' . DS . 'TreeBehaviorNumberTest.php');
+		$suite->addTestFile(CORE_TEST_CASES . DS . 'Model' . DS . 'Behavior' . DS . 'TreeBehaviorScopedTest.php');
+		$suite->addTestFile(CORE_TEST_CASES . DS . 'Model' . DS . 'Behavior' . DS . 'TreeBehaviorAfterTest.php');
+		$suite->addTestFile(CORE_TEST_CASES . DS . 'Model' . DS . 'Behavior' . DS . 'TreeBehaviorUuidTest.php');
+		return $suite;
+	}
+}

lib/Cake/Test/Case/Model/Behavior/TreeBehaviorUuidTest.php

@@ -0,0 +1,298 @@
+<?php
+/**
+ * TreeBehaviorUuidTest file
+ *
+ * Tree test using UUIDs
+ *
+ * CakePHP(tm) Tests <http://book.cakephp.org/2.0/en/development/testing.html>
+ * 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/2.0/en/development/testing.html CakePHP(tm) Tests
+ * @package       Cake.Test.Case.Model.Behavior
+ * @since         CakePHP(tm) v 1.2.0.5330
+ * @license       http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+
+App::uses('Model', 'Model');
+App::uses('AppModel', 'Model');
+App::uses('String', 'Utility');
+
+require_once dirname(dirname(__FILE__)) . DS . 'models.php';
+
+/**
+ * TreeBehaviorUuidTest class
+ *
+ * @package       Cake.Test.Case.Model.Behavior
+ */
+class TreeBehaviorUuidTest extends CakeTestCase {
+
+/**
+ * Whether backup global state for each test method or not
+ *
+ * @var bool
+ */
+	public $backupGlobals = false;
+
+/**
+ * settings property
+ *
+ * @var array
+ */
+	public $settings = array(
+		'modelClass' => 'UuidTree',
+		'leftField' => 'lft',
+		'rightField' => 'rght',
+		'parentField' => 'parent_id'
+	);
+
+/**
+ * fixtures property
+ *
+ * @var array
+ */
+	public $fixtures = array('core.uuid_tree');
+
+/**
+ * testAddWithPreSpecifiedId method
+ *
+ * @return void
+ */
+	public function testAddWithPreSpecifiedId() {
+		extract($this->settings);
+		$this->Tree = new $modelClass();
+		$this->Tree->order = null;
+		$this->Tree->initialize(2, 2);
+
+		$data = $this->Tree->find('first', array(
+			'fields' => array('id'),
+			'conditions' => array($modelClass . '.name' => '1.1')
+		));
+
+		$id = String::uuid();
+		$this->Tree->create();
+		$result = $this->Tree->save(array($modelClass => array(
+			'id' => $id,
+			'name' => 'testAddMiddle',
+			$parentField => $data[$modelClass]['id'])
+		));
+		$expected = array_merge(
+			array($modelClass => array('id' => $id, 'name' => 'testAddMiddle', $parentField => '2')),
+			$result
+		);
+		$this->assertSame($expected, $result);
+
+		$this->assertTrue($this->Tree->verify());
+	}
+
+/**
+ * testMovePromote method
+ *
+ * @return void
+ */
+	public function testMovePromote() {
+		extract($this->settings);
+		$this->Tree = new $modelClass();
+		$this->Tree->order = null;
+		$this->Tree->initialize(2, 2);
+		$this->Tree->id = null;
+
+		$parent = $this->Tree->find('first', array('conditions' => array($modelClass . '.name' => '1. Root')));
+		$parentId = $parent[$modelClass]['id'];
+
+		$data = $this->Tree->find('first', array('fields' => array('id'), 'conditions' => array($modelClass . '.name' => '1.1.1')));
+		$this->Tree->id = $data[$modelClass]['id'];
+		$this->Tree->saveField($parentField, $parentId);
+		$direct = $this->Tree->children($parentId, true, array('name', $leftField, $rightField));
+		$expected = array(array($modelClass => array('name' => '1.1', $leftField => 2, $rightField => 5)),
+			array($modelClass => array('name' => '1.2', $leftField => 6, $rightField => 11)),
+			array($modelClass => array('name' => '1.1.1', $leftField => 12, $rightField => 13)));
+		$this->assertEquals($expected, $direct);
+		$validTree = $this->Tree->verify();
+		$this->assertTrue($validTree);
+	}
+
+/**
+ * testMoveWithWhitelist method
+ *
+ * @return void
+ */
+	public function testMoveWithWhitelist() {
+		extract($this->settings);
+		$this->Tree = new $modelClass();
+		$this->Tree->order = null;
+		$this->Tree->initialize(2, 2);
+		$this->Tree->id = null;
+
+		$parent = $this->Tree->find('first', array('conditions' => array($modelClass . '.name' => '1. Root')));
+		$parentId = $parent[$modelClass]['id'];
+
+		$data = $this->Tree->find('first', array('fields' => array('id'), 'conditions' => array($modelClass . '.name' => '1.1.1')));
+		$this->Tree->id = $data[$modelClass]['id'];
+		$this->Tree->whitelist = array($parentField, 'name', 'description');
+		$this->Tree->saveField($parentField, $parentId);
+
+		$result = $this->Tree->children($parentId, true, array('name', $leftField, $rightField));
+		$expected = array(array($modelClass => array('name' => '1.1', $leftField => 2, $rightField => 5)),
+			array($modelClass => array('name' => '1.2', $leftField => 6, $rightField => 11)),
+			array($modelClass => array('name' => '1.1.1', $leftField => 12, $rightField => 13)));
+		$this->assertEquals($expected, $result);
+		$this->assertTrue($this->Tree->verify());
+	}
+
+/**
+ * testRemoveNoChildren method
+ *
+ * @return void
+ */
+	public function testRemoveNoChildren() {
+		extract($this->settings);
+		$this->Tree = new $modelClass();
+		$this->Tree->order = null;
+		$this->Tree->initialize(2, 2);
+		$initialCount = $this->Tree->find('count');
+
+		$result = $this->Tree->findByName('1.1.1');
+		$this->Tree->removeFromTree($result[$modelClass]['id']);
+
+		$laterCount = $this->Tree->find('count');
+		$this->assertEquals($initialCount, $laterCount);
+
+		$nodes = $this->Tree->find('list', array('order' => $leftField));
+		$expected = array(
+			'1. Root',
+			'1.1',
+			'1.1.2',
+			'1.2',
+			'1.2.1',
+			'1.2.2',
+			'1.1.1',
+		);
+
+		$this->assertEquals($expected, array_values($nodes));
+
+		$validTree = $this->Tree->verify();
+		$this->assertTrue($validTree);
+	}
+
+/**
+ * testRemoveAndDeleteNoChildren method
+ *
+ * @return void
+ */
+	public function testRemoveAndDeleteNoChildren() {
+		extract($this->settings);
+		$this->Tree = new $modelClass();
+		$this->Tree->order = null;
+		$this->Tree->initialize(2, 2);
+		$initialCount = $this->Tree->find('count');
+
+		$result = $this->Tree->findByName('1.1.1');
+		$this->Tree->removeFromTree($result[$modelClass]['id'], true);
+
+		$laterCount = $this->Tree->find('count');
+		$this->assertEquals($initialCount - 1, $laterCount);
+
+		$nodes = $this->Tree->find('list', array('order' => $leftField));
+		$expected = array(
+			'1. Root',
+			'1.1',
+			'1.1.2',
+			'1.2',
+			'1.2.1',
+			'1.2.2',
+		);
+		$this->assertEquals($expected, array_values($nodes));
+
+		$validTree = $this->Tree->verify();
+		$this->assertTrue($validTree);
+	}
+
+/**
+ * testChildren method
+ *
+ * @return void
+ */
+	public function testChildren() {
+		extract($this->settings);
+		$this->Tree = new $modelClass();
+		$this->Tree->order = null;
+		$this->Tree->initialize(2, 2);
+
+		$data = $this->Tree->find('first', array('conditions' => array($modelClass . '.name' => '1. Root')));
+		$this->Tree->id = $data[$modelClass]['id'];
+
+		$direct = $this->Tree->children(null, true, array('name', $leftField, $rightField));
+		$expected = array(array($modelClass => array('name' => '1.1', $leftField => 2, $rightField => 7)),
+			array($modelClass => array('name' => '1.2', $leftField => 8, $rightField => 13)));
+		$this->assertEquals($expected, $direct);
+
+		$total = $this->Tree->children(null, null, array('name', $leftField, $rightField));
+		$expected = array(array($modelClass => array('name' => '1.1', $leftField => 2, $rightField => 7)),
+			array($modelClass => array('name' => '1.1.1', $leftField => 3, $rightField => 4)),
+			array($modelClass => array('name' => '1.1.2', $leftField => 5, $rightField => 6)),
+			array($modelClass => array('name' => '1.2', $leftField => 8, $rightField => 13)),
+			array($modelClass => array('name' => '1.2.1', $leftField => 9, $rightField => 10)),
+			array($modelClass => array('name' => '1.2.2', $leftField => 11, $rightField => 12)));
+		$this->assertEquals($expected, $total);
+	}
+
+/**
+ * testNoAmbiguousColumn method
+ *
+ * @return void
+ */
+	public function testNoAmbiguousColumn() {
+		extract($this->settings);
+		$this->Tree = new $modelClass();
+		$this->Tree->order = null;
+		$this->Tree->initialize(2, 2);
+
+		$this->Tree->bindModel(array('belongsTo' => array('Dummy' =>
+			array('className' => $modelClass, 'foreignKey' => $parentField, 'conditions' => array('Dummy.id' => null)))), false);
+
+		$data = $this->Tree->find('first', array(
+			'conditions' => array($modelClass . '.name' => '1. Root'),
+			'recursive' => -1
+		));
+		$this->Tree->id = $data[$modelClass]['id'];
+
+		$direct = $this->Tree->children(null, true, array('name', $leftField, $rightField));
+		$expected = array(array($modelClass => array('name' => '1.1', $leftField => 2, $rightField => 7)),
+			array($modelClass => array('name' => '1.2', $leftField => 8, $rightField => 13)));
+		$this->assertEquals($expected, $direct);
+
+		$total = $this->Tree->children(null, null, array('name', $leftField, $rightField));
+		$expected = array(
+			array($modelClass => array('name' => '1.1', $leftField => 2, $rightField => 7)),
+			array($modelClass => array('name' => '1.1.1', $leftField => 3, $rightField => 4)),
+			array($modelClass => array('name' => '1.1.2', $leftField => 5, $rightField => 6)),
+			array($modelClass => array('name' => '1.2', $leftField => 8, $rightField => 13)),
+			array($modelClass => array('name' => '1.2.1', $leftField => 9, $rightField => 10)),
+			array($modelClass => array('name' => '1.2.2', $leftField => 11, $rightField => 12))
+		);
+		$this->assertEquals($expected, $total);
+	}
+
+/**
+ * testGenerateTreeListWithSelfJoin method
+ *
+ * @return void
+ */
+	public function testGenerateTreeListWithSelfJoin() {
+		extract($this->settings);
+		$this->Tree = new $modelClass();
+		$this->Tree->order = null;
+		$this->Tree->bindModel(array('belongsTo' => array('Dummy' =>
+			array('className' => $modelClass, 'foreignKey' => $parentField, 'conditions' => array('Dummy.id' => null)))), false);
+		$this->Tree->initialize(2, 2);
+
+		$result = $this->Tree->generateTreeList();
+		$expected = array('1. Root', '_1.1', '__1.1.1', '__1.1.2', '_1.2', '__1.2.1', '__1.2.2');
+		$this->assertSame($expected, array_values($result));
+	}
+}

lib/Cake/Test/Case/Model/ConnectionManagerTest.php

@@ -0,0 +1,345 @@
+<?php
+/**
+ * Connection Manager tests
+ *
+ * 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/2.0/en/development/testing.html CakePHP(tm) Tests
+ * @package       Cake.Test.Case.Model
+ * @since         CakePHP(tm) v 1.2.0.5550
+ * @license       http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+
+App::uses('ConnectionManager', 'Model');
+
+/**
+ * ConnectionManagerTest
+ *
+ * @package       Cake.Test.Case.Model
+ */
+class ConnectionManagerTest extends CakeTestCase {
+
+/**
+ * tearDown method
+ *
+ * @return void
+ */
+	public function tearDown() {
+		parent::tearDown();
+		CakePlugin::unload();
+	}
+
+/**
+ * testEnumConnectionObjects method
+ *
+ * @return void
+ */
+	public function testEnumConnectionObjects() {
+		$sources = ConnectionManager::enumConnectionObjects();
+		$this->assertTrue(count($sources) >= 1);
+
+		$connections = array('default', 'test', 'test');
+		$this->assertTrue(count(array_intersect(array_keys($sources), $connections)) >= 1);
+	}
+
+/**
+ * testGetDataSource method
+ *
+ * @return void
+ */
+	public function testGetDataSource() {
+		App::build(array(
+			'Model/Datasource' => array(
+				CAKE . 'Test' . DS . 'test_app' . DS . 'Model' . DS . 'Datasource' . DS
+			)
+		));
+
+		$name = 'test_get_datasource';
+		$config = array('datasource' => 'Test2Source');
+
+		ConnectionManager::create($name, $config);
+		$connections = ConnectionManager::enumConnectionObjects();
+		$this->assertTrue((bool)(count(array_keys($connections) >= 1)));
+
+		$source = ConnectionManager::getDataSource('test_get_datasource');
+		$this->assertTrue(is_object($source));
+		ConnectionManager::drop('test_get_datasource');
+	}
+
+/**
+ * testGetDataSourceException() method
+ *
+ * @return void
+ * @expectedException MissingDatasourceConfigException
+ */
+	public function testGetDataSourceException() {
+		ConnectionManager::getDataSource('non_existent_source');
+	}
+
+/**
+ * testGetPluginDataSource method
+ *
+ * @return void
+ */
+	public function testGetPluginDataSource() {
+		App::build(array(
+			'Plugin' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'Plugin' . DS)
+		), App::RESET);
+		CakePlugin::load('TestPlugin');
+		$name = 'test_source';
+		$config = array('datasource' => 'TestPlugin.TestSource');
+		$connection = ConnectionManager::create($name, $config);
+
+		$this->assertTrue(class_exists('TestSource'));
+		$this->assertEquals($connection->configKeyName, $name);
+		$this->assertEquals($connection->config, $config);
+
+		ConnectionManager::drop($name);
+	}
+
+/**
+ * testGetPluginDataSourceAndPluginDriver method
+ *
+ * @return void
+ */
+	public function testGetPluginDataSourceAndPluginDriver() {
+		App::build(array(
+			'Plugin' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'Plugin' . DS)
+		), App::RESET);
+		CakePlugin::load('TestPlugin');
+		$name = 'test_plugin_source_and_driver';
+		$config = array('datasource' => 'TestPlugin.Database/TestDriver');
+
+		$connection = ConnectionManager::create($name, $config);
+
+		$this->assertTrue(class_exists('TestSource'));
+		$this->assertTrue(class_exists('TestDriver'));
+		$this->assertEquals($connection->configKeyName, $name);
+		$this->assertEquals($connection->config, $config);
+
+		ConnectionManager::drop($name);
+	}
+
+/**
+ * testGetLocalDataSourceAndPluginDriver method
+ *
+ * @return void
+ */
+	public function testGetLocalDataSourceAndPluginDriver() {
+		App::build(array(
+			'Plugin' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'Plugin' . DS)
+		));
+		CakePlugin::load('TestPlugin');
+		$name = 'test_local_source_and_plugin_driver';
+		$config = array('datasource' => 'TestPlugin.Database/DboDummy');
+
+		$connection = ConnectionManager::create($name, $config);
+
+		$this->assertTrue(class_exists('DboSource'));
+		$this->assertTrue(class_exists('DboDummy'));
+		$this->assertEquals($connection->configKeyName, $name);
+
+		ConnectionManager::drop($name);
+	}
+
+/**
+ * testGetPluginDataSourceAndLocalDriver method
+ *
+ * @return void
+ */
+	public function testGetPluginDataSourceAndLocalDriver() {
+		App::build(array(
+			'Plugin' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'Plugin' . DS),
+			'Model/Datasource/Database' => array(
+				CAKE . 'Test' . DS . 'test_app' . DS . 'Model' . DS . 'Datasource' . DS . 'Database' . DS
+			)
+		));
+
+		$name = 'test_plugin_source_and_local_driver';
+		$config = array('datasource' => 'Database/TestLocalDriver');
+
+		$connection = ConnectionManager::create($name, $config);
+
+		$this->assertTrue(class_exists('TestSource'));
+		$this->assertTrue(class_exists('TestLocalDriver'));
+		$this->assertEquals($connection->configKeyName, $name);
+		$this->assertEquals($connection->config, $config);
+		ConnectionManager::drop($name);
+	}
+
+/**
+ * testSourceList method
+ *
+ * @return void
+ */
+	public function testSourceList() {
+		ConnectionManager::getDataSource('test');
+		$sources = ConnectionManager::sourceList();
+		$this->assertTrue(count($sources) >= 1);
+		$this->assertTrue(in_array('test', array_keys($sources)));
+	}
+
+/**
+ * testGetSourceName method
+ *
+ * @return void
+ */
+	public function testGetSourceName() {
+		$source = ConnectionManager::getDataSource('test');
+		$result = ConnectionManager::getSourceName($source);
+
+		$this->assertEquals('test', $result);
+
+		$source = new StdClass();
+		$result = ConnectionManager::getSourceName($source);
+		$this->assertNull($result);
+	}
+
+/**
+ * testLoadDataSource method
+ *
+ * @return void
+ */
+	public function testLoadDataSource() {
+		$connections = array(
+			array('classname' => 'Mysql', 'filename' => 'Mysql', 'package' => 'Database'),
+			array('classname' => 'Postgres', 'filename' => 'Postgres', 'package' => 'Database'),
+			array('classname' => 'Sqlite', 'filename' => 'Sqlite', 'package' => 'Database'),
+		);
+
+		foreach ($connections as $connection) {
+			$exists = class_exists($connection['classname']);
+			$loaded = ConnectionManager::loadDataSource($connection);
+			$this->assertEquals($loaded, !$exists, "Failed loading the {$connection['classname']} datasource");
+		}
+	}
+
+/**
+ * testLoadDataSourceException() method
+ *
+ * @return void
+ * @expectedException MissingDatasourceException
+ */
+	public function testLoadDataSourceException() {
+		$connection = array('classname' => 'NonExistentDataSource', 'filename' => 'non_existent');
+		ConnectionManager::loadDataSource($connection);
+	}
+
+/**
+ * testCreateDataSource method
+ *
+ * @return void
+ */
+	public function testCreateDataSourceWithIntegrationTests() {
+		$name = 'test_created_connection';
+
+		$connections = ConnectionManager::enumConnectionObjects();
+		$this->assertTrue((bool)(count(array_keys($connections) >= 1)));
+
+		$source = ConnectionManager::getDataSource('test');
+		$this->assertTrue(is_object($source));
+
+		$config = $source->config;
+		$connection = ConnectionManager::create($name, $config);
+
+		$this->assertTrue(is_object($connection));
+		$this->assertEquals($name, $connection->configKeyName);
+		$this->assertEquals($name, ConnectionManager::getSourceName($connection));
+
+		$source = ConnectionManager::create(null, array());
+		$this->assertEquals(null, $source);
+
+		$source = ConnectionManager::create('another_test', array());
+		$this->assertEquals(null, $source);
+
+		$config = array('classname' => 'DboMysql', 'filename' => 'dbo' . DS . 'dbo_mysql');
+		$source = ConnectionManager::create(null, $config);
+		$this->assertEquals(null, $source);
+	}
+
+/**
+ * testConnectionData method
+ *
+ * @return void
+ */
+	public function testConnectionData() {
+		App::build(array(
+			'Plugin' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'Plugin' . DS),
+			'Model/Datasource' => array(
+				CAKE . 'Test' . DS . 'test_app' . DS . 'Model' . DS . 'Datasource' . DS
+			)
+		), App::RESET);
+		CakePlugin::load(array('TestPlugin', 'TestPluginTwo'));
+		$expected = array(
+			'datasource' => 'Test2Source'
+		);
+
+		ConnectionManager::create('connection1', array('datasource' => 'Test2Source'));
+		$connections = ConnectionManager::enumConnectionObjects();
+		$this->assertEquals($expected, $connections['connection1']);
+		ConnectionManager::drop('connection1');
+
+		ConnectionManager::create('connection2', array('datasource' => 'Test2Source'));
+		$connections = ConnectionManager::enumConnectionObjects();
+		$this->assertEquals($expected, $connections['connection2']);
+		ConnectionManager::drop('connection2');
+
+		ConnectionManager::create('connection3', array('datasource' => 'TestPlugin.TestSource'));
+		$connections = ConnectionManager::enumConnectionObjects();
+		$expected['datasource'] = 'TestPlugin.TestSource';
+		$this->assertEquals($expected, $connections['connection3']);
+		ConnectionManager::drop('connection3');
+
+		ConnectionManager::create('connection4', array('datasource' => 'TestPlugin.TestSource'));
+		$connections = ConnectionManager::enumConnectionObjects();
+		$this->assertEquals($expected, $connections['connection4']);
+		ConnectionManager::drop('connection4');
+
+		ConnectionManager::create('connection5', array('datasource' => 'Test2OtherSource'));
+		$connections = ConnectionManager::enumConnectionObjects();
+		$expected['datasource'] = 'Test2OtherSource';
+		$this->assertEquals($expected, $connections['connection5']);
+		ConnectionManager::drop('connection5');
+
+		ConnectionManager::create('connection6', array('datasource' => 'Test2OtherSource'));
+		$connections = ConnectionManager::enumConnectionObjects();
+		$this->assertEquals($expected, $connections['connection6']);
+		ConnectionManager::drop('connection6');
+
+		ConnectionManager::create('connection7', array('datasource' => 'TestPlugin.TestOtherSource'));
+		$connections = ConnectionManager::enumConnectionObjects();
+		$expected['datasource'] = 'TestPlugin.TestOtherSource';
+		$this->assertEquals($expected, $connections['connection7']);
+		ConnectionManager::drop('connection7');
+
+		ConnectionManager::create('connection8', array('datasource' => 'TestPlugin.TestOtherSource'));
+		$connections = ConnectionManager::enumConnectionObjects();
+		$this->assertEquals($expected, $connections['connection8']);
+		ConnectionManager::drop('connection8');
+	}
+
+/**
+ * Tests that a connection configuration can be deleted in runtime
+ *
+ * @return void
+ */
+	public function testDrop() {
+		App::build(array(
+			'Model/Datasource' => array(
+				CAKE . 'Test' . DS . 'test_app' . DS . 'Model' . DS . 'Datasource' . DS
+			)
+		));
+		ConnectionManager::create('droppable', array('datasource' => 'Test2Source'));
+		$connections = ConnectionManager::enumConnectionObjects();
+		$this->assertEquals(array('datasource' => 'Test2Source'), $connections['droppable']);
+
+		$this->assertTrue(ConnectionManager::drop('droppable'));
+		$connections = ConnectionManager::enumConnectionObjects();
+		$this->assertFalse(isset($connections['droppable']));
+	}
+}

lib/Cake/Test/Case/Model/Datasource/CakeSessionTest.php

@@ -0,0 +1,786 @@
+<?php
+/**
+ * SessionTest file
+ *
+ * CakePHP(tm) Tests <http://book.cakephp.org/2.0/en/development/testing.html>
+ * 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/2.0/en/development/testing.html CakePHP(tm) Tests
+ * @package       Cake.Test.Case.Model.Datasource
+ * @since         CakePHP(tm) v 1.2.0.4206
+ * @license       http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+
+App::uses('CakeSession', 'Model/Datasource');
+App::uses('DatabaseSession', 'Model/Datasource/Session');
+App::uses('CacheSession', 'Model/Datasource/Session');
+
+/**
+ * Class TestCakeSession
+ *
+ * @package       Cake.Test.Case.Model.Datasource
+ */
+class TestCakeSession extends CakeSession {
+
+	public static function setUserAgent($value) {
+		self::$_userAgent = $value;
+	}
+
+	public static function setHost($host) {
+		self::_setHost($host);
+	}
+
+}
+
+/**
+ * Class TestCacheSession
+ *
+ * @package       Cake.Test.Case.Model.Datasource
+ */
+class TestCacheSession extends CacheSession {
+
+	protected function _writeSession() {
+		return true;
+	}
+
+}
+
+/**
+ * Class TestDatabaseSession
+ *
+ * @package       Cake.Test.Case.Model.Datasource
+ */
+class TestDatabaseSession extends DatabaseSession {
+
+	protected function _writeSession() {
+		return true;
+	}
+
+}
+
+/**
+ * CakeSessionTest class
+ *
+ * @package       Cake.Test.Case.Model.Datasource
+ */
+class CakeSessionTest extends CakeTestCase {
+
+	protected static $_gcDivisor;
+
+/**
+ * Fixtures used in the SessionTest
+ *
+ * @var array
+ */
+	public $fixtures = array('core.session');
+
+/**
+ * setup before class.
+ *
+ * @return void
+ */
+	public static function setupBeforeClass() {
+		// Make sure garbage colector will be called
+		self::$_gcDivisor = ini_get('session.gc_divisor');
+		ini_set('session.gc_divisor', '1');
+	}
+
+/**
+ * teardown after class
+ *
+ * @return void
+ */
+	public static function teardownAfterClass() {
+		// Revert to the default setting
+		ini_set('session.gc_divisor', self::$_gcDivisor);
+	}
+
+/**
+ * setUp method
+ *
+ * @return void
+ */
+	public function setUp() {
+		parent::setUp();
+		Configure::write('Session', array(
+			'defaults' => 'php',
+			'cookie' => 'cakephp',
+			'timeout' => 120,
+			'cookieTimeout' => 120,
+			'ini' => array(),
+		));
+	}
+
+/**
+ * tearDown method
+ *
+ * @return void
+ */
+	public function tearDown() {
+		if (TestCakeSession::started()) {
+			session_write_close();
+		}
+		unset($_SESSION);
+		parent::tearDown();
+	}
+
+/**
+ * test setting ini properties with Session configuration.
+ *
+ * @return void
+ */
+	public function testSessionConfigIniSetting() {
+		$_SESSION = null;
+
+		Configure::write('Session', array(
+			'cookie' => 'test',
+			'checkAgent' => false,
+			'timeout' => 86400,
+			'ini' => array(
+				'session.referer_check' => 'example.com',
+				'session.use_trans_sid' => false
+			)
+		));
+		TestCakeSession::start();
+		$this->assertEquals('', ini_get('session.use_trans_sid'), 'Ini value is incorrect');
+		$this->assertEquals('example.com', ini_get('session.referer_check'), 'Ini value is incorrect');
+		$this->assertEquals('test', ini_get('session.name'), 'Ini value is incorrect');
+	}
+
+/**
+ * testSessionPath
+ *
+ * @return void
+ */
+	public function testSessionPath() {
+		TestCakeSession::init('/index.php');
+		$this->assertEquals('/', TestCakeSession::$path);
+
+		TestCakeSession::init('/sub_dir/index.php');
+		$this->assertEquals('/sub_dir/', TestCakeSession::$path);
+	}
+
+/**
+ * testCakeSessionPathEmpty
+ *
+ * @return void
+ */
+	public function testCakeSessionPathEmpty() {
+		TestCakeSession::init('');
+		$this->assertEquals('/', TestCakeSession::$path, 'Session path is empty, with "" as $base needs to be /');
+	}
+
+/**
+ * testCakeSessionPathContainsParams
+ *
+ * @return void
+ */
+	public function testCakeSessionPathContainsQuestion() {
+		TestCakeSession::init('/index.php?');
+		$this->assertEquals('/', TestCakeSession::$path);
+	}
+
+/**
+ * testSetHost
+ *
+ * @return void
+ */
+	public function testSetHost() {
+		TestCakeSession::init();
+		TestCakeSession::setHost('cakephp.org');
+		$this->assertEquals('cakephp.org', TestCakeSession::$host);
+	}
+
+/**
+ * testSetHostWithPort
+ *
+ * @return void
+ */
+	public function testSetHostWithPort() {
+		TestCakeSession::init();
+		TestCakeSession::setHost('cakephp.org:443');
+		$this->assertEquals('cakephp.org', TestCakeSession::$host);
+	}
+
+/**
+ * test valid with bogus user agent.
+ *
+ * @return void
+ */
+	public function testValidBogusUserAgent() {
+		Configure::write('Session.checkAgent', true);
+		TestCakeSession::start();
+		$this->assertTrue(TestCakeSession::valid(), 'Newly started session should be valid');
+
+		TestCakeSession::userAgent('bogus!');
+		$this->assertFalse(TestCakeSession::valid(), 'user agent mismatch should fail.');
+	}
+
+/**
+ * test valid with bogus user agent.
+ *
+ * @return void
+ */
+	public function testValidTimeExpiry() {
+		Configure::write('Session.checkAgent', true);
+		TestCakeSession::start();
+		$this->assertTrue(TestCakeSession::valid(), 'Newly started session should be valid');
+
+		TestCakeSession::$time = strtotime('next year');
+		$this->assertFalse(TestCakeSession::valid(), 'time should cause failure.');
+	}
+
+/**
+ * testCheck method
+ *
+ * @return void
+ */
+	public function testCheck() {
+		TestCakeSession::write('SessionTestCase', 'value');
+		$this->assertTrue(TestCakeSession::check('SessionTestCase'));
+
+		$this->assertFalse(TestCakeSession::check('NotExistingSessionTestCase'));
+	}
+
+/**
+ * testSimpleRead method
+ *
+ * @return void
+ */
+	public function testSimpleRead() {
+		TestCakeSession::write('testing', '1,2,3');
+		$result = TestCakeSession::read('testing');
+		$this->assertEquals('1,2,3', $result);
+
+		TestCakeSession::write('testing', array('1' => 'one', '2' => 'two', '3' => 'three'));
+		$result = TestCakeSession::read('testing.1');
+		$this->assertEquals('one', $result);
+
+		$result = TestCakeSession::read('testing');
+		$this->assertEquals(array('1' => 'one', '2' => 'two', '3' => 'three'), $result);
+
+		$result = TestCakeSession::read();
+		$this->assertTrue(isset($result['testing']));
+		$this->assertTrue(isset($result['Config']));
+		$this->assertTrue(isset($result['Config']['userAgent']));
+
+		TestCakeSession::write('This.is.a.deep.array.my.friend', 'value');
+		$result = TestCakeSession::read('This.is.a.deep.array.my.friend');
+		$this->assertEquals('value', $result);
+	}
+
+/**
+ * testReadyEmpty
+ *
+ * @return void
+ */
+	public function testReadyEmpty() {
+		$this->assertFalse(TestCakeSession::read(''));
+	}
+
+/**
+ * test writing a hash of values/
+ *
+ * @return void
+ */
+	public function testWriteArray() {
+		$result = TestCakeSession::write(array(
+			'one' => 1,
+			'two' => 2,
+			'three' => array('something'),
+			'null' => null
+		));
+		$this->assertTrue($result);
+		$this->assertEquals(1, TestCakeSession::read('one'));
+		$this->assertEquals(array('something'), TestCakeSession::read('three'));
+		$this->assertEquals(null, TestCakeSession::read('null'));
+	}
+
+/**
+ * testWriteEmptyKey
+ *
+ * @return void
+ */
+	public function testWriteEmptyKey() {
+		$this->assertFalse(TestCakeSession::write('', 'graham'));
+		$this->assertFalse(TestCakeSession::write('', ''));
+		$this->assertFalse(TestCakeSession::write(''));
+	}
+
+/**
+ * Test overwriting a string value as if it were an array.
+ *
+ * @return void
+ */
+	public function testWriteOverwriteStringValue() {
+		TestCakeSession::write('Some.string', 'value');
+		$this->assertEquals('value', TestCakeSession::read('Some.string'));
+
+		TestCakeSession::write('Some.string.array', array('values'));
+		$this->assertEquals(
+			array('values'),
+			TestCakeSession::read('Some.string.array')
+		);
+	}
+
+/**
+ * testId method
+ *
+ * @return void
+ */
+	public function testId() {
+		TestCakeSession::destroy();
+
+		$result = TestCakeSession::id();
+		$expected = session_id();
+		$this->assertEquals($expected, $result);
+
+		TestCakeSession::id('MySessionId');
+		$result = TestCakeSession::id();
+		$this->assertEquals('MySessionId', $result);
+	}
+
+/**
+ * testStarted method
+ *
+ * @return void
+ */
+	public function testStarted() {
+		unset($_SESSION);
+		$_SESSION = null;
+
+		$this->assertFalse(TestCakeSession::started());
+		$this->assertTrue(TestCakeSession::start());
+		$this->assertTrue(TestCakeSession::started());
+	}
+
+/**
+ * testDel method
+ *
+ * @return void
+ */
+	public function testDelete() {
+		$this->assertTrue(TestCakeSession::write('Delete.me', 'Clearing out'));
+		$this->assertTrue(TestCakeSession::delete('Delete.me'));
+		$this->assertFalse(TestCakeSession::check('Delete.me'));
+		$this->assertTrue(TestCakeSession::check('Delete'));
+
+		$this->assertTrue(TestCakeSession::write('Clearing.sale', 'everything must go'));
+		$this->assertTrue(TestCakeSession::delete('Clearing'));
+		$this->assertFalse(TestCakeSession::check('Clearing.sale'));
+		$this->assertFalse(TestCakeSession::check('Clearing'));
+	}
+
+/**
+ * testDestroy method
+ *
+ * @return void
+ */
+	public function testDestroy() {
+		TestCakeSession::write('bulletProof', 'invincible');
+		$id = TestCakeSession::id();
+		TestCakeSession::destroy();
+
+		$this->assertFalse(TestCakeSession::check('bulletProof'));
+		$this->assertNotEquals(TestCakeSession::id(), $id);
+	}
+
+/**
+ * testCheckingSavedEmpty method
+ *
+ * @return void
+ */
+	public function testCheckingSavedEmpty() {
+		$this->assertTrue(TestCakeSession::write('SessionTestCase', 0));
+		$this->assertTrue(TestCakeSession::check('SessionTestCase'));
+
+		$this->assertTrue(TestCakeSession::write('SessionTestCase', '0'));
+		$this->assertTrue(TestCakeSession::check('SessionTestCase'));
+
+		$this->assertTrue(TestCakeSession::write('SessionTestCase', false));
+		$this->assertTrue(TestCakeSession::check('SessionTestCase'));
+
+		$this->assertTrue(TestCakeSession::write('SessionTestCase', null));
+		$this->assertFalse(TestCakeSession::check('SessionTestCase'));
+	}
+
+/**
+ * testCheckKeyWithSpaces method
+ *
+ * @return void
+ */
+	public function testCheckKeyWithSpaces() {
+		$this->assertTrue(TestCakeSession::write('Session Test', "test"));
+		$this->assertTrue(TestCakeSession::check('Session Test'));
+		TestCakeSession::delete('Session Test');
+
+		$this->assertTrue(TestCakeSession::write('Session Test.Test Case', "test"));
+		$this->assertTrue(TestCakeSession::check('Session Test.Test Case'));
+	}
+
+/**
+ * testCheckEmpty
+ *
+ * @return void
+ */
+	public function testCheckEmpty() {
+		$this->assertFalse(TestCakeSession::check());
+	}
+
+/**
+ * test key exploitation
+ *
+ * @return void
+ */
+	public function testKeyExploit() {
+		$key = "a'] = 1; phpinfo(); \$_SESSION['a";
+		$result = TestCakeSession::write($key, 'haxored');
+		$this->assertFalse($result);
+
+		$result = TestCakeSession::read($key);
+		$this->assertNull($result);
+	}
+
+/**
+ * testReadingSavedEmpty method
+ *
+ * @return void
+ */
+	public function testReadingSavedEmpty() {
+		TestCakeSession::write('SessionTestCase', 0);
+		$this->assertEquals(0, TestCakeSession::read('SessionTestCase'));
+
+		TestCakeSession::write('SessionTestCase', '0');
+		$this->assertEquals('0', TestCakeSession::read('SessionTestCase'));
+		$this->assertFalse(TestCakeSession::read('SessionTestCase') === 0);
+
+		TestCakeSession::write('SessionTestCase', false);
+		$this->assertFalse(TestCakeSession::read('SessionTestCase'));
+
+		TestCakeSession::write('SessionTestCase', null);
+		$this->assertEquals(null, TestCakeSession::read('SessionTestCase'));
+	}
+
+/**
+ * testCheckUserAgentFalse method
+ *
+ * @return void
+ */
+	public function testCheckUserAgentFalse() {
+		Configure::write('Session.checkAgent', false);
+		TestCakeSession::setUserAgent(md5('http://randomdomainname.com' . Configure::read('Security.salt')));
+		$this->assertTrue(TestCakeSession::valid());
+	}
+
+/**
+ * testCheckUserAgentTrue method
+ *
+ * @return void
+ */
+	public function testCheckUserAgentTrue() {
+		Configure::write('Session.checkAgent', true);
+		TestCakeSession::$error = false;
+		$agent = md5('http://randomdomainname.com' . Configure::read('Security.salt'));
+
+		TestCakeSession::write('Config.userAgent', md5('Hacking you!'));
+		TestCakeSession::setUserAgent($agent);
+		$this->assertFalse(TestCakeSession::valid());
+	}
+
+/**
+ * testReadAndWriteWithCakeStorage method
+ *
+ * @return void
+ */
+	public function testReadAndWriteWithCakeStorage() {
+		Configure::write('Session.defaults', 'cake');
+
+		TestCakeSession::init();
+		TestCakeSession::start();
+
+		TestCakeSession::write('SessionTestCase', 0);
+		$this->assertEquals(0, TestCakeSession::read('SessionTestCase'));
+
+		TestCakeSession::write('SessionTestCase', '0');
+		$this->assertEquals('0', TestCakeSession::read('SessionTestCase'));
+		$this->assertFalse(TestCakeSession::read('SessionTestCase') === 0);
+
+		TestCakeSession::write('SessionTestCase', false);
+		$this->assertFalse(TestCakeSession::read('SessionTestCase'));
+
+		TestCakeSession::write('SessionTestCase', null);
+		$this->assertEquals(null, TestCakeSession::read('SessionTestCase'));
+
+		TestCakeSession::write('SessionTestCase', 'This is a Test');
+		$this->assertEquals('This is a Test', TestCakeSession::read('SessionTestCase'));
+
+		TestCakeSession::write('SessionTestCase', 'This is a Test');
+		TestCakeSession::write('SessionTestCase', 'This was updated');
+		$this->assertEquals('This was updated', TestCakeSession::read('SessionTestCase'));
+
+		TestCakeSession::destroy();
+		$this->assertNull(TestCakeSession::read('SessionTestCase'));
+	}
+
+/**
+ * test using a handler from app/Model/Datasource/Session.
+ *
+ * @return void
+ */
+	public function testUsingAppLibsHandler() {
+		App::build(array(
+			'Model/Datasource/Session' => array(
+				CAKE . 'Test' . DS . 'test_app' . DS . 'Model' . DS . 'Datasource' . DS . 'Session' . DS
+			),
+			'Plugin' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'Plugin' . DS)
+		), App::RESET);
+		Configure::write('Session', array(
+			'defaults' => 'cake',
+			'handler' => array(
+				'engine' => 'TestAppLibSession'
+			)
+		));
+
+		TestCakeSession::start();
+		$this->assertTrue(TestCakeSession::started());
+
+		TestCakeSession::destroy();
+		$this->assertFalse(TestCakeSession::started());
+
+		App::build();
+	}
+
+/**
+ * test using a handler from a plugin.
+ *
+ * @return void
+ */
+	public function testUsingPluginHandler() {
+		App::build(array(
+			'Plugin' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'Plugin' . DS)
+		), App::RESET);
+		CakePlugin::load('TestPlugin');
+
+		Configure::write('Session', array(
+			'defaults' => 'cake',
+			'handler' => array(
+				'engine' => 'TestPlugin.TestPluginSession'
+			)
+		));
+
+		TestCakeSession::start();
+		$this->assertTrue(TestCakeSession::started());
+
+		TestCakeSession::destroy();
+		$this->assertFalse(TestCakeSession::started());
+
+		App::build();
+	}
+
+/**
+ * testReadAndWriteWithCacheStorage method
+ *
+ * @return void
+ */
+	public function testReadAndWriteWithCacheStorage() {
+		Configure::write('Session.defaults', 'cache');
+		Configure::write('Session.handler.engine', 'TestCacheSession');
+
+		TestCakeSession::init();
+		TestCakeSession::destroy();
+
+		TestCakeSession::write('SessionTestCase', 0);
+		$this->assertEquals(0, TestCakeSession::read('SessionTestCase'));
+
+		TestCakeSession::write('SessionTestCase', '0');
+		$this->assertEquals('0', TestCakeSession::read('SessionTestCase'));
+		$this->assertFalse(TestCakeSession::read('SessionTestCase') === 0);
+
+		TestCakeSession::write('SessionTestCase', false);
+		$this->assertFalse(TestCakeSession::read('SessionTestCase'));
+
+		TestCakeSession::write('SessionTestCase', null);
+		$this->assertEquals(null, TestCakeSession::read('SessionTestCase'));
+
+		TestCakeSession::write('SessionTestCase', 'This is a Test');
+		$this->assertEquals('This is a Test', TestCakeSession::read('SessionTestCase'));
+
+		TestCakeSession::write('SessionTestCase', 'This is a Test');
+		TestCakeSession::write('SessionTestCase', 'This was updated');
+		$this->assertEquals('This was updated', TestCakeSession::read('SessionTestCase'));
+
+		TestCakeSession::destroy();
+		$this->assertNull(TestCakeSession::read('SessionTestCase'));
+	}
+
+/**
+ * test that changing the config name of the cache config works.
+ *
+ * @return void
+ */
+	public function testReadAndWriteWithCustomCacheConfig() {
+		Configure::write('Session.defaults', 'cache');
+		Configure::write('Session.handler.engine', 'TestCacheSession');
+		Configure::write('Session.handler.config', 'session_test');
+
+		Cache::config('session_test', array(
+			'engine' => 'File',
+			'prefix' => 'session_test_',
+		));
+
+		TestCakeSession::init();
+		TestCakeSession::start();
+
+		TestCakeSession::write('SessionTestCase', 'Some value');
+		$this->assertEquals('Some value', TestCakeSession::read('SessionTestCase'));
+		$id = TestCakeSession::id();
+
+		Cache::delete($id, 'session_test');
+	}
+
+/**
+ * testReadAndWriteWithDatabaseStorage method
+ *
+ * @return void
+ */
+	public function testReadAndWriteWithDatabaseStorage() {
+		Configure::write('Session.defaults', 'database');
+		Configure::write('Session.handler.engine', 'TestDatabaseSession');
+		Configure::write('Session.handler.table', 'sessions');
+		Configure::write('Session.handler.model', 'Session');
+		Configure::write('Session.handler.database', 'test');
+
+		TestCakeSession::init();
+		$this->assertNull(TestCakeSession::id());
+
+		TestCakeSession::start();
+		$expected = session_id();
+		$this->assertEquals($expected, TestCakeSession::id());
+
+		TestCakeSession::renew();
+		$this->assertFalse($expected === TestCakeSession::id());
+
+		$expected = session_id();
+		$this->assertEquals($expected, TestCakeSession::id());
+
+		TestCakeSession::write('SessionTestCase', 0);
+		$this->assertEquals(0, TestCakeSession::read('SessionTestCase'));
+
+		TestCakeSession::write('SessionTestCase', '0');
+		$this->assertEquals('0', TestCakeSession::read('SessionTestCase'));
+		$this->assertFalse(TestCakeSession::read('SessionTestCase') === 0);
+
+		TestCakeSession::write('SessionTestCase', false);
+		$this->assertFalse(TestCakeSession::read('SessionTestCase'));
+
+		TestCakeSession::write('SessionTestCase', null);
+		$this->assertEquals(null, TestCakeSession::read('SessionTestCase'));
+
+		TestCakeSession::write('SessionTestCase', 'This is a Test');
+		$this->assertEquals('This is a Test', TestCakeSession::read('SessionTestCase'));
+
+		TestCakeSession::write('SessionTestCase', 'Some additional data');
+		$this->assertEquals('Some additional data', TestCakeSession::read('SessionTestCase'));
+
+		TestCakeSession::destroy();
+		$this->assertNull(TestCakeSession::read('SessionTestCase'));
+
+		Configure::write('Session', array(
+			'defaults' => 'php'
+		));
+		TestCakeSession::init();
+	}
+
+/**
+ * testSessionTimeout method
+ *
+ * @return void
+ */
+	public function testSessionTimeout() {
+		Configure::write('debug', 2);
+		Configure::write('Session.defaults', 'cake');
+		Configure::write('Session.autoRegenerate', false);
+
+		$timeoutSeconds = Configure::read('Session.timeout') * 60;
+
+		TestCakeSession::destroy();
+		TestCakeSession::write('Test', 'some value');
+
+		$this->assertWithinMargin(time() + $timeoutSeconds, CakeSession::$sessionTime, 1);
+		$this->assertEquals(10, $_SESSION['Config']['countdown']);
+		$this->assertWithinMargin(CakeSession::$sessionTime, $_SESSION['Config']['time'], 1);
+		$this->assertWithinMargin(time(), CakeSession::$time, 1);
+		$this->assertWithinMargin(time() + $timeoutSeconds, $_SESSION['Config']['time'], 1);
+
+		Configure::write('Session.harden', true);
+		TestCakeSession::destroy();
+
+		TestCakeSession::write('Test', 'some value');
+		$this->assertWithinMargin(time() + $timeoutSeconds, CakeSession::$sessionTime, 1);
+		$this->assertEquals(10, $_SESSION['Config']['countdown']);
+		$this->assertWithinMargin(CakeSession::$sessionTime, $_SESSION['Config']['time'], 1);
+		$this->assertWithinMargin(time(), CakeSession::$time, 1);
+		$this->assertWithinMargin(CakeSession::$time + $timeoutSeconds, $_SESSION['Config']['time'], 1);
+	}
+
+/**
+ * Test that cookieTimeout matches timeout when unspecified.
+ *
+ * @return void
+ */
+	public function testCookieTimeoutFallback() {
+		$_SESSION = null;
+		Configure::write('Session', array(
+			'defaults' => 'cake',
+			'timeout' => 400,
+		));
+		TestCakeSession::start();
+		$this->assertEquals(400, Configure::read('Session.cookieTimeout'));
+		$this->assertEquals(400, Configure::read('Session.timeout'));
+		$this->assertEquals(400 * 60, ini_get('session.cookie_lifetime'));
+		$this->assertEquals(400 * 60, ini_get('session.gc_maxlifetime'));
+
+		$_SESSION = null;
+		Configure::write('Session', array(
+			'defaults' => 'cake',
+			'timeout' => 400,
+			'cookieTimeout' => 600
+		));
+		TestCakeSession::start();
+		$this->assertEquals(600, Configure::read('Session.cookieTimeout'));
+		$this->assertEquals(400, Configure::read('Session.timeout'));
+	}
+
+/**
+ * Proves that invalid sessions will be destroyed and re-created
+ * if invalid
+ *
+ * @return void
+ */
+	public function testInvalidSessionRenew() {
+		TestCakeSession::start();
+		$this->assertNotEmpty($_SESSION['Config']);
+		$data = $_SESSION;
+
+		session_write_close();
+		$_SESSION = null;
+
+		TestCakeSession::start();
+		$this->assertEquals($data, $_SESSION);
+		TestCakeSession::write('Foo', 'Bar');
+
+		session_write_close();
+		$_SESSION = null;
+
+		TestCakeSession::userAgent('bogus!');
+		TestCakeSession::start();
+		$this->assertNotEquals($data, $_SESSION);
+		$this->assertEquals('bogus!', $_SESSION['Config']['userAgent']);
+	}
+
+}

lib/Cake/Test/Case/Model/Datasource/DataSourceTest.php

@@ -0,0 +1,249 @@
+<?php
+/**
+ * DataSourceTest file
+ *
+ * CakePHP(tm) Tests <http://book.cakephp.org/2.0/en/development/testing.html>
+ * 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/2.0/en/development/testing.html CakePHP(tm) Tests
+ * @package       Cake.Test.Case.Model.Datasource
+ * @since         CakePHP(tm) v 1.2.0.4206
+ * @license       http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+
+App::uses('Model', 'Model');
+App::uses('DataSource', 'Model/Datasource');
+
+/**
+ * TestSource
+ *
+ * @package       Cake.Test.Case.Model.Datasource
+ */
+class TestSource extends DataSource {
+
+/**
+ * _schema
+ * @var type
+ */
+	protected $_schema = array(
+		'id' => array(
+			'type' => 'integer',
+			'null' => false,
+			'key' => 'primary',
+			'length' => 11,
+		),
+		'text' => array(
+			'type' => 'string',
+			'null' => true,
+			'length' => 140,
+		),
+		'status' => array(
+			'type' => 'string',
+			'null' => true,
+			'length' => 140,
+		),
+		'customField' => array(
+			'type' => 'string',
+			'null' => true,
+			'length' => 255,
+		),
+	);
+
+/**
+ * listSources
+ *
+ * @return bool
+ */
+	public function listSources() {
+		return null;
+	}
+
+/**
+ * Returns the schema for the datasource to enable create/update
+ *
+ * @param object $Model
+ * @return array
+ */
+	public function describe(Model $Model) {
+		return $this->_schema;
+	}
+
+/**
+ * Just return $func to pass to read() to figure out the COUNT
+ * Required for delete/update to work
+ *
+ * @param Model $Model
+ * @param type $func
+ * @param type $params
+ * @return array
+ */
+	public function calculate(Model $Model, $func, $params = array()) {
+		return $func;
+	}
+
+}
+
+/**
+ * DataSourceTest class
+ *
+ * @package       Cake.Test.Case.Model.Datasource
+ */
+class DataSourceTest extends CakeTestCase {
+
+/**
+ * Name of test source
+ *
+ * @var string
+ */
+	public $sourceName = 'myapitest';
+
+/**
+ * setUp method
+ *
+ * @return void
+ */
+	public function setUp() {
+		parent::setUp();
+		$this->Source = $this->getMock(
+			'TestSource',
+			array('create', 'read', 'update', 'delete')
+		);
+		ConnectionManager::create($this->sourceName, array(
+			'datasource' => get_class($this->Source),
+			'apiKey' => '1234abcd',
+		));
+		$this->Model = $this->getMock(
+			'Model',
+			array('getDataSource'),
+			array(array('ds' => $this->sourceName))
+		);
+		$this->Model->expects($this->any())
+			->method('getDataSource')
+			->will($this->returnValue($this->Source));
+	}
+
+/**
+ * tearDown method
+ *
+ * @return void
+ */
+	public function tearDown() {
+		parent::tearDown();
+		unset($this->Model, $this->Source);
+		ConnectionManager::drop($this->sourceName);
+	}
+
+/**
+ * testCreate
+ *
+ * @return void
+ */
+	public function testCreate() {
+		$data = array(
+			$this->Model->alias => array(
+				'text' => 'This is a test',
+				'status' => 'Test status',
+				'customField' => array(
+					'array', 'field', 'type',
+					'for', 'custom', 'datasources',
+				),
+			),
+		);
+		$this->Source->expects($this->once())
+			->method('create')
+			->with(
+				$this->equalTo($this->Model),
+				$this->equalTo(array_keys($data[$this->Model->alias])),
+				$this->equalTo(array_values($data[$this->Model->alias]))
+			);
+		$this->Model->save($data);
+	}
+
+/**
+ * testRead
+ *
+ * @return void
+ */
+	public function testRead() {
+		$expected = array(
+			'conditions'	=> array('status' => 'test'),
+			'fields'		=> null,
+			'joins'			=> array(),
+			'limit'			=> 10,
+			'offset'		=> null,
+			'order'			=> array(array('status')),
+			'page'			=> 1,
+			'group'			=> null,
+			'callbacks'		=> true,
+		);
+		$this->Source->expects($this->once())
+			->method('read')
+			->with(
+				$this->anything(),
+				$this->equalTo($expected)
+			);
+		$this->Model->find('all', array(
+			'conditions' => array('status' => 'test'),
+			'limit' => 10,
+			'order' => array('status'),
+		));
+	}
+
+/**
+ * testUpdate
+ *
+ * @return void
+ */
+	public function testUpdate() {
+		$data = array(
+			$this->Model->alias => array(
+				'id' => 1,
+				'text' => 'This is a test',
+				'status' => 'Test status',
+				'customField' => array(
+					'array', 'field', 'type',
+					'for', 'custom', 'datasources',
+				),
+			),
+		);
+		$this->Source->expects($this->any())
+			->method('read')
+			->will($this->returnValue(array(
+				array($this->Model->alias => array('count' => 1))
+			)));
+		$this->Source->expects($this->once())
+			->method('update')
+			->with(
+				$this->equalTo($this->Model),
+				$this->equalTo(array_keys($data[$this->Model->alias])),
+				$this->equalTo(array_values($data[$this->Model->alias]))
+			);
+		$this->Model->save($data);
+	}
+
+/**
+ * testDelete
+ *
+ * @return void
+ */
+	public function testDelete() {
+		$this->Source->expects($this->any())
+			->method('read')
+			->will($this->returnValue(array(
+				array($this->Model->alias => array('count' => 1))
+			)));
+		$this->Source->expects($this->once())
+			->method('delete')
+			->with(
+				$this->equalTo($this->Model),
+				$this->equalTo(array($this->Model->alias . '.id' => 1))
+			);
+		$this->Model->delete(1);
+	}
+
+}

lib/Cake/Test/Case/Model/Datasource/Database/SqliteTest.php

@@ -0,0 +1,521 @@
+<?php
+/**
+ * DboSqliteTest file
+ *
+ * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
+ * 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://cakephp.org CakePHP(tm) Project
+ * @package       Cake.Test.Case.Model.Datasource.Database
+ * @since         CakePHP(tm) v 1.2.0
+ * @license       http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+
+App::uses('Model', 'Model');
+App::uses('AppModel', 'Model');
+App::uses('Sqlite', 'Model/Datasource/Database');
+
+require_once dirname(dirname(dirname(__FILE__))) . DS . 'models.php';
+
+/**
+ * DboSqliteTestDb class
+ *
+ * @package       Cake.Test.Case.Model.Datasource.Database
+ */
+class DboSqliteTestDb extends Sqlite {
+
+/**
+ * simulated property
+ *
+ * @var array
+ */
+	public $simulated = array();
+
+/**
+ * execute method
+ *
+ * @param mixed $sql
+ * @return void
+ */
+	protected function _execute($sql, $params = array(), $prepareOptions = array()) {
+		$this->simulated[] = $sql;
+		return null;
+	}
+
+/**
+ * getLastQuery method
+ *
+ * @return void
+ */
+	public function getLastQuery() {
+		return $this->simulated[count($this->simulated) - 1];
+	}
+
+}
+
+/**
+ * DboSqliteTest class
+ *
+ * @package       Cake.Test.Case.Model.Datasource.Database
+ */
+class SqliteTest extends CakeTestCase {
+
+/**
+ * Do not automatically load fixtures for each test, they will be loaded manually using CakeTestCase::loadFixtures
+ *
+ * @var bool
+ */
+	public $autoFixtures = false;
+
+/**
+ * Fixtures
+ *
+ * @var object
+ */
+	public $fixtures = array('core.user', 'core.uuid', 'core.datatype');
+
+/**
+ * Actual DB connection used in testing
+ *
+ * @var DboSource
+ */
+	public $Dbo = null;
+
+/**
+ * Sets up a Dbo class instance for testing
+ *
+ * @return void
+ */
+	public function setUp() {
+		parent::setUp();
+		Configure::write('Cache.disable', true);
+		$this->Dbo = ConnectionManager::getDataSource('test');
+		if (!$this->Dbo instanceof Sqlite) {
+			$this->markTestSkipped('The Sqlite extension is not available.');
+		}
+	}
+
+/**
+ * Sets up a Dbo class instance for testing
+ *
+ * @return void
+ */
+	public function tearDown() {
+		parent::tearDown();
+		Configure::write('Cache.disable', false);
+	}
+
+/**
+ * Tests that SELECT queries from DboSqlite::listSources() are not cached
+ *
+ * @return void
+ */
+	public function testTableListCacheDisabling() {
+		$this->assertFalse(in_array('foo_test', $this->Dbo->listSources()));
+
+		$this->Dbo->query('CREATE TABLE foo_test (test VARCHAR(255))');
+		$this->assertTrue(in_array('foo_test', $this->Dbo->listSources()));
+
+		$this->Dbo->cacheSources = false;
+		$this->Dbo->query('DROP TABLE foo_test');
+		$this->assertFalse(in_array('foo_test', $this->Dbo->listSources()));
+	}
+
+/**
+ * test Index introspection.
+ *
+ * @return void
+ */
+	public function testIndex() {
+		$name = $this->Dbo->fullTableName('with_a_key', false, false);
+		$this->Dbo->query('CREATE TABLE ' . $name . ' ("id" int(11) PRIMARY KEY, "bool" int(1), "small_char" varchar(50), "description" varchar(40) );');
+		$this->Dbo->query('CREATE INDEX pointless_bool ON ' . $name . '("bool")');
+		$this->Dbo->query('CREATE UNIQUE INDEX char_index ON ' . $name . '("small_char")');
+		$expected = array(
+			'PRIMARY' => array('column' => 'id', 'unique' => 1),
+			'pointless_bool' => array('column' => 'bool', 'unique' => 0),
+			'char_index' => array('column' => 'small_char', 'unique' => 1),
+
+		);
+		$result = $this->Dbo->index($name);
+		$this->assertEquals($expected, $result);
+		$this->Dbo->query('DROP TABLE ' . $name);
+
+		$this->Dbo->query('CREATE TABLE ' . $name . ' ("id" int(11) PRIMARY KEY, "bool" int(1), "small_char" varchar(50), "description" varchar(40) );');
+		$this->Dbo->query('CREATE UNIQUE INDEX multi_col ON ' . $name . '("small_char", "bool")');
+		$expected = array(
+			'PRIMARY' => array('column' => 'id', 'unique' => 1),
+			'multi_col' => array('column' => array('small_char', 'bool'), 'unique' => 1),
+		);
+		$result = $this->Dbo->index($name);
+		$this->assertEquals($expected, $result);
+		$this->Dbo->query('DROP TABLE ' . $name);
+	}
+
+/**
+ * Tests that cached table descriptions are saved under the sanitized key name
+ *
+ * @return void
+ */
+	public function testCacheKeyName() {
+		Configure::write('Cache.disable', false);
+
+		$dbName = 'db' . rand() . '$(*%&).db';
+		$this->assertFalse(file_exists(TMP . $dbName));
+
+		$db = new Sqlite(array_merge($this->Dbo->config, array('database' => TMP . $dbName)));
+		$this->assertTrue(file_exists(TMP . $dbName));
+
+		$db->execute("CREATE TABLE test_list (id VARCHAR(255));");
+
+		$db->cacheSources = true;
+		$this->assertEquals(array('test_list'), $db->listSources());
+		$db->cacheSources = false;
+
+		$fileName = '_' . preg_replace('/[^A-Za-z0-9_\-+]/', '_', TMP . $dbName) . '_list';
+
+		$result = Cache::read($fileName, '_cake_model_');
+		$this->assertEquals(array('test_list'), $result);
+
+		Cache::delete($fileName, '_cake_model_');
+		Configure::write('Cache.disable', true);
+	}
+
+/**
+ * test building columns with SQLite
+ *
+ * @return void
+ */
+	public function testBuildColumn() {
+		$data = array(
+			'name' => 'int_field',
+			'type' => 'integer',
+			'null' => false,
+		);
+		$result = $this->Dbo->buildColumn($data);
+		$expected = '"int_field" integer NOT NULL';
+		$this->assertEquals($expected, $result);
+
+		$data = array(
+			'name' => 'name',
+			'type' => 'string',
+			'length' => 20,
+			'null' => false,
+		);
+		$result = $this->Dbo->buildColumn($data);
+		$expected = '"name" varchar(20) NOT NULL';
+		$this->assertEquals($expected, $result);
+
+		$data = array(
+			'name' => 'testName',
+			'type' => 'string',
+			'length' => 20,
+			'default' => null,
+			'null' => true,
+			'collate' => 'NOCASE'
+		);
+		$result = $this->Dbo->buildColumn($data);
+		$expected = '"testName" varchar(20) DEFAULT NULL COLLATE NOCASE';
+		$this->assertEquals($expected, $result);
+
+		$data = array(
+			'name' => 'testName',
+			'type' => 'string',
+			'length' => 20,
+			'default' => 'test-value',
+			'null' => false,
+		);
+		$result = $this->Dbo->buildColumn($data);
+		$expected = '"testName" varchar(20) DEFAULT \'test-value\' NOT NULL';
+		$this->assertEquals($expected, $result);
+
+		$data = array(
+			'name' => 'testName',
+			'type' => 'integer',
+			'length' => 10,
+			'default' => 10,
+			'null' => false,
+		);
+		$result = $this->Dbo->buildColumn($data);
+		$expected = '"testName" integer(10) DEFAULT 10 NOT NULL';
+		$this->assertEquals($expected, $result);
+
+		$data = array(
+			'name' => 'testName',
+			'type' => 'integer',
+			'length' => 10,
+			'default' => 10,
+			'null' => false,
+			'collate' => 'BADVALUE'
+		);
+		$result = $this->Dbo->buildColumn($data);
+		$expected = '"testName" integer(10) DEFAULT 10 NOT NULL';
+		$this->assertEquals($expected, $result);
+
+		$data = array(
+			'name' => 'huge',
+			'type' => 'biginteger',
+			'length' => 20,
+			'null' => false,
+		);
+		$result = $this->Dbo->buildColumn($data);
+		$expected = '"huge" bigint(20) NOT NULL';
+		$this->assertEquals($expected, $result);
+
+		$data = array(
+			'name' => 'id',
+			'type' => 'biginteger',
+			'length' => 20,
+			'null' => false,
+			'key' => 'primary',
+		);
+		$result = $this->Dbo->buildColumn($data);
+		$expected = '"id" bigint(20) NOT NULL PRIMARY KEY';
+		$this->assertEquals($expected, $result);
+	}
+
+/**
+ * test describe() and normal results.
+ *
+ * @return void
+ */
+	public function testDescribe() {
+		$this->loadFixtures('User');
+		$Model = new Model(array(
+			'name' => 'User',
+			'ds' => 'test',
+			'table' => 'users'
+		));
+
+		$this->Dbo->cacheSources = true;
+		Configure::write('Cache.disable', false);
+
+		$result = $this->Dbo->describe($Model);
+		$expected = array(
+			'id' => array(
+				'type' => 'integer',
+				'key' => 'primary',
+				'null' => false,
+				'default' => null,
+				'length' => 11
+			),
+			'user' => array(
+				'type' => 'string',
+				'length' => 255,
+				'null' => true,
+				'default' => null
+			),
+			'password' => array(
+				'type' => 'string',
+				'length' => 255,
+				'null' => true,
+				'default' => null
+			),
+			'created' => array(
+				'type' => 'datetime',
+				'null' => true,
+				'default' => null,
+				'length' => null,
+			),
+			'updated' => array(
+				'type' => 'datetime',
+				'null' => true,
+				'default' => null,
+				'length' => null,
+			)
+		);
+		$this->assertEquals($expected, $result);
+
+		$result = $this->Dbo->describe($Model->useTable);
+		$this->assertEquals($expected, $result);
+
+		$result = Cache::read('test_users', '_cake_model_');
+		$this->assertEquals($expected, $result);
+	}
+
+/**
+ * Test that datatypes are reflected
+ *
+ * @return void
+ */
+	public function testDatatypes() {
+		$this->loadFixtures('Datatype');
+		$Model = new Model(array(
+			'name' => 'Datatype',
+			'ds' => 'test',
+			'table' => 'datatypes'
+		));
+		$result = $this->Dbo->describe($Model);
+		$expected = array(
+			'id' => array(
+				'type' => 'integer',
+				'null' => false,
+				'default' => '',
+				'length' => 11,
+				'key' => 'primary',
+			),
+			'float_field' => array(
+				'type' => 'float',
+				'null' => false,
+				'default' => '',
+				'length' => '5,2',
+			),
+			'decimal_field' => array(
+				'type' => 'decimal',
+				'null' => true,
+				'default' => '0.000',
+				'length' => '6,3',
+			),
+			'huge_int' => array(
+				'type' => 'biginteger',
+				'null' => true,
+				'default' => null,
+				'length' => 20,
+			),
+			'bool' => array(
+				'type' => 'boolean',
+				'null' => false,
+				'default' => '0',
+				'length' => null
+			),
+		);
+		$this->assertSame($expected, $result);
+	}
+
+/**
+ * test that describe does not corrupt UUID primary keys
+ *
+ * @return void
+ */
+	public function testDescribeWithUuidPrimaryKey() {
+		$tableName = 'uuid_tests';
+		$this->Dbo->query("CREATE TABLE {$tableName} (id VARCHAR(36) PRIMARY KEY, name VARCHAR, created DATETIME, modified DATETIME)");
+		$Model = new Model(array('name' => 'UuidTest', 'ds' => 'test', 'table' => 'uuid_tests'));
+		$result = $this->Dbo->describe($Model);
+		$expected = array(
+			'type' => 'string',
+			'length' => 36,
+			'null' => false,
+			'default' => null,
+			'key' => 'primary',
+		);
+		$this->assertEquals($expected, $result['id']);
+		$this->Dbo->query('DROP TABLE ' . $tableName);
+
+		$tableName = 'uuid_tests';
+		$this->Dbo->query("CREATE TABLE {$tableName} (id CHAR(36) PRIMARY KEY, name VARCHAR, created DATETIME, modified DATETIME)");
+		$Model = new Model(array('name' => 'UuidTest', 'ds' => 'test', 'table' => 'uuid_tests'));
+		$result = $this->Dbo->describe($Model);
+		$expected = array(
+			'type' => 'string',
+			'length' => 36,
+			'null' => false,
+			'default' => null,
+			'key' => 'primary',
+		);
+		$this->assertEquals($expected, $result['id']);
+		$this->Dbo->query('DROP TABLE ' . $tableName);
+	}
+
+/**
+ * Test virtualFields with functions.
+ *
+ * @return void
+ */
+	public function testVirtualFieldWithFunction() {
+		$this->loadFixtures('User');
+		$User = ClassRegistry::init('User');
+		$User->virtualFields = array('name' => 'SUBSTR(User.user, 5, LENGTH(User.user) - 4)');
+
+		$result = $User->find('first', array(
+			'conditions' => array('User.user' => 'garrett')
+		));
+		$this->assertEquals('ett', $result['User']['name']);
+	}
+
+/**
+ * Test that records can be inserted with UUID primary keys, and
+ * that the primary key is not blank
+ *
+ * @return void
+ */
+	public function testUuidPrimaryKeyInsertion() {
+		$this->loadFixtures('Uuid');
+		$Model = ClassRegistry::init('Uuid');
+
+		$data = array(
+			'title' => 'A UUID should work',
+			'count' => 10
+		);
+		$Model->create($data);
+		$this->assertTrue((bool)$Model->save());
+		$result = $Model->read();
+
+		$this->assertEquals($data['title'], $result['Uuid']['title']);
+		$this->assertTrue(Validation::uuid($result['Uuid']['id']), 'Not a UUID');
+	}
+
+/**
+ * Test nested transaction
+ *
+ * @return void
+ */
+	public function testNestedTransaction() {
+		$this->skipIf($this->Dbo->nestedTransactionSupported() === false, 'The Sqlite version do not support nested transaction');
+
+		$this->loadFixtures('User');
+		$model = new User();
+		$model->hasOne = $model->hasMany = $model->belongsTo = $model->hasAndBelongsToMany = array();
+		$model->cacheQueries = false;
+		$this->Dbo->cacheMethods = false;
+
+		$this->assertTrue($this->Dbo->begin());
+		$this->assertNotEmpty($model->read(null, 1));
+
+		$this->assertTrue($this->Dbo->begin());
+		$this->assertTrue($model->delete(1));
+		$this->assertEmpty($model->read(null, 1));
+		$this->assertTrue($this->Dbo->rollback());
+		$this->assertNotEmpty($model->read(null, 1));
+
+		$this->assertTrue($this->Dbo->begin());
+		$this->assertTrue($model->delete(1));
+		$this->assertEmpty($model->read(null, 1));
+		$this->assertTrue($this->Dbo->commit());
+		$this->assertEmpty($model->read(null, 1));
+
+		$this->assertTrue($this->Dbo->rollback());
+		$this->assertNotEmpty($model->read(null, 1));
+	}
+
+/**
+ * Test the limit function.
+ *
+ * @return void
+ */
+	public function testLimit() {
+		$db = $this->Dbo;
+
+		$result = $db->limit('0');
+		$this->assertNull($result);
+
+		$result = $db->limit('10');
+		$this->assertEquals(' LIMIT 10', $result);
+
+		$result = $db->limit('FARTS', 'BOOGERS');
+		$this->assertEquals(' LIMIT 0 OFFSET 0', $result);
+
+		$result = $db->limit(20, 10);
+		$this->assertEquals(' LIMIT 20 OFFSET 10', $result);
+
+		$result = $db->limit(10, 300000000000000000000000000000);
+		$scientificNotation = sprintf('%.1E', 300000000000000000000000000000);
+		$this->assertNotContains($scientificNotation, $result);
+	}
+
+}

lib/Cake/Test/Case/Model/Datasource/Database/SqlserverTest.php

@@ -0,0 +1,695 @@
+<?php
+/**
+ * SqlserverTest file
+ *
+ * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
+ * 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://cakephp.org CakePHP(tm) Project
+ * @package       Cake.Test.Case.Model.Datasource.Database
+ * @since         CakePHP(tm) v 1.2.0
+ * @license       http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+
+App::uses('Model', 'Model');
+App::uses('AppModel', 'Model');
+App::uses('Sqlserver', 'Model/Datasource/Database');
+
+require_once dirname(dirname(dirname(__FILE__))) . DS . 'models.php';
+
+/**
+ * SqlserverTestDb class
+ *
+ * @package       Cake.Test.Case.Model.Datasource.Database
+ */
+class SqlserverTestDb extends Sqlserver {
+
+/**
+ * simulated property
+ *
+ * @var array
+ */
+	public $simulated = array();
+
+/**
+ * execute results stack
+ *
+ * @var array
+ */
+	public $executeResultsStack = array();
+
+/**
+ * execute method
+ *
+ * @param mixed $sql
+ * @param mixed $params
+ * @param mixed $prepareOptions
+ * @return mixed
+ */
+	protected function _execute($sql, $params = array(), $prepareOptions = array()) {
+		$this->simulated[] = $sql;
+		return empty($this->executeResultsStack) ? null : array_pop($this->executeResultsStack);
+	}
+
+/**
+ * fetchAll method
+ *
+ * @param mixed $sql
+ * @return void
+ */
+	protected function _matchRecords(Model $model, $conditions = null) {
+		return $this->conditions(array('id' => array(1, 2)));
+	}
+
+/**
+ * getLastQuery method
+ *
+ * @return string
+ */
+	public function getLastQuery() {
+		return $this->simulated[count($this->simulated) - 1];
+	}
+
+/**
+ * getPrimaryKey method
+ *
+ * @param mixed $model
+ * @return string
+ */
+	public function getPrimaryKey($model) {
+		return parent::_getPrimaryKey($model);
+	}
+
+/**
+ * clearFieldMappings method
+ *
+ * @return void
+ */
+	public function clearFieldMappings() {
+		$this->_fieldMappings = array();
+	}
+
+/**
+ * describe method
+ *
+ * @param object $model
+ * @return void
+ */
+	public function describe($model) {
+		return empty($this->describe) ? parent::describe($model) : $this->describe;
+	}
+
+}
+
+/**
+ * SqlserverTestModel class
+ *
+ * @package       Cake.Test.Case.Model.Datasource.Database
+ */
+class SqlserverTestModel extends CakeTestModel {
+
+/**
+ * useTable property
+ *
+ * @var bool
+ */
+	public $useTable = false;
+
+/**
+ * _schema property
+ *
+ * @var array
+ */
+	protected $_schema = array(
+		'id' => array('type' => 'integer', 'null' => '', 'default' => '', 'length' => '8', 'key' => 'primary'),
+		'client_id' => array('type' => 'integer', 'null' => '', 'default' => '0', 'length' => '11'),
+		'name' => array('type' => 'string', 'null' => '', 'default' => '', 'length' => '255'),
+		'login' => array('type' => 'string', 'null' => '', 'default' => '', 'length' => '255'),
+		'passwd' => array('type' => 'string', 'null' => '1', 'default' => '', 'length' => '255'),
+		'addr_1' => array('type' => 'string', 'null' => '1', 'default' => '', 'length' => '255'),
+		'addr_2' => array('type' => 'string', 'null' => '1', 'default' => '', 'length' => '25'),
+		'zip_code' => array('type' => 'string', 'null' => '1', 'default' => '', 'length' => '155'),
+		'city' => array('type' => 'string', 'null' => '1', 'default' => '', 'length' => '155'),
+		'country' => array('type' => 'string', 'null' => '1', 'default' => '', 'length' => '155'),
+		'phone' => array('type' => 'string', 'null' => '1', 'default' => '', 'length' => '155'),
+		'fax' => array('type' => 'string', 'null' => '1', 'default' => '', 'length' => '155'),
+		'url' => array('type' => 'string', 'null' => '1', 'default' => '', 'length' => '255'),
+		'email' => array('type' => 'string', 'null' => '1', 'default' => '', 'length' => '155'),
+		'comments' => array('type' => 'text', 'null' => '1', 'default' => '', 'length' => ''),
+		'last_login' => array('type' => 'datetime', 'null' => '1', 'default' => '', 'length' => ''),
+		'created' => array('type' => 'date', 'null' => '1', 'default' => '', 'length' => ''),
+		'updated' => array('type' => 'datetime', 'null' => '1', 'default' => '', 'length' => null)
+	);
+
+/**
+ * belongsTo property
+ *
+ * @var array
+ */
+	public $belongsTo = array(
+		'SqlserverClientTestModel' => array(
+			'foreignKey' => 'client_id'
+		)
+	);
+
+/**
+ * find method
+ *
+ * @param mixed $conditions
+ * @param mixed $fields
+ * @param mixed $order
+ * @param mixed $recursive
+ * @return void
+ */
+	public function find($conditions = null, $fields = null, $order = null, $recursive = null) {
+		return $conditions;
+	}
+
+}
+
+/**
+ * SqlserverClientTestModel class
+ *
+ * @package       Cake.Test.Case.Model.Datasource.Database
+ */
+class SqlserverClientTestModel extends CakeTestModel {
+
+/**
+ * useTable property
+ *
+ * @var bool
+ */
+	public $useTable = false;
+
+/**
+ * _schema property
+ *
+ * @var array
+ */
+	protected $_schema = array(
+		'id'		=> array('type' => 'integer', 'null' => '', 'default' => '', 'length' => '8', 'key' => 'primary'),
+		'name'		=> array('type' => 'string', 'null' => '', 'default' => '', 'length' => '255'),
+		'email'		=> array('type' => 'string', 'null' => '1', 'default' => '', 'length' => '155'),
+		'created'	=> array('type' => 'datetime', 'null' => '1', 'default' => '', 'length' => ''),
+		'updated'	=> array('type' => 'datetime', 'null' => '1', 'default' => '', 'length' => null)
+	);
+}
+
+/**
+ * SqlserverTestResultIterator class
+ *
+ * @package       Cake.Test.Case.Model.Datasource.Database
+ */
+class SqlserverTestResultIterator extends ArrayIterator {
+
+/**
+ * closeCursor method
+ *
+ * @return void
+ */
+	public function closeCursor() {
+	}
+
+/**
+ * fetch method
+ *
+ * @return void
+ */
+	public function fetch() {
+		if (!$this->valid()) {
+			return null;
+		}
+		$current = $this->current();
+		$this->next();
+		return $current;
+	}
+
+}
+
+/**
+ * SqlserverTest class
+ *
+ * @package       Cake.Test.Case.Model.Datasource.Database
+ */
+class SqlserverTest extends CakeTestCase {
+
+/**
+ * The Dbo instance to be tested
+ *
+ * @var DboSource
+ */
+	public $db = null;
+
+/**
+ * autoFixtures property
+ *
+ * @var bool
+ */
+	public $autoFixtures = false;
+
+/**
+ * fixtures property
+ *
+ * @var array
+ */
+	public $fixtures = array('core.user', 'core.category', 'core.author', 'core.post');
+
+/**
+ * Sets up a Dbo class instance for testing
+ *
+ * @return void
+ */
+	public function setUp() {
+		parent::setUp();
+		$this->Dbo = ConnectionManager::getDataSource('test');
+		if (!($this->Dbo instanceof Sqlserver)) {
+			$this->markTestSkipped('Please configure the test datasource to use SQL Server.');
+		}
+		$this->db = new SqlserverTestDb($this->Dbo->config);
+		$this->model = new SqlserverTestModel();
+	}
+
+/**
+ * tearDown method
+ *
+ * @return void
+ */
+	public function tearDown() {
+		parent::tearDown();
+		unset($this->Dbo);
+		unset($this->model);
+	}
+
+/**
+ * testQuoting method
+ *
+ * @return void
+ */
+	public function testQuoting() {
+		$expected = "1.2";
+		$result = $this->db->value(1.2, 'float');
+		$this->assertSame($expected, $result);
+
+		$expected = "'1,2'";
+		$result = $this->db->value('1,2', 'float');
+		$this->assertSame($expected, $result);
+
+		$expected = 'NULL';
+		$result = $this->db->value('', 'integer');
+		$this->assertSame($expected, $result);
+
+		$expected = 'NULL';
+		$result = $this->db->value('', 'float');
+		$this->assertSame($expected, $result);
+
+		$expected = "''";
+		$result = $this->db->value('', 'binary');
+		$this->assertSame($expected, $result);
+
+		$expected = 'NULL';
+		$result = $this->db->value(null, 'string');
+		$this->assertSame($expected, $result);
+	}
+
+/**
+ * testFields method
+ *
+ * @return void
+ */
+	public function testFields() {
+		$fields = array(
+			'[SqlserverTestModel].[id] AS [SqlserverTestModel__id]',
+			'[SqlserverTestModel].[client_id] AS [SqlserverTestModel__client_id]',
+			'[SqlserverTestModel].[name] AS [SqlserverTestModel__name]',
+			'[SqlserverTestModel].[login] AS [SqlserverTestModel__login]',
+			'[SqlserverTestModel].[passwd] AS [SqlserverTestModel__passwd]',
+			'[SqlserverTestModel].[addr_1] AS [SqlserverTestModel__addr_1]',
+			'[SqlserverTestModel].[addr_2] AS [SqlserverTestModel__addr_2]',
+			'[SqlserverTestModel].[zip_code] AS [SqlserverTestModel__zip_code]',
+			'[SqlserverTestModel].[city] AS [SqlserverTestModel__city]',
+			'[SqlserverTestModel].[country] AS [SqlserverTestModel__country]',
+			'[SqlserverTestModel].[phone] AS [SqlserverTestModel__phone]',
+			'[SqlserverTestModel].[fax] AS [SqlserverTestModel__fax]',
+			'[SqlserverTestModel].[url] AS [SqlserverTestModel__url]',
+			'[SqlserverTestModel].[email] AS [SqlserverTestModel__email]',
+			'[SqlserverTestModel].[comments] AS [SqlserverTestModel__comments]',
+			'CONVERT(VARCHAR(20), [SqlserverTestModel].[last_login], 20) AS [SqlserverTestModel__last_login]',
+			'[SqlserverTestModel].[created] AS [SqlserverTestModel__created]',
+			'CONVERT(VARCHAR(20), [SqlserverTestModel].[updated], 20) AS [SqlserverTestModel__updated]'
+		);
+
+		$result = $this->db->fields($this->model);
+		$expected = $fields;
+		$this->assertEquals($expected, $result);
+
+		$this->db->clearFieldMappings();
+		$result = $this->db->fields($this->model, null, 'SqlserverTestModel.*');
+		$expected = $fields;
+		$this->assertEquals($expected, $result);
+
+		$this->db->clearFieldMappings();
+		$result = $this->db->fields($this->model, null, array('*', 'AnotherModel.id', 'AnotherModel.name'));
+		$expected = array_merge($fields, array(
+			'[AnotherModel].[id] AS [AnotherModel__id]',
+			'[AnotherModel].[name] AS [AnotherModel__name]'));
+		$this->assertEquals($expected, $result);
+
+		$this->db->clearFieldMappings();
+		$result = $this->db->fields($this->model, null, array('*', 'SqlserverClientTestModel.*'));
+		$expected = array_merge($fields, array(
+			'[SqlserverClientTestModel].[id] AS [SqlserverClientTestModel__id]',
+			'[SqlserverClientTestModel].[name] AS [SqlserverClientTestModel__name]',
+			'[SqlserverClientTestModel].[email] AS [SqlserverClientTestModel__email]',
+			'CONVERT(VARCHAR(20), [SqlserverClientTestModel].[created], 20) AS [SqlserverClientTestModel__created]',
+			'CONVERT(VARCHAR(20), [SqlserverClientTestModel].[updated], 20) AS [SqlserverClientTestModel__updated]'));
+		$this->assertEquals($expected, $result);
+	}
+
+/**
+ * testDistinctFields method
+ *
+ * @return void
+ */
+	public function testDistinctFields() {
+		$result = $this->db->fields($this->model, null, array('DISTINCT Car.country_code'));
+		$expected = array('DISTINCT [Car].[country_code] AS [Car__country_code]');
+		$this->assertEquals($expected, $result);
+
+		$result = $this->db->fields($this->model, null, 'DISTINCT Car.country_code');
+		$expected = array('DISTINCT [Car].[country_code] AS [Car__country_code]');
+		$this->assertEquals($expected, $result);
+	}
+
+/**
+ * testDistinctWithLimit method
+ *
+ * @return void
+ */
+	public function testDistinctWithLimit() {
+		$this->db->read($this->model, array(
+			'fields' => array('DISTINCT SqlserverTestModel.city', 'SqlserverTestModel.country'),
+			'limit' => 5
+		));
+		$result = $this->db->getLastQuery();
+		$this->assertRegExp('/^SELECT DISTINCT TOP 5/', $result);
+	}
+
+/**
+ * testDescribe method
+ *
+ * @return void
+ */
+	public function testDescribe() {
+		$SqlserverTableDescription = new SqlserverTestResultIterator(array(
+			(object)array(
+				'Default' => '((0))',
+				'Field' => 'count',
+				'Key' => 0,
+				'Length' => '4',
+				'Null' => 'NO',
+				'Type' => 'integer'
+			),
+			(object)array(
+				'Default' => '',
+				'Field' => 'body',
+				'Key' => 0,
+				'Length' => '-1',
+				'Null' => 'YES',
+				'Type' => 'nvarchar'
+			),
+			(object)array(
+				'Default' => '',
+				'Field' => 'published',
+				'Key' => 0,
+				'Type' => 'datetime2',
+				'Length' => 8,
+				'Null' => 'YES',
+				'Size' => ''
+			),
+			(object)array(
+				'Default' => '',
+				'Field' => 'id',
+				'Key' => 1,
+				'Type' => 'nchar',
+				'Length' => 72,
+				'Null' => 'NO',
+				'Size' => ''
+			),
+			(object)array(
+				'Default' => null,
+				'Field' => 'parent_id',
+				'Key' => '0',
+				'Type' => 'bigint',
+				'Length' => 8,
+				'Null' => 'YES',
+				'Size' => '0',
+			),
+		));
+		$this->db->executeResultsStack = array($SqlserverTableDescription);
+		$dummyModel = $this->model;
+		$result = $this->db->describe($dummyModel);
+		$expected = array(
+			'count' => array(
+				'type' => 'integer',
+				'null' => false,
+				'default' => '0',
+				'length' => 4
+			),
+			'body' => array(
+				'type' => 'text',
+				'null' => true,
+				'default' => null,
+				'length' => null
+			),
+			'published' => array(
+				'type' => 'datetime',
+				'null' => true,
+				'default' => '',
+				'length' => null
+			),
+			'id' => array(
+				'type' => 'string',
+				'null' => false,
+				'default' => '',
+				'length' => 36,
+				'key' => 'primary'
+			),
+			'parent_id' => array(
+				'type' => 'biginteger',
+				'null' => true,
+				'default' => null,
+				'length' => 8,
+			),
+		);
+		$this->assertEquals($expected, $result);
+		$this->assertSame($expected['parent_id'], $result['parent_id']);
+	}
+
+/**
+ * testBuildColumn
+ *
+ * @return void
+ */
+	public function testBuildColumn() {
+		$column = array('name' => 'id', 'type' => 'integer', 'null' => false, 'default' => '', 'length' => '8', 'key' => 'primary');
+		$result = $this->db->buildColumn($column);
+		$expected = '[id] int IDENTITY (1, 1) NOT NULL';
+		$this->assertEquals($expected, $result);
+
+		$column = array('name' => 'client_id', 'type' => 'integer', 'null' => false, 'default' => '0', 'length' => '11');
+		$result = $this->db->buildColumn($column);
+		$expected = '[client_id] int DEFAULT 0 NOT NULL';
+		$this->assertEquals($expected, $result);
+
+		$column = array('name' => 'client_id', 'type' => 'integer', 'null' => true);
+		$result = $this->db->buildColumn($column);
+		$expected = '[client_id] int NULL';
+		$this->assertEquals($expected, $result);
+
+		// 'name' => 'type' format for columns
+		$column = array('type' => 'integer', 'name' => 'client_id');
+		$result = $this->db->buildColumn($column);
+		$expected = '[client_id] int NULL';
+		$this->assertEquals($expected, $result);
+
+		$column = array('type' => 'string', 'name' => 'name');
+		$result = $this->db->buildColumn($column);
+		$expected = '[name] nvarchar(255) NULL';
+		$this->assertEquals($expected, $result);
+
+		$column = array('name' => 'name', 'type' => 'string', 'null' => false, 'default' => '', 'length' => '255');
+		$result = $this->db->buildColumn($column);
+		$expected = '[name] nvarchar(255) DEFAULT \'\' NOT NULL';
+		$this->assertEquals($expected, $result);
+
+		$column = array('name' => 'name', 'type' => 'string', 'null' => false, 'length' => '255');
+		$result = $this->db->buildColumn($column);
+		$expected = '[name] nvarchar(255) NOT NULL';
+		$this->assertEquals($expected, $result);
+
+		$column = array('name' => 'name', 'type' => 'string', 'null' => false, 'default' => null, 'length' => '255');
+		$result = $this->db->buildColumn($column);
+		$expected = '[name] nvarchar(255) NOT NULL';
+		$this->assertEquals($expected, $result);
+
+		$column = array('name' => 'name', 'type' => 'string', 'null' => true, 'default' => null, 'length' => '255');
+		$result = $this->db->buildColumn($column);
+		$expected = '[name] nvarchar(255) NULL';
+		$this->assertEquals($expected, $result);
+
+		$column = array('name' => 'name', 'type' => 'string', 'null' => true, 'default' => '', 'length' => '255');
+		$result = $this->db->buildColumn($column);
+		$expected = '[name] nvarchar(255) DEFAULT \'\'';
+		$this->assertEquals($expected, $result);
+
+		$column = array('name' => 'body', 'type' => 'text');
+		$result = $this->db->buildColumn($column);
+		$expected = '[body] nvarchar(MAX)';
+		$this->assertEquals($expected, $result);
+
+		$column = array(
+			'name' => 'checked',
+			'type' => 'boolean',
+			'length' => 10,
+			'default' => '1'
+		);
+		$result = $this->db->buildColumn($column);
+		$expected = "[checked] bit DEFAULT '1'";
+		$this->assertEquals($expected, $result);
+
+		$column = array(
+			'name' => 'huge',
+			'type' => 'biginteger',
+		);
+		$result = $this->db->buildColumn($column);
+		$expected = "[huge] bigint";
+		$this->assertEquals($expected, $result);
+	}
+
+/**
+ * testBuildIndex method
+ *
+ * @return void
+ */
+	public function testBuildIndex() {
+		$indexes = array(
+			'PRIMARY' => array('column' => 'id', 'unique' => 1),
+			'client_id' => array('column' => 'client_id', 'unique' => 1)
+		);
+		$result = $this->db->buildIndex($indexes, 'items');
+		$expected = array(
+			'PRIMARY KEY ([id])',
+			'ALTER TABLE items ADD CONSTRAINT client_id UNIQUE([client_id]);'
+		);
+		$this->assertEquals($expected, $result);
+
+		$indexes = array('client_id' => array('column' => 'client_id'));
+		$result = $this->db->buildIndex($indexes, 'items');
+		$this->assertSame(array(), $result);
+
+		$indexes = array('client_id' => array('column' => array('client_id', 'period_id'), 'unique' => 1));
+		$result = $this->db->buildIndex($indexes, 'items');
+		$expected = array('ALTER TABLE items ADD CONSTRAINT client_id UNIQUE([client_id], [period_id]);');
+		$this->assertEquals($expected, $result);
+	}
+
+/**
+ * testUpdateAllSyntax method
+ *
+ * @return void
+ */
+	public function testUpdateAllSyntax() {
+		$fields = array('SqlserverTestModel.client_id' => '[SqlserverTestModel].[client_id] + 1');
+		$conditions = array('SqlserverTestModel.updated <' => date('2009-01-01 00:00:00'));
+		$this->db->update($this->model, $fields, null, $conditions);
+
+		$result = $this->db->getLastQuery();
+		$this->assertNotRegExp('/SqlserverTestModel/', $result);
+		$this->assertRegExp('/^UPDATE \[sqlserver_test_models\]/', $result);
+		$this->assertRegExp('/SET \[client_id\] = \[client_id\] \+ 1/', $result);
+	}
+
+/**
+ * testGetPrimaryKey method
+ *
+ * @return void
+ */
+	public function testGetPrimaryKey() {
+		$schema = $this->model->schema();
+
+		$this->db->describe = $schema;
+		$result = $this->db->getPrimaryKey($this->model);
+		$this->assertEquals('id', $result);
+
+		unset($schema['id']['key']);
+		$this->db->describe = $schema;
+		$result = $this->db->getPrimaryKey($this->model);
+		$this->assertNull($result);
+	}
+
+/**
+ * SQL server < 11 doesn't have proper limit/offset support, test that our hack works.
+ *
+ * @return void
+ */
+	public function testLimitOffsetHack() {
+		$this->loadFixtures('Author', 'Post', 'User');
+		$query = array(
+			'limit' => 2,
+			'page' => 1,
+			'order' => 'User.user ASC',
+		);
+		$User = ClassRegistry::init('User');
+		$results = $User->find('all', $query);
+
+		$this->assertEquals(2, count($results));
+		$this->assertEquals('garrett', $results[0]['User']['user']);
+		$this->assertEquals('larry', $results[1]['User']['user']);
+
+		$query = array(
+			'limit' => 2,
+			'page' => 2,
+			'order' => 'User.user ASC',
+		);
+		$User = ClassRegistry::init('User');
+		$results = $User->find('all', $query);
+
+		$this->assertEquals(2, count($results));
+		$this->assertFalse(isset($results[0][0]));
+		$this->assertEquals('mariano', $results[0]['User']['user']);
+		$this->assertEquals('nate', $results[1]['User']['user']);
+	}
+
+/**
+ * Test that the return of stored procedures is honoured
+ *
+ * @return void
+ */
+	public function testStoredProcedureReturn() {
+		$sql = <<<SQL
+CREATE PROCEDURE cake_test_procedure
+AS
+BEGIN
+RETURN 2;
+END
+SQL;
+		$this->Dbo->execute($sql);
+
+		$sql = <<<SQL
+DECLARE @return_value int
+EXEC @return_value = [cake_test_procedure]
+SELECT 'value' = @return_value
+SQL;
+		$query = $this->Dbo->execute($sql);
+		$this->Dbo->execute('DROP PROC cake_test_procedure');
+
+		$result = $query->fetch();
+		$this->assertEquals(2, $result['value']);
+	}
+
+}

lib/Cake/Test/Case/Model/Datasource/Session/CacheSessionTest.php

@@ -0,0 +1,121 @@
+<?php
+/**
+ * CacheSessionTest
+ *
+ * CakePHP(tm) Tests <http://book.cakephp.org/2.0/en/development/testing.html>
+ * 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://cakephp.org CakePHP(tm) Project
+ * @package       Cake.Test.Case.Model.Datasource.Session
+ * @since         CakePHP(tm) v 2.0
+ * @license       http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+
+App::uses('CakeSession', 'Model/Datasource');
+App::uses('CacheSession', 'Model/Datasource/Session');
+class_exists('CakeSession');
+
+/**
+ * Class CacheSessionTest
+ *
+ * @package       Cake.Test.Case.Model.Datasource.Session
+ */
+class CacheSessionTest extends CakeTestCase {
+
+	protected static $_sessionBackup;
+
+/**
+ * test case startup
+ *
+ * @return void
+ */
+	public static function setupBeforeClass() {
+		Cache::config('session_test', array(
+			'engine' => 'File',
+			'prefix' => 'session_test_'
+		));
+		self::$_sessionBackup = Configure::read('Session');
+
+		Configure::write('Session.handler.config', 'session_test');
+	}
+
+/**
+ * cleanup after test case.
+ *
+ * @return void
+ */
+	public static function teardownAfterClass() {
+		Cache::clear(false, 'session_test');
+		Cache::drop('session_test');
+
+		Configure::write('Session', self::$_sessionBackup);
+	}
+
+/**
+ * setup
+ *
+ * @return void
+ */
+	public function setUp() {
+		parent::setUp();
+		$this->storage = new CacheSession();
+	}
+
+/**
+ * tearDown
+ *
+ * @return void
+ */
+	public function tearDown() {
+		parent::tearDown();
+		unset($this->storage);
+	}
+
+/**
+ * test open
+ *
+ * @return void
+ */
+	public function testOpen() {
+		$this->assertTrue($this->storage->open());
+	}
+
+/**
+ * test write()
+ *
+ * @return void
+ */
+	public function testWrite() {
+		$this->storage->write('abc', 'Some value');
+		$this->assertEquals('Some value', Cache::read('abc', 'session_test'), 'Value was not written.');
+		$this->assertFalse(Cache::read('abc', 'default'), 'Cache should only write to the given config.');
+	}
+
+/**
+ * test reading.
+ *
+ * @return void
+ */
+	public function testRead() {
+		$this->storage->write('test_one', 'Some other value');
+		$this->assertEquals('Some other value', $this->storage->read('test_one'), 'Incorrect value.');
+	}
+
+/**
+ * test destroy
+ *
+ * @return void
+ */
+	public function testDestroy() {
+		$this->storage->write('test_one', 'Some other value');
+		$this->assertTrue($this->storage->destroy('test_one'), 'Value was not deleted.');
+
+		$this->assertFalse(Cache::read('test_one', 'session_test'), 'Value stuck around.');
+	}
+
+}

lib/Cake/Test/Case/Model/Datasource/Session/DatabaseSessionTest.php

@@ -0,0 +1,194 @@
+<?php
+/**
+ * DatabaseSessionTest file
+ *
+ * CakePHP(tm) Tests <http://book.cakephp.org/2.0/en/development/testing.html>
+ * 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://cakephp.org CakePHP(tm) Project
+ * @package       Cake.Test.Case.Model.Datasource.Session
+ * @since         CakePHP(tm) v 2.0
+ * @license       http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+
+App::uses('Model', 'Model');
+App::uses('CakeSession', 'Model/Datasource');
+App::uses('DatabaseSession', 'Model/Datasource/Session');
+class_exists('CakeSession');
+
+/**
+ * Class SessionTestModel
+ *
+ * @package       Cake.Test.Case.Model.Datasource.Session
+ */
+class SessionTestModel extends Model {
+
+	public $useTable = 'sessions';
+
+}
+
+/**
+ * Database session test.
+ *
+ * @package       Cake.Test.Case.Model.Datasource.Session
+ */
+class DatabaseSessionTest extends CakeTestCase {
+
+	protected static $_sessionBackup;
+
+/**
+ * fixtures
+ *
+ * @var string
+ */
+	public $fixtures = array('core.session');
+
+/**
+ * test case startup
+ *
+ * @return void
+ */
+	public static function setupBeforeClass() {
+		self::$_sessionBackup = Configure::read('Session');
+		Configure::write('Session.handler', array(
+			'model' => 'SessionTestModel',
+		));
+		Configure::write('Session.timeout', 100);
+	}
+
+/**
+ * cleanup after test case.
+ *
+ * @return void
+ */
+	public static function teardownAfterClass() {
+		Configure::write('Session', self::$_sessionBackup);
+	}
+
+/**
+ * setUp
+ *
+ * @return void
+ */
+	public function setUp() {
+		parent::setUp();
+		$this->storage = new DatabaseSession();
+	}
+
+/**
+ * tearDown
+ *
+ * @return void
+ */
+	public function tearDown() {
+		unset($this->storage);
+		ClassRegistry::flush();
+		parent::tearDown();
+	}
+
+/**
+ * test that constructor sets the right things up.
+ *
+ * @return void
+ */
+	public function testConstructionSettings() {
+		ClassRegistry::flush();
+		new DatabaseSession();
+
+		$session = ClassRegistry::getObject('session');
+		$this->assertInstanceOf('SessionTestModel', $session);
+		$this->assertEquals('Session', $session->alias);
+		$this->assertEquals('test', $session->useDbConfig);
+		$this->assertEquals('sessions', $session->useTable);
+	}
+
+/**
+ * test opening the session
+ *
+ * @return void
+ */
+	public function testOpen() {
+		$this->assertTrue($this->storage->open());
+	}
+
+/**
+ * test write()
+ *
+ * @return void
+ */
+	public function testWrite() {
+		$result = $this->storage->write('foo', 'Some value');
+		$expected = array(
+			'Session' => array(
+				'id' => 'foo',
+				'data' => 'Some value',
+			)
+		);
+		$expires = $result['Session']['expires'];
+		unset($result['Session']['expires']);
+		$this->assertEquals($expected, $result);
+
+		$expected = time() + (Configure::read('Session.timeout') * 60);
+		$this->assertWithinMargin($expires, $expected, 1);
+	}
+
+/**
+ * testReadAndWriteWithDatabaseStorage method
+ *
+ * @return void
+ */
+	public function testWriteEmptySessionId() {
+		$result = $this->storage->write('', 'This is a Test');
+		$this->assertFalse($result);
+	}
+
+/**
+ * test read()
+ *
+ * @return void
+ */
+	public function testRead() {
+		$this->storage->write('foo', 'Some value');
+
+		$result = $this->storage->read('foo');
+		$expected = 'Some value';
+		$this->assertEquals($expected, $result);
+
+		$result = $this->storage->read('made up value');
+		$this->assertFalse($result);
+	}
+
+/**
+ * test blowing up the session.
+ *
+ * @return void
+ */
+	public function testDestroy() {
+		$this->storage->write('foo', 'Some value');
+
+		$this->assertTrue($this->storage->destroy('foo'), 'Destroy failed');
+		$this->assertFalse($this->storage->read('foo'), 'Value still present.');
+	}
+
+/**
+ * test the garbage collector
+ *
+ * @return void
+ */
+	public function testGc() {
+		ClassRegistry::flush();
+		Configure::write('Session.timeout', 0);
+
+		$storage = new DatabaseSession();
+		$storage->write('foo', 'Some value');
+
+		sleep(1);
+		$storage->gc();
+		$this->assertFalse($storage->read('foo'));
+	}
+}

lib/Cake/Test/Case/Model/ModelCrossSchemaHabtmTest.php

@@ -0,0 +1,236 @@
+<?php
+/**
+ * Tests cross database HABTM. Requires $test and $test2 to both be set in DATABASE_CONFIG
+ * NOTE: When testing on MySQL, you must set 'persistent' => false on *both* database connections,
+ * or one connection will step on the other.
+ *
+ * CakePHP(tm) Tests <http://book.cakephp.org/2.0/en/development/testing.html>
+ * 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/2.0/en/development/testing.html CakePHP(tm) Tests
+ * @package       Cake.Test.Case.Model
+ * @since         CakePHP(tm) v 2.1
+ * @license       http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+
+require_once dirname(__FILE__) . DS . 'ModelTestBase.php';
+
+/**
+ * Class ModelCrossSchemaHabtmTest
+ *
+ * @package       Cake.Test.Case.Model
+ */
+class ModelCrossSchemaHabtmTest extends BaseModelTest {
+
+/**
+ * Fixtures to be used
+ *
+ * @var array
+ */
+	public $fixtures = array(
+		'core.player', 'core.guild', 'core.guilds_player',
+		'core.armor', 'core.armors_player',
+	);
+
+/**
+ * Don't drop tables if they exist
+ *
+ * @var bool
+ */
+	public $dropTables = false;
+
+/**
+ * Don't auto load fixtures
+ *
+ * @var bool
+ */
+	public $autoFixtures = false;
+
+/**
+ * setUp method
+ *
+ * @return void
+ */
+	public function setUp() {
+		parent::setUp();
+		$this->_checkConfigs();
+	}
+
+/**
+ * Check if primary and secondary test databases are configured.
+ *
+ * @return void
+ */
+	protected function _checkConfigs() {
+		$config = ConnectionManager::enumConnectionObjects();
+		$this->skipIf($this->db instanceof Sqlite, 'This test is not compatible with Sqlite.');
+		$this->skipIf(
+			!isset($config['test']) || !isset($config['test2']),
+			'Primary and secondary test databases not configured, ' .
+			'skipping cross-database join tests.' .
+			' To run these tests, you must define $test and $test2 in your database configuration.'
+		);
+	}
+
+/**
+ * testModelDatasources method
+ *
+ * @return void
+ */
+	public function testModelDatasources() {
+		$this->loadFixtures('Player', 'Guild', 'GuildsPlayer');
+
+		$Player = ClassRegistry::init('Player');
+		$this->assertEquals('test', $Player->useDbConfig);
+		$this->assertEquals('test', $Player->Guild->useDbConfig);
+		$this->assertEquals('test2', $Player->GuildsPlayer->useDbConfig);
+
+		$this->assertEquals('test', $Player->getDataSource()->configKeyName);
+		$this->assertEquals('test', $Player->Guild->getDataSource()->configKeyName);
+		$this->assertEquals('test2', $Player->GuildsPlayer->getDataSource()->configKeyName);
+	}
+
+/**
+ * testHabtmFind method
+ *
+ * @return void
+ */
+	public function testHabtmFind() {
+		$this->loadFixtures('Player', 'Guild', 'GuildsPlayer');
+		$Player = ClassRegistry::init('Player');
+
+		$players = $Player->find('all', array(
+			'fields' => array('id', 'name'),
+			'contain' => array(
+				'Guild' => array(
+					'conditions' => array(
+						'Guild.name' => 'Wizards',
+					),
+				),
+			),
+		));
+		$this->assertEquals(4, count($players));
+		$wizards = Hash::extract($players, '{n}.Guild.{n}[name=Wizards]');
+		$this->assertEquals(1, count($wizards));
+
+		$players = $Player->find('all', array(
+			'fields' => array('id', 'name'),
+			'conditions' => array(
+				'Player.id' => 1,
+			),
+		));
+		$this->assertEquals(1, count($players));
+		$wizards = Hash::extract($players, '{n}.Guild.{n}');
+		$this->assertEquals(2, count($wizards));
+	}
+
+/**
+ * testHabtmSave method
+ *
+ * @return void
+ */
+	public function testHabtmSave() {
+		$this->loadFixtures('Player', 'Guild', 'GuildsPlayer');
+		$Player = ClassRegistry::init('Player');
+		$players = $Player->find('count');
+		$this->assertEquals(4, $players);
+
+		$player = $Player->create(array(
+			'name' => 'rchavik',
+		));
+
+		$results = $Player->saveAll($player, array('validate' => 'first'));
+		$this->assertNotSame(false, $results);
+		$count = $Player->find('count');
+		$this->assertEquals(5, $count);
+
+		$count = $Player->GuildsPlayer->find('count');
+		$this->assertEquals(3, $count);
+
+		$player = $Player->findByName('rchavik');
+		$this->assertEmpty($player['Guild']);
+
+		$player['Guild']['Guild'] = array(1, 2, 3);
+		$Player->save($player);
+
+		$player = $Player->findByName('rchavik');
+		$this->assertEquals(3, count($player['Guild']));
+
+		$players = $Player->find('all', array(
+			'contain' => array(
+				'conditions' => array(
+					'Guild.name' => 'Rangers',
+				),
+			),
+		));
+		$rangers = Hash::extract($players, '{n}.Guild.{n}[name=Rangers]');
+		$this->assertEquals(2, count($rangers));
+	}
+
+/**
+ * testHabtmWithThreeDatabases method
+ *
+ * @return void
+ */
+	public function testHabtmWithThreeDatabases() {
+		$config = ConnectionManager::enumConnectionObjects();
+		$this->skipIf(
+			!isset($config['test']) || !isset($config['test2']) || !isset($config['test_database_three']),
+			'Primary, secondary, and tertiary test databases not configured,' .
+			' skipping test. To run these tests, you must define ' .
+			'$test, $test2, and $test_database_three in your database configuration.'
+		);
+
+		$this->loadFixtures('Player', 'Guild', 'GuildsPlayer', 'Armor', 'ArmorsPlayer');
+
+		$Player = ClassRegistry::init('Player');
+		$Player->bindModel(array(
+			'hasAndBelongsToMany' => array(
+				'Armor' => array(
+					'with' => 'ArmorsPlayer',
+					'unique' => true,
+				),
+			),
+		), false);
+		$this->assertEquals('test', $Player->useDbConfig);
+		$this->assertEquals('test2', $Player->Armor->useDbConfig);
+		$this->assertEquals('test_database_three', $Player->ArmorsPlayer->useDbConfig);
+		$players = $Player->find('count');
+		$this->assertEquals(4, $players);
+
+		$spongebob = $Player->create(array(
+			'id' => 10,
+			'name' => 'spongebob',
+		));
+		$spongebob['Armor'] = array('Armor' => array(1, 2, 3, 4));
+		$result = $Player->save($spongebob);
+
+		$expected = array(
+			'Player' => array(
+				'id' => 10,
+				'name' => 'spongebob',
+			),
+			'Armor' => array(
+				'Armor' => array(
+					1, 2, 3, 4,
+				),
+			),
+		);
+		unset($result['Player']['created']);
+		unset($result['Player']['updated']);
+		$this->assertEquals($expected, $result);
+
+		$spongebob = $Player->find('all', array(
+			'conditions' => array(
+				'Player.id' => 10,
+			)
+		));
+		$spongeBobsArmors = Hash::extract($spongebob, '{n}.Armor.{n}');
+		$this->assertEquals(4, count($spongeBobsArmors));
+	}
+}

lib/Cake/Test/Case/Model/ModelDeleteTest.php

@@ -0,0 +1,948 @@
+<?php
+/**
+ * ModelDeleteTest file
+ *
+ * CakePHP(tm) Tests <http://book.cakephp.org/2.0/en/development/testing.html>
+ * 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/2.0/en/development/testing.html CakePHP(tm) Tests
+ * @package       Cake.Test.Case.Model
+ * @since         CakePHP(tm) v 1.2.0.4206
+ * @license       http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+
+require_once dirname(__FILE__) . DS . 'ModelTestBase.php';
+
+/**
+ * ModelDeleteTest
+ *
+ * @package       Cake.Test.Case.Model
+ */
+class ModelDeleteTest extends BaseModelTest {
+
+/**
+ * testDeleteHabtmReferenceWithConditions method
+ *
+ * @return void
+ */
+	public function testDeleteHabtmReferenceWithConditions() {
+		$this->loadFixtures('Portfolio', 'Item', 'ItemsPortfolio', 'Syfile', 'Image');
+
+		$Portfolio = new Portfolio();
+		$Portfolio->hasAndBelongsToMany['Item']['conditions'] = array('ItemsPortfolio.item_id >' => 1);
+
+		$result = $Portfolio->find('first', array(
+			'conditions' => array('Portfolio.id' => 1)
+		));
+		$expected = array(
+			array(
+				'id' => 3,
+				'syfile_id' => 3,
+				'published' => false,
+				'name' => 'Item 3',
+				'ItemsPortfolio' => array(
+					'id' => 3,
+					'item_id' => 3,
+					'portfolio_id' => 1
+			)),
+			array(
+				'id' => 4,
+				'syfile_id' => 4,
+				'published' => false,
+				'name' => 'Item 4',
+				'ItemsPortfolio' => array(
+					'id' => 4,
+					'item_id' => 4,
+					'portfolio_id' => 1
+			)),
+			array(
+				'id' => 5,
+				'syfile_id' => 5,
+				'published' => false,
+				'name' => 'Item 5',
+				'ItemsPortfolio' => array(
+					'id' => 5,
+					'item_id' => 5,
+					'portfolio_id' => 1
+		)));
+		$this->assertEquals($expected, $result['Item']);
+
+		$result = $Portfolio->ItemsPortfolio->find('all', array(
+			'conditions' => array('ItemsPortfolio.portfolio_id' => 1)
+		));
+		$expected = array(
+			array(
+				'ItemsPortfolio' => array(
+					'id' => 1,
+					'item_id' => 1,
+					'portfolio_id' => 1
+			)),
+			array(
+				'ItemsPortfolio' => array(
+					'id' => 3,
+					'item_id' => 3,
+					'portfolio_id' => 1
+			)),
+			array(
+				'ItemsPortfolio' => array(
+					'id' => 4,
+					'item_id' => 4,
+					'portfolio_id' => 1
+			)),
+			array(
+				'ItemsPortfolio' => array(
+					'id' => 5,
+					'item_id' => 5,
+					'portfolio_id' => 1
+		)));
+		$this->assertEquals($expected, $result);
+
+		$Portfolio->delete(1);
+
+		$result = $Portfolio->find('first', array(
+			'conditions' => array('Portfolio.id' => 1)
+		));
+		$this->assertSame(array(), $result);
+
+		$result = $Portfolio->ItemsPortfolio->find('all', array(
+			'conditions' => array('ItemsPortfolio.portfolio_id' => 1)
+		));
+		$this->assertSame(array(), $result);
+	}
+
+/**
+ * testDeleteArticleBLinks method
+ *
+ * @return void
+ */
+	public function testDeleteArticleBLinks() {
+		$this->loadFixtures('Article', 'ArticlesTag', 'Tag', 'User');
+		$TestModel = new ArticleB();
+
+		$result = $TestModel->ArticlesTag->find('all');
+		$expected = array(
+			array('ArticlesTag' => array('article_id' => '1', 'tag_id' => '1')),
+			array('ArticlesTag' => array('article_id' => '1', 'tag_id' => '2')),
+			array('ArticlesTag' => array('article_id' => '2', 'tag_id' => '1')),
+			array('ArticlesTag' => array('article_id' => '2', 'tag_id' => '3'))
+			);
+		$this->assertEquals($expected, $result);
+
+		$TestModel->delete(1);
+		$result = $TestModel->ArticlesTag->find('all');
+
+		$expected = array(
+			array('ArticlesTag' => array('article_id' => '2', 'tag_id' => '1')),
+			array('ArticlesTag' => array('article_id' => '2', 'tag_id' => '3'))
+		);
+		$this->assertEquals($expected, $result);
+	}
+
+/**
+ * testDeleteDependentWithConditions method
+ *
+ * @return void
+ */
+	public function testDeleteDependentWithConditions() {
+		$this->loadFixtures('Cd', 'Book', 'OverallFavorite');
+
+		$Cd = new Cd();
+		$Book = new Book();
+		$OverallFavorite = new OverallFavorite();
+
+		$Cd->delete(1);
+
+		$result = $OverallFavorite->find('all', array(
+			'fields' => array('model_type', 'model_id', 'priority')
+		));
+		$expected = array(
+			array(
+				'OverallFavorite' => array(
+					'model_type' => 'Book',
+					'model_id' => 1,
+					'priority' => 2
+		)));
+
+		$this->assertTrue(is_array($result));
+		$this->assertEquals($expected, $result);
+
+		$Book->delete(1);
+
+		$result = $OverallFavorite->find('all', array(
+			'fields' => array('model_type', 'model_id', 'priority')
+		));
+		$expected = array();
+
+		$this->assertTrue(is_array($result));
+		$this->assertEquals($expected, $result);
+	}
+
+/**
+ * testDel method
+ *
+ * @return void
+ */
+	public function testDelete() {
+		$this->loadFixtures('Article', 'Comment', 'Attachment');
+		$TestModel = new Article();
+
+		$result = $TestModel->delete(2);
+		$this->assertTrue($result);
+
+		$result = $TestModel->read(null, 2);
+		$this->assertSame(array(), $result);
+
+		$TestModel->recursive = -1;
+		$result = $TestModel->find('all', array(
+			'fields' => array('id', 'title')
+		));
+		$expected = array(
+			array('Article' => array(
+				'id' => 1,
+				'title' => 'First Article'
+			)),
+			array('Article' => array(
+				'id' => 3,
+				'title' => 'Third Article'
+		)));
+		$this->assertEquals($expected, $result);
+
+		$result = $TestModel->delete(3);
+		$this->assertTrue($result);
+
+		$result = $TestModel->read(null, 3);
+		$this->assertSame(array(), $result);
+
+		$TestModel->recursive = -1;
+		$result = $TestModel->find('all', array(
+			'fields' => array('id', 'title')
+		));
+		$expected = array(
+			array('Article' => array(
+				'id' => 1,
+				'title' => 'First Article'
+		)));
+
+		$this->assertEquals($expected, $result);
+
+		// make sure deleting a non-existent record doesn't break save()
+		// ticket #6293
+		$this->loadFixtures('Uuid');
+		$Uuid = new Uuid();
+		$data = array(
+			'B607DAB9-88A2-46CF-B57C-842CA9E3B3B3',
+			'52C8865C-10EE-4302-AE6C-6E7D8E12E2C8',
+			'8208C7FE-E89C-47C5-B378-DED6C271F9B8');
+		foreach ($data as $id) {
+			$Uuid->save(array('id' => $id));
+		}
+		$Uuid->delete('52C8865C-10EE-4302-AE6C-6E7D8E12E2C8');
+		$Uuid->delete('52C8865C-10EE-4302-AE6C-6E7D8E12E2C8');
+		foreach ($data as $id) {
+			$Uuid->save(array('id' => $id));
+		}
+		$result = $Uuid->find('all', array(
+			'conditions' => array('id' => $data),
+			'fields' => array('id'),
+			'order' => 'id'));
+		$expected = array(
+			array('Uuid' => array(
+				'id' => '52C8865C-10EE-4302-AE6C-6E7D8E12E2C8')),
+			array('Uuid' => array(
+				'id' => '8208C7FE-E89C-47C5-B378-DED6C271F9B8')),
+			array('Uuid' => array(
+				'id' => 'B607DAB9-88A2-46CF-B57C-842CA9E3B3B3')));
+		$this->assertEquals($expected, $result);
+	}
+
+/**
+ * test that delete() updates the correct records counterCache() records.
+ *
+ * @return void
+ */
+	public function testDeleteUpdatingCounterCacheCorrectly() {
+		$this->loadFixtures('CounterCacheUser', 'CounterCachePost');
+		$User = new CounterCacheUser();
+
+		$User->Post->delete(3);
+		$result = $User->read(null, 301);
+		$this->assertEquals(0, $result['User']['post_count']);
+
+		$result = $User->read(null, 66);
+		$this->assertEquals(2, $result['User']['post_count']);
+	}
+
+/**
+ * testDeleteAll method
+ *
+ * @return void
+ */
+	public function testDeleteAll() {
+		$this->loadFixtures('Article');
+		$TestModel = new Article();
+
+		$data = array('Article' => array(
+			'user_id' => 2,
+			'id' => 4,
+			'title' => 'Fourth Article',
+			'published' => 'N'
+		));
+		$result = $TestModel->set($data) && $TestModel->save();
+		$this->assertTrue($result);
+
+		$data = array('Article' => array(
+			'user_id' => 2,
+			'id' => 5,
+			'title' => 'Fifth Article',
+			'published' => 'Y'
+		));
+		$result = $TestModel->set($data) && $TestModel->save();
+		$this->assertTrue($result);
+
+		$data = array('Article' => array(
+			'user_id' => 1,
+			'id' => 6,
+			'title' => 'Sixth Article',
+			'published' => 'N'
+		));
+		$result = $TestModel->set($data) && $TestModel->save();
+		$this->assertTrue($result);
+
+		$TestModel->recursive = -1;
+		$result = $TestModel->find('all', array(
+			'fields' => array('id', 'user_id', 'title', 'published'),
+			'order' => array('Article.id' => 'ASC')
+		));
+
+		$expected = array(
+			array('Article' => array(
+				'id' => 1,
+				'user_id' => 1,
+				'title' => 'First Article',
+				'published' => 'Y'
+			)),
+			array('Article' => array(
+				'id' => 2,
+				'user_id' => 3,
+				'title' => 'Second Article',
+				'published' => 'Y'
+			)),
+			array('Article' => array(
+				'id' => 3,
+				'user_id' => 1,
+				'title' => 'Third Article',
+				'published' => 'Y')),
+			array('Article' => array(
+				'id' => 4,
+				'user_id' => 2,
+				'title' => 'Fourth Article',
+				'published' => 'N'
+			)),
+			array('Article' => array(
+				'id' => 5,
+				'user_id' => 2,
+				'title' => 'Fifth Article',
+				'published' => 'Y'
+			)),
+			array('Article' => array(
+				'id' => 6,
+				'user_id' => 1,
+				'title' => 'Sixth Article',
+				'published' => 'N'
+		)));
+
+		$this->assertEquals($expected, $result);
+
+		$result = $TestModel->deleteAll(array('Article.published' => 'N'));
+		$this->assertTrue($result);
+
+		$TestModel->recursive = -1;
+		$result = $TestModel->find('all', array(
+			'fields' => array('id', 'user_id', 'title', 'published'),
+			'order' => array('Article.id' => 'ASC')
+		));
+		$expected = array(
+			array('Article' => array(
+				'id' => 1,
+				'user_id' => 1,
+				'title' => 'First Article',
+				'published' => 'Y'
+			)),
+			array('Article' => array(
+				'id' => 2,
+				'user_id' => 3,
+				'title' => 'Second Article',
+				'published' => 'Y'
+			)),
+			array('Article' => array(
+				'id' => 3,
+				'user_id' => 1,
+				'title' => 'Third Article',
+				'published' => 'Y'
+			)),
+			array('Article' => array(
+				'id' => 5,
+				'user_id' => 2,
+				'title' => 'Fifth Article',
+				'published' => 'Y'
+		)));
+		$this->assertEquals($expected, $result);
+
+		$data = array('Article.user_id' => array(2, 3));
+		$result = $TestModel->deleteAll($data, true, true);
+		$this->assertTrue($result);
+
+		$TestModel->recursive = -1;
+		$result = $TestModel->find('all', array(
+			'fields' => array('id', 'user_id', 'title', 'published'),
+			'order' => array('Article.id' => 'ASC')
+		));
+		$expected = array(
+			array('Article' => array(
+				'id' => 1,
+				'user_id' => 1,
+				'title' => 'First Article',
+				'published' => 'Y'
+			)),
+			array('Article' => array(
+				'id' => 3,
+				'user_id' => 1,
+				'title' => 'Third Article',
+				'published' => 'Y'
+		)));
+		$this->assertEquals($expected, $result);
+
+		$result = $TestModel->deleteAll(array('Article.user_id' => 999));
+		$this->assertTrue($result, 'deleteAll returned false when all no records matched conditions. %s');
+	}
+
+/**
+ * testDeleteAllUnknownColumn method
+ *
+ * @expectedException PDOException
+ * @return void
+ */
+	public function testDeleteAllUnknownColumn() {
+		$this->loadFixtures('Article');
+		$TestModel = new Article();
+		$result = $TestModel->deleteAll(array('Article.non_existent_field' => 999));
+		$this->assertFalse($result, 'deleteAll returned true when find query generated sql error. %s');
+	}
+
+/**
+ * testDeleteAllFailedFind method
+ *
+ * Eg: Behavior callback stops the event, find returns null
+ *
+ * @return void
+ */
+	public function testDeleteAllFailedFind() {
+		$this->loadFixtures('Article');
+		$TestModel = $this->getMock('Article', array('find'));
+		$TestModel->expects($this->once())
+			->method('find')
+			->will($this->returnValue(null));
+
+		$result = $TestModel->deleteAll(array('Article.user_id' => 999));
+		$this->assertFalse($result);
+	}
+
+/**
+ * testDeleteAllMultipleRowsPerId method
+ *
+ * Ensure find done in deleteAll only returns distinct ids. A wacky combination
+ * of association and conditions can sometimes generate multiple rows per id.
+ *
+ * @return void
+ */
+	public function testDeleteAllMultipleRowsPerId() {
+		$this->loadFixtures('Article', 'User');
+
+		$TestModel = new Article();
+		$TestModel->unbindModel(array(
+			'belongsTo' => array('User'),
+			'hasMany' => array('Comment'),
+			'hasAndBelongsToMany' => array('Tag')
+		), false);
+		$TestModel->bindModel(array(
+			'belongsTo' => array(
+				'User' => array(
+					'foreignKey' => false,
+					'conditions' => array(
+						'Article.user_id = 1'
+					)
+				)
+			)
+		), false);
+
+		$result = $TestModel->deleteAll(
+			array('Article.user_id' => array(1, 3)),
+			true,
+			true
+		);
+
+		$this->assertTrue($result);
+	}
+
+/**
+ * testDeleteAllWithOrderProperty
+ *
+ * Ensure find done in deleteAll works with models that has $order property set
+ *
+ * @return void
+ */
+	public function testDeleteAllWithOrderProperty() {
+		$this->loadFixtures('Article', 'User');
+
+		$TestModel = new Article();
+		$TestModel->order = 'Article.published desc';
+		$TestModel->unbindModel(array(
+			'belongsTo' => array('User'),
+			'hasMany' => array('Comment'),
+			'hasAndBelongsToMany' => array('Tag')
+		), false);
+
+		$result = $TestModel->deleteAll(
+			array('Article.user_id' => array(1, 3)),
+			true,
+			true
+		);
+
+		$this->assertTrue($result);
+	}
+
+/**
+ * testRecursiveDel method
+ *
+ * @return void
+ */
+	public function testRecursiveDel() {
+		$this->loadFixtures('Article', 'Comment', 'Attachment');
+		$TestModel = new Article();
+
+		$result = $TestModel->delete(2);
+		$this->assertTrue($result);
+
+		$TestModel->recursive = 2;
+		$result = $TestModel->read(null, 2);
+		$this->assertSame(array(), $result);
+
+		$result = $TestModel->Comment->read(null, 5);
+		$this->assertSame(array(), $result);
+
+		$result = $TestModel->Comment->read(null, 6);
+		$this->assertSame(array(), $result);
+
+		$result = $TestModel->Comment->Attachment->read(null, 1);
+		$this->assertSame(array(), $result);
+
+		$result = $TestModel->find('count');
+		$this->assertEquals(2, $result);
+
+		$result = $TestModel->Comment->find('count');
+		$this->assertEquals(4, $result);
+
+		$result = $TestModel->Comment->Attachment->find('count');
+		$this->assertEquals(0, $result);
+	}
+
+/**
+ * testDependentExclusiveDelete method
+ *
+ * @return void
+ */
+	public function testDependentExclusiveDelete() {
+		$this->loadFixtures('Article', 'Comment');
+		$TestModel = new Article10();
+
+		$result = $TestModel->find('all');
+		$this->assertEquals(4, count($result[0]['Comment']));
+		$this->assertEquals(2, count($result[1]['Comment']));
+		$this->assertEquals(6, $TestModel->Comment->find('count'));
+
+		$TestModel->delete(1);
+		$this->assertEquals(2, $TestModel->Comment->find('count'));
+	}
+
+/**
+ * testDeleteLinks method
+ *
+ * @return void
+ */
+	public function testDeleteLinks() {
+		$this->loadFixtures('Article', 'ArticlesTag', 'Tag');
+		$TestModel = new Article();
+
+		$result = $TestModel->ArticlesTag->find('all');
+		$expected = array(
+			array('ArticlesTag' => array(
+				'article_id' => '1',
+				'tag_id' => '1'
+			)),
+			array('ArticlesTag' => array(
+				'article_id' => '1',
+				'tag_id' => '2'
+			)),
+			array('ArticlesTag' => array(
+				'article_id' => '2',
+				'tag_id' => '1'
+			)),
+			array('ArticlesTag' => array(
+				'article_id' => '2',
+				'tag_id' => '3'
+		)));
+		$this->assertEquals($expected, $result);
+
+		$TestModel->delete(1);
+		$result = $TestModel->ArticlesTag->find('all');
+
+		$expected = array(
+			array('ArticlesTag' => array(
+				'article_id' => '2',
+				'tag_id' => '1'
+			)),
+			array('ArticlesTag' => array(
+				'article_id' => '2',
+				'tag_id' => '3'
+		)));
+		$this->assertEquals($expected, $result);
+
+		$result = $TestModel->deleteAll(array('Article.user_id' => 999));
+		$this->assertTrue($result, 'deleteAll returned false when all no records matched conditions. %s');
+	}
+
+/**
+ * test that a plugin model as the 'with' model doesn't have issues
+ *
+ * @return void
+ */
+	public function testDeleteLinksWithPLuginJoinModel() {
+		$this->loadFixtures('Article', 'ArticlesTag', 'Tag');
+		$Article = new Article();
+		$Article->unbindModel(array('hasAndBelongsToMany' => array('Tag')), false);
+		unset($Article->Tag, $Article->ArticleTags);
+		$Article->bindModel(array('hasAndBelongsToMany' => array(
+			'Tag' => array('with' => 'TestPlugin.ArticlesTag')
+		)), false);
+
+		$Article->ArticlesTag->order = null;
+		$this->assertTrue($Article->delete(1));
+	}
+
+/**
+ * testDeleteDependent method
+ *
+ * @return void
+ */
+	public function testDeleteDependent() {
+		$this->loadFixtures('Bidding', 'BiddingMessage', 'Article',
+			'ArticlesTag', 'Comment', 'User', 'Attachment'
+		);
+		$Bidding = new Bidding();
+		$result = $Bidding->find('all', array('order' => array('Bidding.id' => 'ASC')));
+		$expected = array(
+			array(
+				'Bidding' => array('id' => 1, 'bid' => 'One', 'name' => 'Bid 1'),
+				'BiddingMessage' => array('bidding' => 'One', 'name' => 'Message 1'),
+			),
+			array(
+				'Bidding' => array('id' => 2, 'bid' => 'Two', 'name' => 'Bid 2'),
+				'BiddingMessage' => array('bidding' => 'Two', 'name' => 'Message 2'),
+			),
+			array(
+				'Bidding' => array('id' => 3, 'bid' => 'Three', 'name' => 'Bid 3'),
+				'BiddingMessage' => array('bidding' => 'Three', 'name' => 'Message 3'),
+			),
+			array(
+				'Bidding' => array('id' => 4, 'bid' => 'Five', 'name' => 'Bid 5'),
+				'BiddingMessage' => array('bidding' => '', 'name' => ''),
+			),
+		);
+		$this->assertEquals($expected, $result);
+
+		$Bidding->delete(4, true);
+		$result = $Bidding->find('all', array('order' => array('Bidding.id' => 'ASC')));
+		$expected = array(
+			array(
+				'Bidding' => array('id' => 1, 'bid' => 'One', 'name' => 'Bid 1'),
+				'BiddingMessage' => array('bidding' => 'One', 'name' => 'Message 1'),
+			),
+			array(
+				'Bidding' => array('id' => 2, 'bid' => 'Two', 'name' => 'Bid 2'),
+				'BiddingMessage' => array('bidding' => 'Two', 'name' => 'Message 2'),
+			),
+			array(
+				'Bidding' => array('id' => 3, 'bid' => 'Three', 'name' => 'Bid 3'),
+				'BiddingMessage' => array('bidding' => 'Three', 'name' => 'Message 3'),
+			),
+		);
+		$this->assertEquals($expected, $result);
+
+		$Bidding->delete(2, true);
+		$result = $Bidding->find('all', array('order' => array('Bidding.id' => 'ASC')));
+		$expected = array(
+			array(
+				'Bidding' => array('id' => 1, 'bid' => 'One', 'name' => 'Bid 1'),
+				'BiddingMessage' => array('bidding' => 'One', 'name' => 'Message 1'),
+			),
+			array(
+				'Bidding' => array('id' => 3, 'bid' => 'Three', 'name' => 'Bid 3'),
+				'BiddingMessage' => array('bidding' => 'Three', 'name' => 'Message 3'),
+			),
+		);
+		$this->assertEquals($expected, $result);
+
+		$result = $Bidding->BiddingMessage->find('all', array('order' => array('BiddingMessage.name' => 'ASC')));
+		$expected = array(
+			array(
+				'BiddingMessage' => array('bidding' => 'One', 'name' => 'Message 1'),
+				'Bidding' => array('id' => 1, 'bid' => 'One', 'name' => 'Bid 1'),
+			),
+			array(
+				'BiddingMessage' => array('bidding' => 'Three', 'name' => 'Message 3'),
+				'Bidding' => array('id' => 3, 'bid' => 'Three', 'name' => 'Bid 3'),
+			),
+			array(
+				'BiddingMessage' => array('bidding' => 'Four', 'name' => 'Message 4'),
+				'Bidding' => array('id' => '', 'bid' => '', 'name' => ''),
+			),
+		);
+		$this->assertEquals($expected, $result);
+
+		$Article = new Article();
+		$result = $Article->Comment->find('count', array(
+			'conditions' => array('Comment.article_id' => 1)
+		));
+		$this->assertEquals(4, $result);
+
+		$result = $Article->delete(1, true);
+		$this->assertTrue($result);
+
+		$result = $Article->Comment->find('count', array(
+			'conditions' => array('Comment.article_id' => 1)
+		));
+		$this->assertEquals(0, $result);
+	}
+
+/**
+ * test deleteLinks with Multiple habtm associations
+ *
+ * @return void
+ */
+	public function testDeleteLinksWithMultipleHabtmAssociations() {
+		$this->loadFixtures('JoinA', 'JoinB', 'JoinC', 'JoinAB', 'JoinAC');
+		$JoinA = new JoinA();
+
+		//create two new join records to expose the issue.
+		$JoinA->JoinAsJoinC->create(array(
+			'join_a_id' => 1,
+			'join_c_id' => 2,
+		));
+		$JoinA->JoinAsJoinC->save();
+		$JoinA->JoinAsJoinB->create(array(
+			'join_a_id' => 1,
+			'join_b_id' => 2,
+		));
+		$JoinA->JoinAsJoinB->save();
+
+		$result = $JoinA->delete(1);
+		$this->assertTrue($result, 'Delete failed %s');
+
+		$joinedBs = $JoinA->JoinAsJoinB->find('count', array(
+			'conditions' => array('JoinAsJoinB.join_a_id' => 1)
+		));
+		$this->assertEquals(0, $joinedBs, 'JoinA/JoinB link records left over. %s');
+
+		$joinedBs = $JoinA->JoinAsJoinC->find('count', array(
+			'conditions' => array('JoinAsJoinC.join_a_id' => 1)
+		));
+		$this->assertEquals(0, $joinedBs, 'JoinA/JoinC link records left over. %s');
+	}
+
+/**
+ * testHabtmDeleteLinksWhenNoPrimaryKeyInJoinTable method
+ *
+ * @return void
+ */
+	public function testHabtmDeleteLinksWhenNoPrimaryKeyInJoinTable() {
+		$this->loadFixtures('Apple', 'Device', 'ThePaperMonkies');
+		$ThePaper = new ThePaper();
+		$ThePaper->id = 1;
+		$ThePaper->save(array('Monkey' => array(2, 3)));
+
+		$result = $ThePaper->findById(1);
+		$expected = array(
+			array(
+				'id' => '2',
+				'device_type_id' => '1',
+				'name' => 'Device 2',
+				'typ' => '1'
+			),
+			array(
+				'id' => '3',
+				'device_type_id' => '1',
+				'name' => 'Device 3',
+				'typ' => '2'
+		));
+		$this->assertEquals($expected, $result['Monkey']);
+
+		$ThePaper = new ThePaper();
+		$ThePaper->id = 2;
+		$ThePaper->save(array('Monkey' => array(2, 3)));
+
+		$result = $ThePaper->findById(2);
+		$expected = array(
+			array(
+				'id' => '2',
+				'device_type_id' => '1',
+				'name' => 'Device 2',
+				'typ' => '1'
+			),
+			array(
+				'id' => '3',
+				'device_type_id' => '1',
+				'name' => 'Device 3',
+				'typ' => '2'
+		));
+		$this->assertEquals($expected, $result['Monkey']);
+
+		$ThePaper->delete(1);
+		$result = $ThePaper->findById(2);
+		$expected = array(
+			array(
+				'id' => '2',
+				'device_type_id' => '1',
+				'name' => 'Device 2',
+				'typ' => '1'
+			),
+			array(
+				'id' => '3',
+				'device_type_id' => '1',
+				'name' => 'Device 3',
+				'typ' => '2'
+		));
+		$this->assertEquals($expected, $result['Monkey']);
+	}
+
+/**
+ * test that beforeDelete returning false can abort deletion.
+ *
+ * @return void
+ */
+	public function testBeforeDeleteDeleteAbortion() {
+		$this->loadFixtures('Post');
+		$Model = new CallbackPostTestModel();
+		$Model->beforeDeleteReturn = false;
+
+		$result = $Model->delete(1);
+		$this->assertFalse($result);
+
+		$exists = $Model->findById(1);
+		$this->assertTrue(is_array($exists));
+	}
+
+/**
+ * test for a habtm deletion error that occurs in postgres but should not.
+ * And should not occur in any dbo.
+ *
+ * @return void
+ */
+	public function testDeleteHabtmPostgresFailure() {
+		$this->loadFixtures('Article', 'Tag', 'ArticlesTag');
+
+		$Article = ClassRegistry::init('Article');
+		$Article->hasAndBelongsToMany['Tag']['unique'] = true;
+
+		$Tag = ClassRegistry::init('Tag');
+		$Tag->bindModel(array('hasAndBelongsToMany' => array(
+			'Article' => array(
+				'className' => 'Article',
+				'unique' => true
+			)
+		)), true);
+
+		// Article 1 should have Tag.1 and Tag.2
+		$before = $Article->find("all", array(
+			"conditions" => array("Article.id" => 1),
+		));
+		$this->assertEquals(2, count($before[0]['Tag']), 'Tag count for Article.id = 1 is incorrect, should be 2 %s');
+
+		// From now on, Tag #1 is only associated with Post #1
+		$submittedData = array(
+			"Tag" => array("id" => 1, 'tag' => 'tag1'),
+			"Article" => array(
+				"Article" => array(1)
+			)
+		);
+		$Tag->save($submittedData);
+
+		// One more submission (The other way around) to make sure the reverse save looks good.
+		$submittedData = array(
+			"Article" => array("id" => 2, 'title' => 'second article'),
+			"Tag" => array(
+				"Tag" => array(2, 3)
+			)
+		);
+
+		// ERROR:
+		// Postgresql: DELETE FROM "articles_tags" WHERE tag_id IN ('1', '3')
+		// MySQL: DELETE `ArticlesTag` FROM `articles_tags` AS `ArticlesTag` WHERE `ArticlesTag`.`article_id` = 2 AND `ArticlesTag`.`tag_id` IN (1, 3)
+		$Article->save($submittedData);
+
+		// Want to make sure Article #1 has Tag #1 and Tag #2 still.
+		$after = $Article->find("all", array(
+			"conditions" => array("Article.id" => 1),
+		));
+
+		// Removing Article #2 from Tag #1 is all that should have happened.
+		$this->assertEquals(count($before[0]["Tag"]), count($after[0]["Tag"]));
+	}
+
+/**
+ * test that deleting records inside the beforeDelete doesn't truncate the table.
+ *
+ * @return void
+ */
+	public function testBeforeDeleteWipingTable() {
+		$this->loadFixtures('Comment');
+
+		$Comment = new BeforeDeleteComment();
+		// Delete 3 records.
+		$Comment->delete(4);
+		$result = $Comment->find('count');
+
+		$this->assertTrue($result > 1, 'Comments are all gone.');
+		$Comment->create(array(
+			'article_id' => 1,
+			'user_id' => 2,
+			'comment' => 'new record',
+			'published' => 'Y'
+		));
+		$Comment->save();
+
+		$Comment->delete(5);
+		$result = $Comment->find('count');
+
+		$this->assertTrue($result > 1, 'Comments are all gone.');
+	}
+
+/**
+ * test that deleting the same record from the beforeDelete and the delete doesn't truncate the table.
+ *
+ * @return void
+ */
+	public function testBeforeDeleteWipingTableWithDuplicateDelete() {
+		$this->loadFixtures('Comment');
+
+		$Comment = new BeforeDeleteComment();
+		$Comment->delete(1);
+
+		$result = $Comment->find('count');
+		$this->assertTrue($result > 1, 'Comments are all gone.');
+	}
+}

lib/Cake/Test/Case/Model/ModelTest.php

@@ -0,0 +1,46 @@
+<?php
+/**
+ * ModelTest file
+ *
+ * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
+ * 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://cakephp.org CakePHP(tm) Project
+ * @package       Cake.Test.Case
+ * @since         CakePHP(tm) v 2.0
+ * @license       http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+
+/**
+ * ModelTest class
+ *
+ * This test group will run model class tests
+ *
+ * @package       Cake.Test.Case
+ */
+class ModelTest extends PHPUnit_Framework_TestSuite {
+
+/**
+ * suite method, defines tests for this suite.
+ *
+ * @return void
+ */
+	public static function suite() {
+		$suite = new PHPUnit_Framework_TestSuite('All Model related class tests');
+
+		$suite->addTestFile(CORE_TEST_CASES . DS . 'Model' . DS . 'Validator' . DS . 'CakeValidationSetTest.php');
+		$suite->addTestFile(CORE_TEST_CASES . DS . 'Model' . DS . 'Validator' . DS . 'CakeValidationRuleTest.php');
+		$suite->addTestFile(CORE_TEST_CASES . DS . 'Model' . DS . 'ModelReadTest.php');
+		$suite->addTestFile(CORE_TEST_CASES . DS . 'Model' . DS . 'ModelWriteTest.php');
+		$suite->addTestFile(CORE_TEST_CASES . DS . 'Model' . DS . 'ModelDeleteTest.php');
+		$suite->addTestFile(CORE_TEST_CASES . DS . 'Model' . DS . 'ModelValidationTest.php');
+		$suite->addTestFile(CORE_TEST_CASES . DS . 'Model' . DS . 'ModelIntegrationTest.php');
+		$suite->addTestFile(CORE_TEST_CASES . DS . 'Model' . DS . 'ModelCrossSchemaHabtmTest.php');
+		return $suite;
+	}
+}

lib/Cake/Test/Case/Model/ModelTestBase.php

@@ -0,0 +1,96 @@
+<?php
+/**
+ * ModelTest file
+ *
+ * CakePHP(tm) Tests <http://book.cakephp.org/2.0/en/development/testing.html>
+ * 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/2.0/en/development/testing.html CakePHP(tm) Tests
+ * @package       Cake.Test.Case.Model
+ * @since         CakePHP(tm) v 1.2.0.4206
+ * @license       http://www.opensource.org/licenses/mit-license.php MIT License
+ */
+
+App::uses('Model', 'Model');
+App::uses('AppModel', 'Model');
+
+require_once dirname(__FILE__) . DS . 'models.php';
+
+/**
+ * ModelBaseTest
+ *
+ * @package       Cake.Test.Case.Model
+ */
+abstract class BaseModelTest extends CakeTestCase {
+
+/**
+ * autoFixtures property
+ *
+ * @var bool
+ */
+	public $autoFixtures = false;
+
+/**
+ * Whether backup global state for each test method or not
+ *
+ * @var bool
+ */
+	public $backupGlobals = false;
+
+/**
+ * fixtures property
+ *
+ * @var array
+ */
+	public $fixtures = array(
+		'core.category', 'core.category_thread', 'core.user', 'core.my_category', 'core.my_product',
+		'core.my_user', 'core.my_categories_my_users', 'core.my_categories_my_products',
+		'core.article', 'core.featured', 'core.article_featureds_tags', 'core.article_featured',
+		'core.numeric_article', 'core.tag', 'core.articles_tag', 'core.comment',
+		'core.attachment', 'core.apple', 'core.sample', 'core.another_article', 'core.item',
+		'core.advertisement', 'core.home', 'core.post', 'core.author', 'core.bid', 'core.portfolio',
+		'core.product', 'core.project', 'core.thread', 'core.message', 'core.items_portfolio',
+		'core.syfile', 'core.image', 'core.device_type', 'core.device_type_category',
+		'core.feature_set', 'core.exterior_type_category', 'core.document', 'core.device',
+		'core.document_directory', 'core.primary_model', 'core.secondary_model', 'core.something',
+		'core.something_else', 'core.join_thing', 'core.join_a', 'core.join_b', 'core.join_c',
+		'core.join_a_b', 'core.join_a_c', 'core.uuid', 'core.data_test', 'core.posts_tag',
+		'core.the_paper_monkies', 'core.person', 'core.underscore_field', 'core.node',
+		'core.dependency', 'core.story', 'core.stories_tag', 'core.cd', 'core.book', 'core.basket',
+		'core.overall_favorite', 'core.account', 'core.content', 'core.content_account',
+		'core.film_file', 'core.test_plugin_article', 'core.test_plugin_comment', 'core.uuiditem',
+		'core.counter_cache_user', 'core.counter_cache_post',
+		'core.counter_cache_user_nonstandard_primary_key',
+		'core.counter_cache_post_nonstandard_primary_key', 'core.uuidportfolio',
+		'core.uuiditems_uuidportfolio', 'core.uuiditems_uuidportfolio_numericid', 'core.fruit',
+		'core.fruits_uuid_tag', 'core.uuid_tag', 'core.product_update_all', 'core.group_update_all',
+		'core.player', 'core.guild', 'core.guilds_player', 'core.armor', 'core.armors_player',
+		'core.bidding', 'core.bidding_message', 'core.site', 'core.domain', 'core.domains_site',
+	);
+
+/**
+ * setUp method
+ *
+ * @return void
+ */
+	public function setUp() {
+		parent::setUp();
+		$this->debug = Configure::read('debug');
+	}
+
+/**
+ * tearDown method
+ *
+ * @return void
+ */
+	public function tearDown() {
+		parent::tearDown();
+		Configure::write('debug', $this->debug);
+		ClassRegistry::flush();
+	}
+}

lib/Cake/Test/Case/Model/Validator/CakeValidationRuleTest.php

@@ -0,0 +1,198 @@
+<?php
+/**
+ * CakeValidationRuleTest 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('CakeValidationRule', 'Model/Validator');
+
+/**
+ * CakeValidationRuleTest
+ *
+ * @package       Cake.Test.Case.Model.Validator
+ */
+class CakeValidationRuleTest extends CakeTestCase {
+
+/**
+ * Auxiliary method to test custom validators
+ *
+ * @return bool
+ */
+	public function myTestRule() {
+		return false;
+	}
+
+/**
+ * Auxiliary method to test custom validators
+ *
+ * @return bool
+ */
+	public function myTestRule2() {
+		return true;
+	}
+
+/**
+ * Auxiliary method to test custom validators
+ *
+ * @return string
+ */
+	public function myTestRule3() {
+		return 'string';
+	}
+
+/**
+ * Test isValid method
+ *
+ * @return void
+ */
+	public function testIsValid() {
+		$def = array('rule' => 'notEmpty', 'message' => 'Can not be empty');
+		$data = array(
+			'fieldName' => ''
+		);
+		$methods = array();
+
+		$Rule = new CakeValidationRule($def);
+		$Rule->process('fieldName', $data, $methods);
+		$this->assertFalse($Rule->isValid());
+
+		$data = array('fieldName' => 'not empty');
+		$Rule->process('fieldName', $data, $methods);
+		$this->assertTrue($Rule->isValid());
+	}
+
+/**
+ * tests that passing custom validation methods work
+ *
+ * @return void
+ */
+	public function testCustomMethods() {
+		$def = array('rule' => 'myTestRule');
+		$data = array(
+			'fieldName' => 'some data'
+		);
+		$methods = array('mytestrule' => array($this, 'myTestRule'));
+
+		$Rule = new CakeValidationRule($def);
+		$Rule->process('fieldName', $data, $methods);
+		$this->assertFalse($Rule->isValid());
+
+		$methods = array('mytestrule' => array($this, 'myTestRule2'));
+		$Rule->process('fieldName', $data, $methods);
+		$this->assertTrue($Rule->isValid());
+
+		$methods = array('mytestrule' => array($this, 'myTestRule3'));
+		$Rule->process('fieldName', $data, $methods);
+		$this->assertFalse($Rule->isValid());
+	}
+
+/**
+ * Make sure errors are triggered when validation is missing.
+ *
+ * @expectedException PHPUnit_Framework_Error_Warning
+ * @expectedExceptionMessage Could not find validation handler totallyMissing for fieldName
+ * @return void
+ */
+	public function testCustomMethodMissingError() {
+		$def = array('rule' => array('totallyMissing'));
+		$data = array(
+			'fieldName' => 'some data'
+		);
+		$methods = array('mytestrule' => array($this, 'myTestRule'));
+
+		$Rule = new CakeValidationRule($def);
+		$Rule->process('fieldName', $data, $methods);
+	}
+
+/**
+ * Test isRequired method
+ *
+ * @return void
+ */
+	public function testIsRequired() {
+		$def = array('rule' => 'notEmpty', 'required' => true);
+		$Rule = new CakeValidationRule($def);
+		$this->assertTrue($Rule->isRequired());
+
+		$def = array('rule' => 'notEmpty', 'required' => false);
+		$Rule = new CakeValidationRule($def);
+		$this->assertFalse($Rule->isRequired());
+
+		$def = array('rule' => 'notEmpty', 'required' => 'create');
+		$Rule = new CakeValidationRule($def);
+		$this->assertTrue($Rule->isRequired());
+
+		$def = array('rule' => 'notEmpty', 'required' => 'update');
+		$Rule = new CakeValidationRule($def);
+		$this->assertFalse($Rule->isRequired());
+
+		$Rule->isUpdate(true);
+		$this->assertTrue($Rule->isRequired());
+	}
+
+/**
+ * Test isEmptyAllowed method
+ *
+ * @return void
+ */
+	public function testIsEmptyAllowed() {
+		$def = array('rule' => 'aRule', 'allowEmpty' => true);
+		$Rule = new CakeValidationRule($def);
+		$this->assertTrue($Rule->isEmptyAllowed());
+
+		$def = array('rule' => 'aRule', 'allowEmpty' => false);
+		$Rule = new CakeValidationRule($def);
+		$this->assertFalse($Rule->isEmptyAllowed());
+
+		$def = array('rule' => 'notEmpty', 'allowEmpty' => false, 'on' => 'update');
+		$Rule = new CakeValidationRule($def);
+		$this->assertTrue($Rule->isEmptyAllowed());
+
+		$Rule->isUpdate(true);
+		$this->assertFalse($Rule->isEmptyAllowed());
+
+		$def = array('rule' => 'notEmpty', 'allowEmpty' => false, 'on' => 'create');
+		$Rule = new CakeValidationRule($def);
+		$this->assertFalse($Rule->isEmptyAllowed());
+
+		$Rule->isUpdate(true);
+		$this->assertTrue($Rule->isEmptyAllowed());
+	}
+
+/**
+ * Test checkRequired method
+ *
+ * @return void
+ */
+	public function testCheckRequiredWhenRequiredAndAllowEmpty() {
+		$Rule = $this->getMock('CakeValidationRule', array('isRequired'));
+		$Rule->expects($this->any())
+			->method('isRequired')
+			->will($this->returnValue(true));
+		$Rule->allowEmpty = true;
+
+		$fieldname = 'field';
+		$data = array(
+			$fieldname => null
+		);
+
+		$this->assertFalse($Rule->checkRequired($fieldname, $data), "A null but present field should not fail requirement check if allowEmpty is true");
+
+		$Rule->allowEmpty = false;
+
+		$this->assertTrue($Rule->checkRequired($fieldname, $data), "A null but present field should fail requirement check if allowEmpty is false");
+	}
+
+}

lib/Cake/Test/Case/Model/Validator/CakeValidationSetTest.php

@@ -0,0 +1,337 @@
+<?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']));
+	}
+
+}