2008-05-30 11:40:08 +00:00
< ? php
2008-06-02 19:22:55 +00:00
/**
2009-03-19 21:10:13 +00:00
* BehaviorTest file
2008-06-27 07:23:22 +00:00
*
2008-06-02 19:22:55 +00:00
* Long description for behavior . test . php
2008-06-27 07:23:22 +00:00
*
2010-10-03 16:31:21 +00:00
* PHP 5
2008-06-27 07:23:22 +00:00
*
2009-05-01 21:05:46 +00:00
* CakePHP ( tm ) : Rapid Development Framework ( http :// cakephp . org )
2010-10-24 20:58:22 +00:00
* Copyright 2005 - 2010 , Cake Software Foundation , Inc . ( http :// cakefoundation . org )
2008-06-27 07:23:22 +00:00
*
2008-06-02 19:22:55 +00:00
* Licensed under The MIT License
* Redistributions of files must retain the above copyright notice .
2008-06-27 07:23:22 +00:00
*
2010-01-26 22:15:15 +00:00
* @ copyright CakePHP ( tm ) : Rapid Development Framework ( http :// cakephp . org )
2010-01-26 22:03:03 +00:00
* @ link http :// cakephp . org CakePHP ( tm ) Project
2010-12-24 18:57:20 +00:00
* @ package cake . tests . cases . libs . model
2008-10-30 17:30:26 +00:00
* @ since 1.2
2009-05-01 21:05:46 +00:00
* @ license MIT License ( http :// www . opensource . org / licenses / mit - license . php )
2008-06-02 19:22:55 +00:00
*/
2010-12-09 05:55:24 +00:00
App :: uses ( 'AppModel' , 'Model' );
2008-05-30 11:40:08 +00:00
require_once dirname ( __FILE__ ) . DS . 'models.php' ;
2009-07-24 19:18:37 +00:00
2008-05-30 11:40:08 +00:00
/**
2009-03-19 21:10:13 +00:00
* TestBehavior class
2008-05-30 11:40:08 +00:00
*
2010-12-24 18:57:20 +00:00
* @ package cake . tests . cases . libs . model
2008-05-30 11:40:08 +00:00
*/
class TestBehavior extends ModelBehavior {
2009-07-24 19:18:37 +00:00
2008-06-02 19:22:55 +00:00
/**
* mapMethods property
2008-06-27 07:23:22 +00:00
*
2008-06-02 19:22:55 +00:00
* @ var array
* @ access public
*/
2010-04-04 07:14:00 +00:00
public $mapMethods = array ( '/test(\w+)/' => 'testMethod' , '/look for\s+(.+)/' => 'speakEnglish' );
2009-07-24 19:18:37 +00:00
2008-06-02 19:22:55 +00:00
/**
* setup method
2008-06-27 07:23:22 +00:00
*
* @ param mixed $model
* @ param array $config
2008-06-02 19:22:55 +00:00
* @ access public
* @ return void
*/
2010-12-12 22:41:57 +00:00
function setup ( $model , $config = array ()) {
2008-05-30 11:40:08 +00:00
parent :: setup ( $model , $config );
if ( isset ( $config [ 'mangle' ])) {
$config [ 'mangle' ] .= ' mangled' ;
}
$this -> settings [ $model -> alias ] = array_merge ( array ( 'beforeFind' => 'on' , 'afterFind' => 'off' ), $config );
}
2009-07-24 19:18:37 +00:00
2008-06-02 19:22:55 +00:00
/**
* beforeFind method
2008-06-27 07:23:22 +00:00
*
* @ param mixed $model
* @ param mixed $query
2008-06-02 19:22:55 +00:00
* @ access public
* @ return void
*/
2010-12-12 22:41:57 +00:00
function beforeFind ( $model , $query ) {
2008-05-30 11:40:08 +00:00
$settings = $this -> settings [ $model -> alias ];
if ( ! isset ( $settings [ 'beforeFind' ]) || $settings [ 'beforeFind' ] == 'off' ) {
return parent :: beforeFind ( $model , $query );
}
switch ( $settings [ 'beforeFind' ]) {
case 'on' :
return false ;
break ;
case 'test' :
return null ;
break ;
case 'modify' :
$query [ 'fields' ] = array ( $model -> alias . '.id' , $model -> alias . '.name' , $model -> alias . '.mytime' );
$query [ 'recursive' ] = - 1 ;
return $query ;
break ;
}
}
2009-07-24 19:18:37 +00:00
2008-06-02 19:22:55 +00:00
/**
* afterFind method
2008-06-27 07:23:22 +00:00
*
* @ param mixed $model
* @ param mixed $results
* @ param mixed $primary
2008-06-02 19:22:55 +00:00
* @ access public
* @ return void
*/
2010-12-12 22:41:57 +00:00
function afterFind ( $model , $results , $primary ) {
2008-05-30 11:40:08 +00:00
$settings = $this -> settings [ $model -> alias ];
if ( ! isset ( $settings [ 'afterFind' ]) || $settings [ 'afterFind' ] == 'off' ) {
return parent :: afterFind ( $model , $results , $primary );
}
switch ( $settings [ 'afterFind' ]) {
case 'on' :
return array ();
break ;
case 'test' :
return true ;
break ;
case 'test2' :
return null ;
break ;
case 'modify' :
2008-05-31 12:36:38 +00:00
return Set :: extract ( $results , " { n}. { $model -> alias } " );
2008-05-30 11:40:08 +00:00
break ;
}
}
2009-07-24 19:18:37 +00:00
2008-06-02 19:22:55 +00:00
/**
* beforeSave method
2008-06-27 07:23:22 +00:00
*
* @ param mixed $model
2008-06-02 19:22:55 +00:00
* @ access public
* @ return void
*/
2010-12-12 22:41:57 +00:00
function beforeSave ( $model ) {
2008-05-30 11:40:08 +00:00
$settings = $this -> settings [ $model -> alias ];
if ( ! isset ( $settings [ 'beforeSave' ]) || $settings [ 'beforeSave' ] == 'off' ) {
return parent :: beforeSave ( $model );
}
switch ( $settings [ 'beforeSave' ]) {
case 'on' :
return false ;
break ;
case 'test' :
2010-12-12 22:41:57 +00:00
return true ;
2008-05-30 11:40:08 +00:00
break ;
case 'modify' :
$model -> data [ $model -> alias ][ 'name' ] .= ' modified before' ;
return true ;
break ;
2008-06-27 07:23:22 +00:00
}
2008-05-30 11:40:08 +00:00
}
2009-07-24 19:18:37 +00:00
2008-06-02 19:22:55 +00:00
/**
* afterSave method
2008-06-27 07:23:22 +00:00
*
* @ param mixed $model
* @ param mixed $created
2008-06-02 19:22:55 +00:00
* @ access public
* @ return void
*/
2010-12-12 22:41:57 +00:00
function afterSave ( $model , $created ) {
2008-05-30 11:40:08 +00:00
$settings = $this -> settings [ $model -> alias ];
if ( ! isset ( $settings [ 'afterSave' ]) || $settings [ 'afterSave' ] == 'off' ) {
return parent :: afterSave ( $model , $created );
}
$string = 'modified after' ;
if ( $created ) {
$string .= ' on create' ;
}
switch ( $settings [ 'afterSave' ]) {
case 'on' :
$model -> data [ $model -> alias ][ 'aftersave' ] = $string ;
break ;
case 'test' :
unset ( $model -> data [ $model -> alias ][ 'name' ]);
break ;
case 'test2' :
return false ;
break ;
case 'modify' :
$model -> data [ $model -> alias ][ 'name' ] .= ' ' . $string ;
2008-06-27 07:23:22 +00:00
break ;
2008-05-30 11:40:08 +00:00
}
}
2009-07-24 19:18:37 +00:00
2008-06-02 19:22:55 +00:00
/**
* beforeValidate method
2008-06-27 07:23:22 +00:00
*
* @ param mixed $model
2008-06-02 19:22:55 +00:00
* @ access public
* @ return void
*/
2010-12-12 22:41:57 +00:00
function beforeValidate ( $model ) {
2008-05-30 11:40:08 +00:00
$settings = $this -> settings [ $model -> alias ];
if ( ! isset ( $settings [ 'validate' ]) || $settings [ 'validate' ] == 'off' ) {
return parent :: beforeValidate ( $model );
}
switch ( $settings [ 'validate' ]) {
case 'on' :
$model -> invalidate ( 'name' );
return true ;
break ;
case 'test' :
return null ;
break ;
case 'whitelist' :
$this -> _addToWhitelist ( $model , array ( 'name' ));
return true ;
break ;
case 'stop' :
$model -> invalidate ( 'name' );
return false ;
break ;
2008-06-27 07:23:22 +00:00
}
2008-05-30 11:40:08 +00:00
}
2009-07-24 19:18:37 +00:00
2008-06-02 19:22:55 +00:00
/**
* beforeDelete method
2008-06-27 07:23:22 +00:00
*
* @ param mixed $model
* @ param bool $cascade
2008-06-02 19:22:55 +00:00
* @ access public
* @ return void
*/
2010-12-12 22:41:57 +00:00
function beforeDelete ( $model , $cascade = true ) {
2010-06-05 03:57:28 +00:00
$settings = $this -> settings [ $model -> alias ];
2008-05-30 11:40:08 +00:00
if ( ! isset ( $settings [ 'beforeDelete' ]) || $settings [ 'beforeDelete' ] == 'off' ) {
return parent :: beforeDelete ( $model , $cascade );
2008-06-27 07:23:22 +00:00
}
2008-05-30 11:40:08 +00:00
switch ( $settings [ 'beforeDelete' ]) {
case 'on' :
return false ;
break ;
case 'test' :
return null ;
break ;
case 'test2' :
echo 'beforeDelete success' ;
if ( $cascade ) {
echo ' (cascading) ' ;
}
2010-12-12 22:41:57 +00:00
return true ;
2008-05-30 11:40:08 +00:00
break ;
2008-06-27 07:23:22 +00:00
}
2008-05-30 11:40:08 +00:00
}
2009-07-24 19:18:37 +00:00
2008-06-02 19:22:55 +00:00
/**
* afterDelete method
2008-06-27 07:23:22 +00:00
*
* @ param mixed $model
2008-06-02 19:22:55 +00:00
* @ access public
* @ return void
*/
2010-12-12 22:41:57 +00:00
function afterDelete ( $model ) {
2010-06-05 03:57:28 +00:00
$settings = $this -> settings [ $model -> alias ];
2008-05-30 11:40:08 +00:00
if ( ! isset ( $settings [ 'afterDelete' ]) || $settings [ 'afterDelete' ] == 'off' ) {
return parent :: afterDelete ( $model );
2008-06-27 07:23:22 +00:00
}
2008-05-30 11:40:08 +00:00
switch ( $settings [ 'afterDelete' ]) {
case 'on' :
echo 'afterDelete success' ;
break ;
2008-06-27 07:23:22 +00:00
}
2008-05-30 11:40:08 +00:00
}
2009-07-24 19:18:37 +00:00
2008-06-02 19:22:55 +00:00
/**
* onError method
2008-06-27 07:23:22 +00:00
*
* @ param mixed $model
2008-06-02 19:22:55 +00:00
* @ access public
* @ return void
*/
2010-12-12 22:41:57 +00:00
function onError ( $model , $error ) {
2008-05-30 11:40:08 +00:00
$settings = $this -> settings [ $model -> alias ];
if ( ! isset ( $settings [ 'onError' ]) || $settings [ 'onError' ] == 'off' ) {
2010-12-12 22:41:57 +00:00
return parent :: onError ( $model , $error );
2008-05-30 11:40:08 +00:00
}
echo " onError trigger success " ;
}
2009-08-03 18:13:46 +00:00
/**
2008-06-02 19:22:55 +00:00
* beforeTest method
2008-06-27 07:23:22 +00:00
*
* @ param mixed $model
2008-06-02 19:22:55 +00:00
* @ access public
* @ return void
*/
2010-12-12 22:41:57 +00:00
function beforeTest ( $model ) {
2010-07-14 21:28:12 +00:00
if ( ! isset ( $model -> beforeTestResult )) {
$model -> beforeTestResult = array ();
}
2009-08-03 18:12:42 +00:00
$model -> beforeTestResult [] = strtolower ( get_class ( $this ));
return strtolower ( get_class ( $this ));
2008-05-30 11:40:08 +00:00
}
2009-07-24 19:18:37 +00:00
2008-06-02 19:22:55 +00:00
/**
* testMethod method
2008-06-27 07:23:22 +00:00
*
* @ param mixed $model
* @ param bool $param
2008-06-02 19:22:55 +00:00
* @ access public
* @ return void
*/
2010-06-05 03:57:28 +00:00
function testMethod ( Model $model , $param = true ) {
2008-05-30 11:40:08 +00:00
if ( $param === true ) {
return 'working' ;
}
}
2009-07-24 19:18:37 +00:00
2008-06-02 19:22:55 +00:00
/**
* testData method
2008-06-27 07:23:22 +00:00
*
* @ param mixed $model
2008-06-02 19:22:55 +00:00
* @ access public
* @ return void
*/
2010-06-05 03:57:28 +00:00
function testData ( Model $model ) {
2008-05-30 11:40:08 +00:00
if ( ! isset ( $model -> data [ 'Apple' ][ 'field' ])) {
return false ;
}
$model -> data [ 'Apple' ][ 'field_2' ] = true ;
return true ;
}
2009-07-24 19:18:37 +00:00
2008-06-02 19:22:55 +00:00
/**
* validateField method
2008-06-27 07:23:22 +00:00
*
* @ param mixed $model
* @ param mixed $field
2008-06-02 19:22:55 +00:00
* @ access public
* @ return void
*/
2010-06-05 03:57:28 +00:00
function validateField ( Model $model , $field ) {
2008-05-30 11:40:08 +00:00
return current ( $field ) === 'Orange' ;
}
2009-07-24 19:18:37 +00:00
2008-06-02 19:22:55 +00:00
/**
* speakEnglish method
2008-06-27 07:23:22 +00:00
*
* @ param mixed $model
* @ param mixed $method
* @ param mixed $query
2008-06-02 19:22:55 +00:00
* @ access public
* @ return void
*/
2010-06-05 03:57:28 +00:00
function speakEnglish ( Model $model , $method , $query ) {
2008-05-30 11:40:08 +00:00
$method = preg_replace ( '/look for\s+/' , 'Item.name = \'' , $method );
$query = preg_replace ( '/^in\s+/' , 'Location.name = \'' , $query );
return $method . '\' AND ' . $query . '\'' ;
}
}
2009-07-24 19:18:37 +00:00
2008-06-02 19:22:55 +00:00
/**
* Test2Behavior class
2008-06-27 07:23:22 +00:00
*
2010-12-24 18:57:20 +00:00
* @ package cake . tests . cases . libs . model
2008-06-02 19:22:55 +00:00
*/
2010-12-26 19:25:57 +00:00
class Test2Behavior extends TestBehavior {
public $mapMethods = array ( '/mappingRobot(\w+)/' => 'mapped' );
function resolveMethod ( $model , $stuff ) {
2011-04-17 10:35:21 +00:00
2010-12-26 19:25:57 +00:00
}
2011-04-17 10:35:21 +00:00
2010-12-26 19:25:57 +00:00
function mapped ( $model , $method , $query ) {
2011-04-17 10:35:21 +00:00
2010-12-26 19:25:57 +00:00
}
2008-05-30 11:40:08 +00:00
}
2009-07-24 19:18:37 +00:00
2008-06-02 19:22:55 +00:00
/**
* Test3Behavior class
2008-06-27 07:23:22 +00:00
*
2010-12-24 18:57:20 +00:00
* @ package cake . tests . cases . libs . model
2008-06-02 19:22:55 +00:00
*/
2008-05-30 11:40:08 +00:00
class Test3Behavior extends TestBehavior {
}
2009-07-24 19:18:37 +00:00
2009-07-06 22:38:37 +00:00
/**
* Test4Behavior class
*
2010-12-24 18:57:20 +00:00
* @ package cake . tests . cases . libs . model
2009-07-06 22:38:37 +00:00
*/
class Test4Behavior extends ModelBehavior {
2010-12-12 22:41:57 +00:00
function setup ( $model , $config = null ) {
2009-07-06 22:38:37 +00:00
$model -> bindModel (
array ( 'hasMany' => array ( 'Comment' ))
);
}
}
2009-07-24 19:18:37 +00:00
2009-07-06 22:38:37 +00:00
/**
* Test5Behavior class
*
2010-12-24 18:57:20 +00:00
* @ package cake . tests . cases . libs . model
2009-07-06 22:38:37 +00:00
*/
class Test5Behavior extends ModelBehavior {
2010-12-12 22:41:57 +00:00
function setup ( $model , $config = null ) {
2009-07-06 22:38:37 +00:00
$model -> bindModel (
array ( 'belongsTo' => array ( 'User' ))
);
}
}
2009-07-24 19:18:37 +00:00
2009-07-06 22:38:37 +00:00
/**
* Test6Behavior class
*
2010-12-24 18:57:20 +00:00
* @ package cake . tests . cases . libs . model
2009-07-06 22:38:37 +00:00
*/
class Test6Behavior extends ModelBehavior {
2010-12-12 22:41:57 +00:00
function setup ( $model , $config = null ) {
2009-07-06 22:38:37 +00:00
$model -> bindModel (
array ( 'hasAndBelongsToMany' => array ( 'Tag' ))
);
}
}
2009-07-24 19:18:37 +00:00
2009-07-06 22:38:37 +00:00
/**
* Test7Behavior class
*
2010-12-24 18:57:20 +00:00
* @ package cake . tests . cases . libs . model
2009-07-06 22:38:37 +00:00
*/
class Test7Behavior extends ModelBehavior {
2010-12-12 22:41:57 +00:00
function setup ( $model , $config = null ) {
2009-07-06 22:38:37 +00:00
$model -> bindModel (
array ( 'hasOne' => array ( 'Attachment' ))
);
}
}
2009-07-24 19:18:37 +00:00
2011-01-10 02:28:05 +00:00
/**
* Extended TestBehavior
*/
class TestAliasBehavior extends TestBehavior {
}
2008-06-02 19:22:55 +00:00
/**
2010-09-06 17:51:42 +00:00
* BehaviorCollection class
2008-06-27 07:23:22 +00:00
*
2010-12-24 18:57:20 +00:00
* @ package cake . tests . cases . libs . model
2008-06-02 19:22:55 +00:00
*/
2010-09-06 17:51:42 +00:00
class BehaviorCollectionTest extends CakeTestCase {
2009-07-24 19:18:37 +00:00
2008-06-02 19:22:55 +00:00
/**
* fixtures property
2008-06-27 07:23:22 +00:00
*
2008-06-02 19:22:55 +00:00
* @ var array
* @ access public
*/
2010-04-04 07:14:00 +00:00
public $fixtures = array (
2009-07-06 22:38:37 +00:00
'core.apple' , 'core.sample' , 'core.article' , 'core.user' , 'core.comment' ,
'core.attachment' , 'core.tag' , 'core.articles_tag'
);
2009-07-24 19:18:37 +00:00
2011-01-10 02:28:05 +00:00
/**
* Tests loading aliased behaviors
*/
function testLoadAlias () {
$Apple = new Apple ();
$this -> assertIdentical ( $Apple -> Behaviors -> attached (), array ());
2011-01-14 02:04:06 +00:00
$Apple -> Behaviors -> load ( 'Test' , array ( 'className' => 'TestAlias' , 'somesetting' => true ));
2011-01-10 02:28:05 +00:00
$this -> assertIdentical ( $Apple -> Behaviors -> attached (), array ( 'Test' ));
$this -> assertInstanceOf ( 'TestAliasBehavior' , $Apple -> Behaviors -> Test );
$this -> assertTrue ( $Apple -> Behaviors -> Test -> settings [ 'Apple' ][ 'somesetting' ]);
$this -> assertEquals ( $Apple -> Behaviors -> Test -> testMethod ( $Apple , true ), 'working' );
$this -> assertEquals ( $Apple -> testMethod ( true ), 'working' );
$this -> assertEquals ( $Apple -> Behaviors -> dispatchMethod ( $Apple , 'testMethod' ), 'working' );
2011-01-15 01:44:33 +00:00
2011-04-17 10:35:21 +00:00
App :: build ( array ( 'plugins' => array ( CAKE . 'Test' . DS . 'test_app' . DS . 'Plugin' . DS )));
2011-05-13 06:13:35 +00:00
CakePlugin :: load ( 'TestPlugin' );
2011-01-15 01:44:33 +00:00
$this -> assertTrue ( $Apple -> Behaviors -> load ( 'SomeOther' , array ( 'className' => 'TestPlugin.TestPluginPersisterOne' )));
$this -> assertInstanceOf ( 'TestPluginPersisterOneBehavior' , $Apple -> Behaviors -> SomeOther );
$result = $Apple -> Behaviors -> attached ();
$this -> assertEquals ( array ( 'Test' , 'SomeOther' ), $result , 'attached() results are wrong.' );
App :: build ();
2011-05-13 06:13:35 +00:00
CakePlugin :: unload ();
2011-01-10 02:28:05 +00:00
}
2008-06-02 19:22:55 +00:00
/**
* testBehaviorBinding method
2008-06-27 07:23:22 +00:00
*
2008-06-02 19:22:55 +00:00
* @ access public
* @ return void
*/
2008-05-30 11:40:08 +00:00
function testBehaviorBinding () {
$Apple = new Apple ();
$this -> assertIdentical ( $Apple -> Behaviors -> attached (), array ());
$Apple -> Behaviors -> attach ( 'Test' , array ( 'key' => 'value' ));
$this -> assertIdentical ( $Apple -> Behaviors -> attached (), array ( 'Test' ));
$this -> assertEqual ( strtolower ( get_class ( $Apple -> Behaviors -> Test )), 'testbehavior' );
2009-08-30 23:33:21 +00:00
$expected = array ( 'beforeFind' => 'on' , 'afterFind' => 'off' , 'key' => 'value' );
$this -> assertEqual ( $Apple -> Behaviors -> Test -> settings [ 'Apple' ], $expected );
2008-05-30 11:40:08 +00:00
$this -> assertEqual ( array_keys ( $Apple -> Behaviors -> Test -> settings ), array ( 'Apple' ));
$this -> assertIdentical ( $Apple -> Sample -> Behaviors -> attached (), array ());
$Apple -> Sample -> Behaviors -> attach ( 'Test' , array ( 'key2' => 'value2' ));
$this -> assertIdentical ( $Apple -> Sample -> Behaviors -> attached (), array ( 'Test' ));
$this -> assertEqual ( $Apple -> Sample -> Behaviors -> Test -> settings [ 'Sample' ], array ( 'beforeFind' => 'on' , 'afterFind' => 'off' , 'key2' => 'value2' ));
2009-03-11 00:06:41 +00:00
$this -> assertEqual ( array_keys ( $Apple -> Behaviors -> Test -> settings ), array ( 'Apple' , 'Sample' ));
$this -> assertIdentical (
$Apple -> Sample -> Behaviors -> Test -> settings ,
$Apple -> Behaviors -> Test -> settings
);
2008-05-30 11:40:08 +00:00
$this -> assertNotIdentical ( $Apple -> Behaviors -> Test -> settings [ 'Apple' ], $Apple -> Sample -> Behaviors -> Test -> settings [ 'Sample' ]);
$Apple -> Behaviors -> attach ( 'Test' , array ( 'key2' => 'value2' , 'key3' => 'value3' , 'beforeFind' => 'off' ));
$Apple -> Sample -> Behaviors -> attach ( 'Test' , array ( 'key' => 'value' , 'key3' => 'value3' , 'beforeFind' => 'off' ));
$this -> assertEqual ( $Apple -> Behaviors -> Test -> settings [ 'Apple' ], array ( 'beforeFind' => 'off' , 'afterFind' => 'off' , 'key' => 'value' , 'key2' => 'value2' , 'key3' => 'value3' ));
$this -> assertEqual ( $Apple -> Behaviors -> Test -> settings [ 'Apple' ], $Apple -> Sample -> Behaviors -> Test -> settings [ 'Sample' ]);
$this -> assertFalse ( isset ( $Apple -> Child -> Behaviors -> Test ));
$Apple -> Child -> Behaviors -> attach ( 'Test' , array ( 'key' => 'value' , 'key2' => 'value2' , 'key3' => 'value3' , 'beforeFind' => 'off' ));
$this -> assertEqual ( $Apple -> Child -> Behaviors -> Test -> settings [ 'Child' ], $Apple -> Sample -> Behaviors -> Test -> settings [ 'Sample' ]);
$this -> assertFalse ( isset ( $Apple -> Parent -> Behaviors -> Test ));
$Apple -> Parent -> Behaviors -> attach ( 'Test' , array ( 'key' => 'value' , 'key2' => 'value2' , 'key3' => 'value3' , 'beforeFind' => 'off' ));
$this -> assertEqual ( $Apple -> Parent -> Behaviors -> Test -> settings [ 'Parent' ], $Apple -> Sample -> Behaviors -> Test -> settings [ 'Sample' ]);
$Apple -> Parent -> Behaviors -> attach ( 'Test' , array ( 'key' => 'value' , 'key2' => 'value' , 'key3' => 'value' , 'beforeFind' => 'off' ));
$this -> assertNotEqual ( $Apple -> Parent -> Behaviors -> Test -> settings [ 'Parent' ], $Apple -> Sample -> Behaviors -> Test -> settings [ 'Sample' ]);
$Apple -> Behaviors -> attach ( 'Plugin.Test' , array ( 'key' => 'new value' ));
2009-03-11 00:06:41 +00:00
$expected = array (
'beforeFind' => 'off' , 'afterFind' => 'off' , 'key' => 'new value' ,
'key2' => 'value2' , 'key3' => 'value3'
);
$this -> assertEqual ( $Apple -> Behaviors -> Test -> settings [ 'Apple' ], $expected );
2008-05-30 11:40:08 +00:00
$current = $Apple -> Behaviors -> Test -> settings [ 'Apple' ];
$expected = array_merge ( $current , array ( 'mangle' => 'trigger mangled' ));
$Apple -> Behaviors -> attach ( 'Test' , array ( 'mangle' => 'trigger' ));
$this -> assertEqual ( $Apple -> Behaviors -> Test -> settings [ 'Apple' ], $expected );
2009-03-11 00:06:41 +00:00
2008-05-30 11:40:08 +00:00
$Apple -> Behaviors -> attach ( 'Test' );
2008-05-31 12:36:38 +00:00
$expected = array_merge ( $current , array ( 'mangle' => 'trigger mangled mangled' ));
2009-03-11 00:06:41 +00:00
2008-05-30 11:40:08 +00:00
$this -> assertEqual ( $Apple -> Behaviors -> Test -> settings [ 'Apple' ], $expected );
$Apple -> Behaviors -> attach ( 'Test' , array ( 'mangle' => 'trigger' ));
2008-05-31 12:36:38 +00:00
$expected = array_merge ( $current , array ( 'mangle' => 'trigger mangled' ));
2008-05-30 11:40:08 +00:00
$this -> assertEqual ( $Apple -> Behaviors -> Test -> settings [ 'Apple' ], $expected );
}
2009-07-24 19:18:37 +00:00
2010-05-12 03:08:14 +00:00
/**
* test that attach () / detach () works with plugin . banana
*
* @ return void
*/
function testDetachWithPluginNames () {
$Apple = new Apple ();
$Apple -> Behaviors -> attach ( 'Plugin.Test' );
$this -> assertTrue ( isset ( $Apple -> Behaviors -> Test ), 'Missing behavior' );
$this -> assertEqual ( $Apple -> Behaviors -> attached (), array ( 'Test' ));
$Apple -> Behaviors -> detach ( 'Plugin.Test' );
$this -> assertEqual ( $Apple -> Behaviors -> attached (), array ());
$Apple -> Behaviors -> attach ( 'Plugin.Test' );
$this -> assertTrue ( isset ( $Apple -> Behaviors -> Test ), 'Missing behavior' );
$this -> assertEqual ( $Apple -> Behaviors -> attached (), array ( 'Test' ));
$Apple -> Behaviors -> detach ( 'Test' );
$this -> assertEqual ( $Apple -> Behaviors -> attached (), array ());
}
2009-08-30 23:33:21 +00:00
/**
* test that attaching a non existant Behavior triggers a cake error .
*
2011-01-28 06:18:15 +00:00
* @ expectedException MissingBehaviorClassException
2009-08-30 23:33:21 +00:00
* @ return void
2009-11-14 12:19:25 +00:00
*/
2009-08-30 23:33:21 +00:00
function testInvalidBehaviorCausingCakeError () {
2010-06-05 03:57:28 +00:00
$Apple = new Apple ();
2010-07-04 04:15:36 +00:00
$Apple -> Behaviors -> attach ( 'NoSuchBehavior' );
2009-08-30 23:33:21 +00:00
}
2008-06-02 19:22:55 +00:00
/**
* testBehaviorToggling method
2008-06-27 07:23:22 +00:00
*
2008-06-02 19:22:55 +00:00
* @ access public
* @ return void
*/
2008-05-30 11:40:08 +00:00
function testBehaviorToggling () {
$Apple = new Apple ();
2010-10-25 00:29:54 +00:00
$expected = $Apple -> find ( 'all' );
2008-05-30 11:40:08 +00:00
$this -> assertIdentical ( $Apple -> Behaviors -> enabled (), array ());
$Apple -> Behaviors -> init ( 'Apple' , array ( 'Test' => array ( 'key' => 'value' )));
$this -> assertIdentical ( $Apple -> Behaviors -> enabled (), array ( 'Test' ));
$Apple -> Behaviors -> disable ( 'Test' );
$this -> assertIdentical ( $Apple -> Behaviors -> attached (), array ( 'Test' ));
$this -> assertIdentical ( $Apple -> Behaviors -> enabled (), array ());
$Apple -> Sample -> Behaviors -> attach ( 'Test' );
$this -> assertIdentical ( $Apple -> Sample -> Behaviors -> enabled ( 'Test' ), true );
$this -> assertIdentical ( $Apple -> Behaviors -> enabled (), array ());
$Apple -> Behaviors -> enable ( 'Test' );
$this -> assertIdentical ( $Apple -> Behaviors -> attached ( 'Test' ), true );
$this -> assertIdentical ( $Apple -> Behaviors -> enabled (), array ( 'Test' ));
$Apple -> Behaviors -> disable ( 'Test' );
$this -> assertIdentical ( $Apple -> Behaviors -> enabled (), array ());
$Apple -> Behaviors -> attach ( 'Test' , array ( 'enabled' => true ));
$this -> assertIdentical ( $Apple -> Behaviors -> enabled (), array ( 'Test' ));
$Apple -> Behaviors -> attach ( 'Test' , array ( 'enabled' => false ));
$this -> assertIdentical ( $Apple -> Behaviors -> enabled (), array ());
$Apple -> Behaviors -> detach ( 'Test' );
$this -> assertIdentical ( $Apple -> Behaviors -> enabled (), array ());
}
2009-07-24 19:18:37 +00:00
2008-06-02 19:22:55 +00:00
/**
* testBehaviorFindCallbacks method
2008-06-27 07:23:22 +00:00
*
2008-06-02 19:22:55 +00:00
* @ access public
* @ return void
*/
2008-05-30 11:40:08 +00:00
function testBehaviorFindCallbacks () {
$Apple = new Apple ();
$expected = $Apple -> find ( 'all' );
$Apple -> Behaviors -> attach ( 'Test' );
$this -> assertIdentical ( $Apple -> find ( 'all' ), null );
$Apple -> Behaviors -> attach ( 'Test' , array ( 'beforeFind' => 'off' ));
$this -> assertIdentical ( $Apple -> find ( 'all' ), $expected );
$Apple -> Behaviors -> attach ( 'Test' , array ( 'beforeFind' => 'test' ));
$this -> assertIdentical ( $Apple -> find ( 'all' ), $expected );
$Apple -> Behaviors -> attach ( 'Test' , array ( 'beforeFind' => 'modify' ));
$expected2 = array (
array ( 'Apple' => array ( 'id' => '1' , 'name' => 'Red Apple 1' , 'mytime' => '22:57:17' )),
array ( 'Apple' => array ( 'id' => '2' , 'name' => 'Bright Red Apple' , 'mytime' => '22:57:17' )),
array ( 'Apple' => array ( 'id' => '3' , 'name' => 'green blue' , 'mytime' => '22:57:17' ))
);
2008-05-31 12:36:38 +00:00
$result = $Apple -> find ( 'all' , array ( 'conditions' => array ( 'Apple.id <' => '4' )));
2008-05-30 11:40:08 +00:00
$this -> assertEqual ( $result , $expected2 );
$Apple -> Behaviors -> disable ( 'Test' );
$result = $Apple -> find ( 'all' );
$this -> assertEqual ( $result , $expected );
$Apple -> Behaviors -> attach ( 'Test' , array ( 'beforeFind' => 'off' , 'afterFind' => 'on' ));
$this -> assertIdentical ( $Apple -> find ( 'all' ), array ());
$Apple -> Behaviors -> attach ( 'Test' , array ( 'afterFind' => 'off' ));
$this -> assertEqual ( $Apple -> find ( 'all' ), $expected );
$Apple -> Behaviors -> attach ( 'Test' , array ( 'afterFind' => 'test' ));
$this -> assertEqual ( $Apple -> find ( 'all' ), $expected );
$Apple -> Behaviors -> attach ( 'Test' , array ( 'afterFind' => 'test2' ));
$this -> assertEqual ( $Apple -> find ( 'all' ), $expected );
$Apple -> Behaviors -> attach ( 'Test' , array ( 'afterFind' => 'modify' ));
$expected = array (
array ( 'id' => '1' , 'apple_id' => '2' , 'color' => 'Red 1' , 'name' => 'Red Apple 1' , 'created' => '2006-11-22 10:38:58' , 'date' => '1951-01-04' , 'modified' => '2006-12-01 13:31:26' , 'mytime' => '22:57:17' ),
array ( 'id' => '2' , 'apple_id' => '1' , 'color' => 'Bright Red 1' , 'name' => 'Bright Red Apple' , 'created' => '2006-11-22 10:43:13' , 'date' => '2014-01-01' , 'modified' => '2006-11-30 18:38:10' , 'mytime' => '22:57:17' ),
array ( 'id' => '3' , 'apple_id' => '2' , 'color' => 'blue green' , 'name' => 'green blue' , 'created' => '2006-12-25 05:13:36' , 'date' => '2006-12-25' , 'modified' => '2006-12-25 05:23:24' , 'mytime' => '22:57:17' ),
array ( 'id' => '4' , 'apple_id' => '2' , 'color' => 'Blue Green' , 'name' => 'Test Name' , 'created' => '2006-12-25 05:23:36' , 'date' => '2006-12-25' , 'modified' => '2006-12-25 05:23:36' , 'mytime' => '22:57:17' ),
array ( 'id' => '5' , 'apple_id' => '5' , 'color' => 'Green' , 'name' => 'Blue Green' , 'created' => '2006-12-25 05:24:06' , 'date' => '2006-12-25' , 'modified' => '2006-12-25 05:29:16' , 'mytime' => '22:57:17' ),
array ( 'id' => '6' , 'apple_id' => '4' , 'color' => 'My new appleOrange' , 'name' => 'My new apple' , 'created' => '2006-12-25 05:29:39' , 'date' => '2006-12-25' , 'modified' => '2006-12-25 05:29:39' , 'mytime' => '22:57:17' ),
array ( 'id' => '7' , 'apple_id' => '6' , 'color' => 'Some wierd color' , 'name' => 'Some odd color' , 'created' => '2006-12-25 05:34:21' , 'date' => '2006-12-25' , 'modified' => '2006-12-25 05:34:21' , 'mytime' => '22:57:17' )
);
$this -> assertEqual ( $Apple -> find ( 'all' ), $expected );
}
2009-07-24 19:18:37 +00:00
2008-06-02 19:22:55 +00:00
/**
* testBehaviorHasManyFindCallbacks method
2008-06-27 07:23:22 +00:00
*
2008-06-02 19:22:55 +00:00
* @ access public
* @ return void
*/
2008-05-30 11:40:08 +00:00
function testBehaviorHasManyFindCallbacks () {
$Apple = new Apple ();
$Apple -> unbindModel ( array ( 'hasOne' => array ( 'Sample' ), 'belongsTo' => array ( 'Parent' )), false );
$expected = $Apple -> find ( 'all' );
$Apple -> unbindModel ( array ( 'hasMany' => array ( 'Child' )));
$wellBehaved = $Apple -> find ( 'all' );
2008-05-31 12:36:38 +00:00
$Apple -> Child -> Behaviors -> attach ( 'Test' , array ( 'afterFind' => 'modify' ));
2008-06-27 07:23:22 +00:00
$Apple -> unbindModel ( array ( 'hasMany' => array ( 'Child' )));
2008-05-30 11:40:08 +00:00
$this -> assertIdentical ( $Apple -> find ( 'all' ), $wellBehaved );
$Apple -> Child -> Behaviors -> attach ( 'Test' , array ( 'before' => 'off' ));
$this -> assertIdentical ( $Apple -> find ( 'all' ), $expected );
$Apple -> Child -> Behaviors -> attach ( 'Test' , array ( 'before' => 'test' ));
$this -> assertIdentical ( $Apple -> find ( 'all' ), $expected );
$expected2 = array (
array (
'Apple' => array ( 'id' => 1 ),
'Child' => array (
array ( 'id' => 2 , 'name' => 'Bright Red Apple' , 'mytime' => '22:57:17' ))),
array (
'Apple' => array ( 'id' => 2 ),
'Child' => array (
array ( 'id' => 1 , 'name' => 'Red Apple 1' , 'mytime' => '22:57:17' ),
array ( 'id' => 3 , 'name' => 'green blue' , 'mytime' => '22:57:17' ),
array ( 'id' => 4 , 'name' => 'Test Name' , 'mytime' => '22:57:17' ))),
array (
'Apple' => array ( 'id' => 3 ),
'Child' => array ())
);
2008-06-27 07:23:22 +00:00
$Apple -> Child -> Behaviors -> attach ( 'Test' , array ( 'before' => 'modify' ));
$result = $Apple -> find ( 'all' , array ( 'fields' => array ( 'Apple.id' ), 'conditions' => array ( 'Apple.id <' => '4' )));
//$this->assertEqual($result, $expected2);
2008-05-30 11:40:08 +00:00
$Apple -> Child -> Behaviors -> disable ( 'Test' );
$result = $Apple -> find ( 'all' );
$this -> assertEqual ( $result , $expected );
$Apple -> Child -> Behaviors -> attach ( 'Test' , array ( 'before' => 'off' , 'after' => 'on' ));
2008-06-27 07:23:22 +00:00
//$this->assertIdentical($Apple->find('all'), array());
2008-05-30 11:40:08 +00:00
$Apple -> Child -> Behaviors -> attach ( 'Test' , array ( 'after' => 'off' ));
$this -> assertEqual ( $Apple -> find ( 'all' ), $expected );
$Apple -> Child -> Behaviors -> attach ( 'Test' , array ( 'after' => 'test' ));
$this -> assertEqual ( $Apple -> find ( 'all' ), $expected );
$Apple -> Child -> Behaviors -> attach ( 'Test' , array ( 'after' => 'test2' ));
$this -> assertEqual ( $Apple -> find ( 'all' ), $expected );
$Apple -> Child -> Behaviors -> attach ( 'Test' , array ( 'after' => 'modify' ));
$expected = array (
array ( 'id' => '1' , 'apple_id' => '2' , 'color' => 'Red 1' , 'name' => 'Red Apple 1' , 'created' => '2006-11-22 10:38:58' , 'date' => '1951-01-04' , 'modified' => '2006-12-01 13:31:26' , 'mytime' => '22:57:17' ),
array ( 'id' => '2' , 'apple_id' => '1' , 'color' => 'Bright Red 1' , 'name' => 'Bright Red Apple' , 'created' => '2006-11-22 10:43:13' , 'date' => '2014-01-01' , 'modified' => '2006-11-30 18:38:10' , 'mytime' => '22:57:17' ),
array ( 'id' => '3' , 'apple_id' => '2' , 'color' => 'blue green' , 'name' => 'green blue' , 'created' => '2006-12-25 05:13:36' , 'date' => '2006-12-25' , 'modified' => '2006-12-25 05:23:24' , 'mytime' => '22:57:17' ),
array ( 'id' => '4' , 'apple_id' => '2' , 'color' => 'Blue Green' , 'name' => 'Test Name' , 'created' => '2006-12-25 05:23:36' , 'date' => '2006-12-25' , 'modified' => '2006-12-25 05:23:36' , 'mytime' => '22:57:17' ),
array ( 'id' => '5' , 'apple_id' => '5' , 'color' => 'Green' , 'name' => 'Blue Green' , 'created' => '2006-12-25 05:24:06' , 'date' => '2006-12-25' , 'modified' => '2006-12-25 05:29:16' , 'mytime' => '22:57:17' ),
array ( 'id' => '6' , 'apple_id' => '4' , 'color' => 'My new appleOrange' , 'name' => 'My new apple' , 'created' => '2006-12-25 05:29:39' , 'date' => '2006-12-25' , 'modified' => '2006-12-25 05:29:39' , 'mytime' => '22:57:17' ),
array ( 'id' => '7' , 'apple_id' => '6' , 'color' => 'Some wierd color' , 'name' => 'Some odd color' , 'created' => '2006-12-25 05:34:21' , 'date' => '2006-12-25' , 'modified' => '2006-12-25 05:34:21' , 'mytime' => '22:57:17' )
);
2008-06-27 07:23:22 +00:00
//$this->assertEqual($Apple->find('all'), $expected);
2008-05-30 11:40:08 +00:00
}
2008-06-02 19:22:55 +00:00
/**
* testBehaviorHasOneFindCallbacks method
2008-06-27 07:23:22 +00:00
*
2008-06-02 19:22:55 +00:00
* @ access public
* @ return void
*/
2008-05-30 11:40:08 +00:00
function testBehaviorHasOneFindCallbacks () {
$Apple = new Apple ();
$Apple -> unbindModel ( array ( 'hasMany' => array ( 'Child' ), 'belongsTo' => array ( 'Parent' )), false );
$expected = $Apple -> find ( 'all' );
$Apple -> unbindModel ( array ( 'hasOne' => array ( 'Sample' )));
$wellBehaved = $Apple -> find ( 'all' );
$Apple -> Sample -> Behaviors -> attach ( 'Test' );
2008-06-27 07:23:22 +00:00
$Apple -> unbindModel ( array ( 'hasOne' => array ( 'Sample' )));
2008-05-30 11:40:08 +00:00
$this -> assertIdentical ( $Apple -> find ( 'all' ), $wellBehaved );
$Apple -> Sample -> Behaviors -> attach ( 'Test' , array ( 'before' => 'off' ));
$this -> assertIdentical ( $Apple -> find ( 'all' ), $expected );
$Apple -> Sample -> Behaviors -> attach ( 'Test' , array ( 'before' => 'test' ));
$this -> assertIdentical ( $Apple -> find ( 'all' ), $expected );
$Apple -> Sample -> Behaviors -> attach ( 'Test' , array ( 'before' => 'modify' ));
$expected2 = array (
array (
'Apple' => array ( 'id' => 1 ),
'Child' => array (
array ( 'id' => 2 , 'name' => 'Bright Red Apple' , 'mytime' => '22:57:17' ))),
array (
'Apple' => array ( 'id' => 2 ),
'Child' => array (
array ( 'id' => 1 , 'name' => 'Red Apple 1' , 'mytime' => '22:57:17' ),
array ( 'id' => 3 , 'name' => 'green blue' , 'mytime' => '22:57:17' ),
array ( 'id' => 4 , 'name' => 'Test Name' , 'mytime' => '22:57:17' ))),
array (
'Apple' => array ( 'id' => 3 ),
'Child' => array ())
);
2008-06-27 07:23:22 +00:00
$result = $Apple -> find ( 'all' , array ( 'fields' => array ( 'Apple.id' ), 'conditions' => array ( 'Apple.id <' => '4' )));
//$this->assertEqual($result, $expected2);
2008-05-30 11:40:08 +00:00
$Apple -> Sample -> Behaviors -> disable ( 'Test' );
$result = $Apple -> find ( 'all' );
$this -> assertEqual ( $result , $expected );
$Apple -> Sample -> Behaviors -> attach ( 'Test' , array ( 'before' => 'off' , 'after' => 'on' ));
2008-06-27 07:23:22 +00:00
//$this->assertIdentical($Apple->find('all'), array());
2008-05-30 11:40:08 +00:00
$Apple -> Sample -> Behaviors -> attach ( 'Test' , array ( 'after' => 'off' ));
$this -> assertEqual ( $Apple -> find ( 'all' ), $expected );
$Apple -> Sample -> Behaviors -> attach ( 'Test' , array ( 'after' => 'test' ));
$this -> assertEqual ( $Apple -> find ( 'all' ), $expected );
$Apple -> Sample -> Behaviors -> attach ( 'Test' , array ( 'after' => 'test2' ));
$this -> assertEqual ( $Apple -> find ( 'all' ), $expected );
$Apple -> Sample -> Behaviors -> attach ( 'Test' , array ( 'after' => 'modify' ));
$expected = array (
array ( 'id' => '1' , 'apple_id' => '2' , 'color' => 'Red 1' , 'name' => 'Red Apple 1' , 'created' => '2006-11-22 10:38:58' , 'date' => '1951-01-04' , 'modified' => '2006-12-01 13:31:26' , 'mytime' => '22:57:17' ),
array ( 'id' => '2' , 'apple_id' => '1' , 'color' => 'Bright Red 1' , 'name' => 'Bright Red Apple' , 'created' => '2006-11-22 10:43:13' , 'date' => '2014-01-01' , 'modified' => '2006-11-30 18:38:10' , 'mytime' => '22:57:17' ),
array ( 'id' => '3' , 'apple_id' => '2' , 'color' => 'blue green' , 'name' => 'green blue' , 'created' => '2006-12-25 05:13:36' , 'date' => '2006-12-25' , 'modified' => '2006-12-25 05:23:24' , 'mytime' => '22:57:17' ),
array ( 'id' => '4' , 'apple_id' => '2' , 'color' => 'Blue Green' , 'name' => 'Test Name' , 'created' => '2006-12-25 05:23:36' , 'date' => '2006-12-25' , 'modified' => '2006-12-25 05:23:36' , 'mytime' => '22:57:17' ),
array ( 'id' => '5' , 'apple_id' => '5' , 'color' => 'Green' , 'name' => 'Blue Green' , 'created' => '2006-12-25 05:24:06' , 'date' => '2006-12-25' , 'modified' => '2006-12-25 05:29:16' , 'mytime' => '22:57:17' ),
array ( 'id' => '6' , 'apple_id' => '4' , 'color' => 'My new appleOrange' , 'name' => 'My new apple' , 'created' => '2006-12-25 05:29:39' , 'date' => '2006-12-25' , 'modified' => '2006-12-25 05:29:39' , 'mytime' => '22:57:17' ),
array ( 'id' => '7' , 'apple_id' => '6' , 'color' => 'Some wierd color' , 'name' => 'Some odd color' , 'created' => '2006-12-25 05:34:21' , 'date' => '2006-12-25' , 'modified' => '2006-12-25 05:34:21' , 'mytime' => '22:57:17' )
);
2008-06-27 07:23:22 +00:00
//$this->assertEqual($Apple->find('all'), $expected);
2008-05-30 11:40:08 +00:00
}
2008-06-02 19:22:55 +00:00
/**
* testBehaviorBelongsToFindCallbacks method
2008-06-27 07:23:22 +00:00
*
2008-06-02 19:22:55 +00:00
* @ access public
* @ return void
*/
2008-05-30 11:40:08 +00:00
function testBehaviorBelongsToFindCallbacks () {
$Apple = new Apple ();
$Apple -> unbindModel ( array ( 'hasMany' => array ( 'Child' ), 'hasOne' => array ( 'Sample' )), false );
$expected = $Apple -> find ( 'all' );
$Apple -> unbindModel ( array ( 'belongsTo' => array ( 'Parent' )));
$wellBehaved = $Apple -> find ( 'all' );
$Apple -> Parent -> Behaviors -> attach ( 'Test' );
2008-06-27 07:23:22 +00:00
$Apple -> unbindModel ( array ( 'belongsTo' => array ( 'Parent' )));
2008-05-30 11:40:08 +00:00
$this -> assertIdentical ( $Apple -> find ( 'all' ), $wellBehaved );
$Apple -> Parent -> Behaviors -> attach ( 'Test' , array ( 'before' => 'off' ));
$this -> assertIdentical ( $Apple -> find ( 'all' ), $expected );
$Apple -> Parent -> Behaviors -> attach ( 'Test' , array ( 'before' => 'test' ));
$this -> assertIdentical ( $Apple -> find ( 'all' ), $expected );
$Apple -> Parent -> Behaviors -> attach ( 'Test' , array ( 'before' => 'modify' ));
$expected2 = array (
array (
'Apple' => array ( 'id' => 1 ),
'Parent' => array ( 'id' => 2 , 'name' => 'Bright Red Apple' , 'mytime' => '22:57:17' )),
array (
'Apple' => array ( 'id' => 2 ),
'Parent' => array ( 'id' => 1 , 'name' => 'Red Apple 1' , 'mytime' => '22:57:17' )),
array (
'Apple' => array ( 'id' => 3 ),
'Parent' => array ( 'id' => 2 , 'name' => 'Bright Red Apple' , 'mytime' => '22:57:17' ))
);
2010-03-08 00:02:19 +00:00
$result = $Apple -> find ( 'all' , array (
'fields' => array ( 'Apple.id' , 'Parent.id' , 'Parent.name' , 'Parent.mytime' ),
'conditions' => array ( 'Apple.id <' => '4' )
));
$this -> assertEqual ( $result , $expected2 );
2008-05-30 11:40:08 +00:00
$Apple -> Parent -> Behaviors -> disable ( 'Test' );
$result = $Apple -> find ( 'all' );
$this -> assertEqual ( $result , $expected );
$Apple -> Parent -> Behaviors -> attach ( 'Test' , array ( 'after' => 'off' ));
$this -> assertEqual ( $Apple -> find ( 'all' ), $expected );
$Apple -> Parent -> Behaviors -> attach ( 'Test' , array ( 'after' => 'test' ));
$this -> assertEqual ( $Apple -> find ( 'all' ), $expected );
$Apple -> Parent -> Behaviors -> attach ( 'Test' , array ( 'after' => 'test2' ));
$this -> assertEqual ( $Apple -> find ( 'all' ), $expected );
$Apple -> Parent -> Behaviors -> attach ( 'Test' , array ( 'after' => 'modify' ));
$expected = array (
array ( 'id' => '1' , 'apple_id' => '2' , 'color' => 'Red 1' , 'name' => 'Red Apple 1' , 'created' => '2006-11-22 10:38:58' , 'date' => '1951-01-04' , 'modified' => '2006-12-01 13:31:26' , 'mytime' => '22:57:17' ),
array ( 'id' => '2' , 'apple_id' => '1' , 'color' => 'Bright Red 1' , 'name' => 'Bright Red Apple' , 'created' => '2006-11-22 10:43:13' , 'date' => '2014-01-01' , 'modified' => '2006-11-30 18:38:10' , 'mytime' => '22:57:17' ),
array ( 'id' => '3' , 'apple_id' => '2' , 'color' => 'blue green' , 'name' => 'green blue' , 'created' => '2006-12-25 05:13:36' , 'date' => '2006-12-25' , 'modified' => '2006-12-25 05:23:24' , 'mytime' => '22:57:17' ),
array ( 'id' => '4' , 'apple_id' => '2' , 'color' => 'Blue Green' , 'name' => 'Test Name' , 'created' => '2006-12-25 05:23:36' , 'date' => '2006-12-25' , 'modified' => '2006-12-25 05:23:36' , 'mytime' => '22:57:17' ),
array ( 'id' => '5' , 'apple_id' => '5' , 'color' => 'Green' , 'name' => 'Blue Green' , 'created' => '2006-12-25 05:24:06' , 'date' => '2006-12-25' , 'modified' => '2006-12-25 05:29:16' , 'mytime' => '22:57:17' ),
array ( 'id' => '6' , 'apple_id' => '4' , 'color' => 'My new appleOrange' , 'name' => 'My new apple' , 'created' => '2006-12-25 05:29:39' , 'date' => '2006-12-25' , 'modified' => '2006-12-25 05:29:39' , 'mytime' => '22:57:17' ),
array ( 'id' => '7' , 'apple_id' => '6' , 'color' => 'Some wierd color' , 'name' => 'Some odd color' , 'created' => '2006-12-25 05:34:21' , 'date' => '2006-12-25' , 'modified' => '2006-12-25 05:34:21' , 'mytime' => '22:57:17' )
);
2008-06-27 07:23:22 +00:00
//$this->assertEqual($Apple->find('all'), $expected);
2008-05-30 11:40:08 +00:00
}
2009-07-24 19:18:37 +00:00
2008-06-02 19:22:55 +00:00
/**
* testBehaviorSaveCallbacks method
2008-06-27 07:23:22 +00:00
*
2008-06-02 19:22:55 +00:00
* @ access public
* @ return void
*/
2008-05-30 11:40:08 +00:00
function testBehaviorSaveCallbacks () {
$Sample = new Sample ();
$record = array ( 'Sample' => array ( 'apple_id' => 6 , 'name' => 'sample99' ));
$Sample -> Behaviors -> attach ( 'Test' , array ( 'beforeSave' => 'on' ));
$Sample -> create ();
$this -> assertIdentical ( $Sample -> save ( $record ), false );
$Sample -> Behaviors -> attach ( 'Test' , array ( 'beforeSave' => 'off' ));
$Sample -> create ();
$this -> assertIdentical ( $Sample -> save ( $record ), $record );
$Sample -> Behaviors -> attach ( 'Test' , array ( 'beforeSave' => 'test' ));
$Sample -> create ();
$this -> assertIdentical ( $Sample -> save ( $record ), $record );
$Sample -> Behaviors -> attach ( 'Test' , array ( 'beforeSave' => 'modify' ));
$expected = Set :: insert ( $record , 'Sample.name' , 'sample99 modified before' );
$Sample -> create ();
$this -> assertIdentical ( $Sample -> save ( $record ), $expected );
2008-06-27 07:23:22 +00:00
2008-05-30 11:40:08 +00:00
$Sample -> Behaviors -> disable ( 'Test' );
$this -> assertIdentical ( $Sample -> save ( $record ), $record );
$Sample -> Behaviors -> attach ( 'Test' , array ( 'beforeSave' => 'off' , 'afterSave' => 'on' ));
$expected = Set :: merge ( $record , array ( 'Sample' => array ( 'aftersave' => 'modified after on create' )));
$Sample -> create ();
$this -> assertIdentical ( $Sample -> save ( $record ), $expected );
$Sample -> Behaviors -> attach ( 'Test' , array ( 'beforeSave' => 'modify' , 'afterSave' => 'modify' ));
$expected = Set :: merge ( $record , array ( 'Sample' => array ( 'name' => 'sample99 modified before modified after on create' )));
$Sample -> create ();
$this -> assertIdentical ( $Sample -> save ( $record ), $expected );
$Sample -> Behaviors -> attach ( 'Test' , array ( 'beforeSave' => 'off' , 'afterSave' => 'test' ));
$Sample -> create ();
$this -> assertIdentical ( $Sample -> save ( $record ), $record );
2008-06-27 07:23:22 +00:00
2008-05-30 11:40:08 +00:00
$Sample -> Behaviors -> attach ( 'Test' , array ( 'afterSave' => 'test2' ));
$Sample -> create ();
$this -> assertIdentical ( $Sample -> save ( $record ), $record );
2008-06-27 07:23:22 +00:00
2008-05-30 11:40:08 +00:00
$Sample -> Behaviors -> attach ( 'Test' , array ( 'beforeFind' => 'off' , 'afterFind' => 'off' ));
$Sample -> recursive = - 1 ;
$record2 = $Sample -> read ( null , 1 );
$Sample -> Behaviors -> attach ( 'Test' , array ( 'afterSave' => 'on' ));
$expected = Set :: merge ( $record2 , array ( 'Sample' => array ( 'aftersave' => 'modified after' )));
$Sample -> create ();
$this -> assertIdentical ( $Sample -> save ( $record2 ), $expected );
$Sample -> Behaviors -> attach ( 'Test' , array ( 'afterSave' => 'modify' ));
$expected = Set :: merge ( $record2 , array ( 'Sample' => array ( 'name' => 'sample1 modified after' )));
$Sample -> create ();
$this -> assertIdentical ( $Sample -> save ( $record2 ), $expected );
}
2009-07-24 19:18:37 +00:00
2008-06-05 15:20:45 +00:00
/**
* testBehaviorDeleteCallbacks method
2008-06-27 07:23:22 +00:00
*
2008-06-05 15:20:45 +00:00
* @ access public
* @ return void
*/
2008-05-30 11:40:08 +00:00
function testBehaviorDeleteCallbacks () {
$Apple = new Apple ();
$Apple -> Behaviors -> attach ( 'Test' , array ( 'beforeFind' => 'off' , 'beforeDelete' => 'off' ));
2009-05-01 21:05:46 +00:00
$this -> assertIdentical ( $Apple -> delete ( 6 ), true );
2008-05-30 11:40:08 +00:00
$Apple -> Behaviors -> attach ( 'Test' , array ( 'beforeDelete' => 'on' ));
$this -> assertIdentical ( $Apple -> delete ( 4 ), false );
$Apple -> Behaviors -> attach ( 'Test' , array ( 'beforeDelete' => 'test2' ));
2010-09-19 22:55:14 +00:00
ob_start ();
$results = $Apple -> delete ( 4 );
$this -> assertIdentical ( trim ( ob_get_clean ()), 'beforeDelete success (cascading)' );
$this -> assertIdentical ( $results , true );
ob_start ();
$results = $Apple -> delete ( 3 , false );
$this -> assertIdentical ( trim ( ob_get_clean ()), 'beforeDelete success' );
$this -> assertIdentical ( $results , true );
2008-05-30 11:40:08 +00:00
$Apple -> Behaviors -> attach ( 'Test' , array ( 'beforeDelete' => 'off' , 'afterDelete' => 'on' ));
2010-09-19 22:55:14 +00:00
ob_start ();
$results = $Apple -> delete ( 2 , false );
$this -> assertIdentical ( trim ( ob_get_clean ()), 'afterDelete success' );
$this -> assertIdentical ( $results , true );
2008-05-30 11:40:08 +00:00
}
2010-12-12 22:41:57 +00:00
/**
2008-06-05 15:20:45 +00:00
* testBehaviorOnErrorCallback method
2008-06-27 07:23:22 +00:00
*
2008-06-05 15:20:45 +00:00
* @ access public
* @ return void
*/
2008-05-30 11:40:08 +00:00
function testBehaviorOnErrorCallback () {
$Apple = new Apple ();
2008-06-27 07:23:22 +00:00
2008-05-30 11:40:08 +00:00
$Apple -> Behaviors -> attach ( 'Test' , array ( 'beforeFind' => 'off' , 'onError' => 'on' ));
2010-09-19 22:55:14 +00:00
ob_start ();
2010-12-12 22:41:57 +00:00
$Apple -> Behaviors -> Test -> onError ( $Apple , '' );
2010-09-19 22:55:14 +00:00
$this -> assertIdentical ( trim ( ob_get_clean ()), 'onError trigger success' );
2008-05-30 11:40:08 +00:00
}
2010-12-12 22:41:57 +00:00
/**
2008-06-05 15:20:45 +00:00
* testBehaviorValidateCallback method
2008-06-27 07:23:22 +00:00
*
2008-06-05 15:20:45 +00:00
* @ access public
* @ return void
*/
2008-05-30 11:40:08 +00:00
function testBehaviorValidateCallback () {
$Apple = new Apple ();
$Apple -> Behaviors -> attach ( 'Test' );
$this -> assertIdentical ( $Apple -> validates (), true );
$Apple -> Behaviors -> attach ( 'Test' , array ( 'validate' => 'on' ));
$this -> assertIdentical ( $Apple -> validates (), false );
2011-04-21 23:31:15 +00:00
$this -> assertIdentical ( $Apple -> validationErrors , array ( 'name' => array ( true )));
2008-06-27 07:23:22 +00:00
2008-05-30 11:40:08 +00:00
$Apple -> Behaviors -> attach ( 'Test' , array ( 'validate' => 'stop' ));
$this -> assertIdentical ( $Apple -> validates (), false );
2011-04-21 23:31:15 +00:00
$this -> assertIdentical ( $Apple -> validationErrors , array ( 'name' => array ( true , true )));
2008-05-30 11:40:08 +00:00
$Apple -> Behaviors -> attach ( 'Test' , array ( 'validate' => 'whitelist' ));
$Apple -> validates ();
$this -> assertIdentical ( $Apple -> whitelist , array ());
2008-06-27 07:23:22 +00:00
2008-05-30 11:40:08 +00:00
$Apple -> whitelist = array ( 'unknown' );
$Apple -> validates ();
$this -> assertIdentical ( $Apple -> whitelist , array ( 'unknown' , 'name' ));
}
2009-07-24 19:18:37 +00:00
2008-06-05 15:20:45 +00:00
/**
* testBehaviorValidateMethods method
2008-06-27 07:23:22 +00:00
*
2008-06-05 15:20:45 +00:00
* @ access public
* @ return void
*/
2008-05-30 11:40:08 +00:00
function testBehaviorValidateMethods () {
$Apple = new Apple ();
$Apple -> Behaviors -> attach ( 'Test' );
$Apple -> validate [ 'color' ] = 'validateField' ;
$result = $Apple -> save ( array ( 'name' => 'Genetically Modified Apple' , 'color' => 'Orange' ));
$this -> assertEqual ( array_keys ( $result [ 'Apple' ]), array ( 'name' , 'color' , 'modified' , 'created' ));
$Apple -> create ();
$result = $Apple -> save ( array ( 'name' => 'Regular Apple' , 'color' => 'Red' ));
$this -> assertFalse ( $result );
}
2009-07-24 19:18:37 +00:00
2008-06-05 15:20:45 +00:00
/**
* testBehaviorMethodDispatching method
2008-06-27 07:23:22 +00:00
*
2008-06-05 15:20:45 +00:00
* @ access public
* @ return void
*/
2008-05-30 11:40:08 +00:00
function testBehaviorMethodDispatching () {
$Apple = new Apple ();
$Apple -> Behaviors -> attach ( 'Test' );
$expected = 'working' ;
$this -> assertEqual ( $Apple -> testMethod (), $expected );
$this -> assertEqual ( $Apple -> Behaviors -> dispatchMethod ( $Apple , 'testMethod' ), $expected );
$result = $Apple -> Behaviors -> dispatchMethod ( $Apple , 'wtf' );
$this -> assertEqual ( $result , array ( 'unhandled' ));
$result = $Apple -> { 'look for the remote' }( 'in the couch' );
$expected = " Item.name = 'the remote' AND Location.name = 'the couch' " ;
$this -> assertEqual ( $result , $expected );
2010-09-06 17:38:01 +00:00
$result = $Apple -> { 'look for THE REMOTE' }( 'in the couch' );
$expected = " Item.name = 'THE REMOTE' AND Location.name = 'the couch' " ;
$this -> assertEqual ( $result , $expected , 'Mapped method was lowercased.' );
2008-05-30 11:40:08 +00:00
}
2009-07-24 19:18:37 +00:00
2008-06-05 15:20:45 +00:00
/**
* testBehaviorMethodDispatchingWithData method
2008-06-27 07:23:22 +00:00
*
2008-06-05 15:20:45 +00:00
* @ access public
* @ return void
*/
2008-05-30 11:40:08 +00:00
function testBehaviorMethodDispatchingWithData () {
$Apple = new Apple ();
$Apple -> Behaviors -> attach ( 'Test' );
$Apple -> set ( 'field' , 'value' );
$this -> assertTrue ( $Apple -> testData ());
$this -> assertTrue ( $Apple -> data [ 'Apple' ][ 'field_2' ]);
2009-09-28 22:11:04 +00:00
$this -> assertTrue ( $Apple -> testData ( 'one' , 'two' , 'three' , 'four' , 'five' , 'six' ));
2008-05-30 11:40:08 +00:00
}
2009-07-24 19:18:37 +00:00
2009-07-06 22:38:37 +00:00
/**
* undocumented function
*
* @ return void
*/
2010-04-05 03:19:38 +00:00
public function testBindModelCallsInBehaviors () {
2009-07-06 22:38:37 +00:00
$this -> loadFixtures ( 'Article' , 'Comment' );
// hasMany
$Article = new Article ();
$Article -> unbindModel ( array ( 'hasMany' => array ( 'Comment' )));
$result = $Article -> find ( 'first' );
$this -> assertFalse ( array_key_exists ( 'Comment' , $result ));
$Article -> Behaviors -> attach ( 'Test4' );
$result = $Article -> find ( 'first' );
$this -> assertTrue ( array_key_exists ( 'Comment' , $result ));
// belongsTo
$Article -> unbindModel ( array ( 'belongsTo' => array ( 'User' )));
$result = $Article -> find ( 'first' );
$this -> assertFalse ( array_key_exists ( 'User' , $result ));
$Article -> Behaviors -> attach ( 'Test5' );
$result = $Article -> find ( 'first' );
$this -> assertTrue ( array_key_exists ( 'User' , $result ));
// hasAndBelongsToMany
$Article -> unbindModel ( array ( 'hasAndBelongsToMany' => array ( 'Tag' )));
$result = $Article -> find ( 'first' );
$this -> assertFalse ( array_key_exists ( 'Tag' , $result ));
$Article -> Behaviors -> attach ( 'Test6' );
$result = $Article -> find ( 'first' );
$this -> assertTrue ( array_key_exists ( 'Comment' , $result ));
// hasOne
$Comment = new Comment ();
$Comment -> unbindModel ( array ( 'hasOne' => array ( 'Attachment' )));
$result = $Comment -> find ( 'first' );
$this -> assertFalse ( array_key_exists ( 'Attachment' , $result ));
$Comment -> Behaviors -> attach ( 'Test7' );
$result = $Comment -> find ( 'first' );
$this -> assertTrue ( array_key_exists ( 'Attachment' , $result ));
}
2009-07-24 19:18:37 +00:00
2008-11-11 00:17:37 +00:00
/**
* Test attach and detaching
*
2009-03-19 21:10:13 +00:00
* @ access public
2008-11-11 00:17:37 +00:00
* @ return void
2009-11-14 12:19:25 +00:00
*/
2008-11-11 00:17:37 +00:00
function testBehaviorAttachAndDetach () {
2010-06-05 03:57:28 +00:00
$Sample = new Sample ();
2008-11-11 00:17:37 +00:00
$Sample -> actsAs = array ( 'Test3' => array ( 'bar' ), 'Test2' => array ( 'foo' , 'bar' ));
$Sample -> Behaviors -> init ( $Sample -> alias , $Sample -> actsAs );
$Sample -> Behaviors -> attach ( 'Test2' );
$Sample -> Behaviors -> detach ( 'Test3' );
2009-03-19 21:10:13 +00:00
2010-12-12 22:41:57 +00:00
$Sample -> Behaviors -> trigger ( 'beforeTest' , array ( & $Sample ));
2008-11-11 00:17:37 +00:00
}
2010-12-26 19:25:57 +00:00
/**
* test that hasMethod works with basic functions .
*
* @ return void
*/
function testHasMethodBasic () {
$Sample = new Sample ();
$Collection = new BehaviorCollection ();
$Collection -> init ( 'Sample' , array ( 'Test' , 'Test2' ));
2011-04-17 10:35:21 +00:00
2010-12-26 19:25:57 +00:00
$this -> assertTrue ( $Collection -> hasMethod ( 'testMethod' ));
$this -> assertTrue ( $Collection -> hasMethod ( 'resolveMethod' ));
$this -> assertFalse ( $Collection -> hasMethod ( 'No method' ));
}
/**
* test that hasMethod works with mapped methods .
*
* @ return void
*/
function testHasMethodMappedMethods () {
$Sample = new Sample ();
$Collection = new BehaviorCollection ();
$Collection -> init ( 'Sample' , array ( 'Test' , 'Test2' ));
2010-12-26 22:09:20 +00:00
2010-12-26 19:25:57 +00:00
$this -> assertTrue ( $Collection -> hasMethod ( 'look for the remote in the couch' ));
$this -> assertTrue ( $Collection -> hasMethod ( 'mappingRobotOnTheRoof' ));
}
2010-12-26 22:09:20 +00:00
/**
* test hasMethod returrning a 'callback'
*
* @ return void
*/
function testHasMethodAsCallback () {
$Sample = new Sample ();
$Collection = new BehaviorCollection ();
$Collection -> init ( 'Sample' , array ( 'Test' , 'Test2' ));
$result = $Collection -> hasMethod ( 'testMethod' , true );
$expected = array ( 'Test' , 'testMethod' );
$this -> assertEquals ( $expected , $result );
$result = $Collection -> hasMethod ( 'resolveMethod' , true );
$expected = array ( 'Test2' , 'resolveMethod' );
$this -> assertEquals ( $expected , $result );
$result = $Collection -> hasMethod ( 'mappingRobotOnTheRoof' , true );
$expected = array ( 'Test2' , 'mapped' , 'mappingRobotOnTheRoof' );
$this -> assertEquals ( $expected , $result );
}
2008-05-30 11:40:08 +00:00
}