Subversion Repositories SmartDukaan

<?php

/**

 * ConfigureTest file

 *

 * Holds several tests

 *

 * 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.Core

 * @since         CakePHP(tm) v 1.2.0.5432

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

 */

App::uses('PhpReader', 'Configure');

/**

 * ConfigureTest

 *

 * @package       Cake.Test.Case.Core

 */

class ConfigureTest extends CakeTestCase {

/**

 * setUp method

 *

 * @return void

 */

	public function setUp() {

		parent::setUp();

		Configure::write('Cache.disable', true);

		App::build();

		App::objects('plugin', null, true);

	}

/**

 * tearDown method

 *

 * @return void

 */

	public function tearDown() {

		parent::tearDown();

		if (file_exists(TMP . 'cache' . DS . 'persistent' . DS . 'cake_core_core_paths')) {

			unlink(TMP . 'cache' . DS . 'persistent' . DS . 'cake_core_core_paths');

		}

		if (file_exists(TMP . 'cache' . DS . 'persistent' . DS . 'cake_core_dir_map')) {

			unlink(TMP . 'cache' . DS . 'persistent' . DS . 'cake_core_dir_map');

		}

		if (file_exists(TMP . 'cache' . DS . 'persistent' . DS . 'cake_core_file_map')) {

			unlink(TMP . 'cache' . DS . 'persistent' . DS . 'cake_core_file_map');

		}

		if (file_exists(TMP . 'cache' . DS . 'persistent' . DS . 'cake_core_object_map')) {

			unlink(TMP . 'cache' . DS . 'persistent' . DS . 'cake_core_object_map');

		}

		if (file_exists(TMP . 'cache' . DS . 'persistent' . DS . 'test.config.php')) {

			unlink(TMP . 'cache' . DS . 'persistent' . DS . 'test.config.php');

		}

		if (file_exists(TMP . 'cache' . DS . 'persistent' . DS . 'test.php')) {

			unlink(TMP . 'cache' . DS . 'persistent' . DS . 'test.php');

		}

		Configure::drop('test');

	}

/**

 * Test to ensure bootrapping doesn't overwrite prior configs set under 'App' key

 * @return void

 */

	public function testBootstrap() {

		$expected = array(

			'foo' => 'bar'

		);

		Configure::write('App', $expected);

		Configure::bootstrap(true);

		$result = Configure::read('App');

		$this->assertEquals($expected['foo'], $result['foo']);

		$this->assertFalse($result['base']);

	}

/**

 * testRead method

 *

 * @return void

 */

	public function testRead() {

		$expected = 'ok';

		Configure::write('level1.level2.level3_1', $expected);

		Configure::write('level1.level2.level3_2', 'something_else');

		$result = Configure::read('level1.level2.level3_1');

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

		$result = Configure::read('level1.level2.level3_2');

		$this->assertEquals('something_else', $result);

		$result = Configure::read('debug');

		$this->assertTrue($result >= 0);

		$result = Configure::read();

		$this->assertTrue(is_array($result));

		$this->assertTrue(isset($result['debug']));

		$this->assertTrue(isset($result['level1']));

		$result = Configure::read('something_I_just_made_up_now');

		$this->assertEquals(null, $result, 'Missing key should return null.');

	}

/**

 * testWrite method

 *

 * @return void

 */

	public function testWrite() {

		$writeResult = Configure::write('SomeName.someKey', 'myvalue');

		$this->assertTrue($writeResult);

		$result = Configure::read('SomeName.someKey');

		$this->assertEquals('myvalue', $result);

		$writeResult = Configure::write('SomeName.someKey', null);

		$this->assertTrue($writeResult);

		$result = Configure::read('SomeName.someKey');

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

		$expected = array('One' => array('Two' => array('Three' => array('Four' => array('Five' => 'cool')))));

		$writeResult = Configure::write('Key', $expected);

		$this->assertTrue($writeResult);

		$result = Configure::read('Key');

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

		$result = Configure::read('Key.One');

		$this->assertEquals($expected['One'], $result);

		$result = Configure::read('Key.One.Two');

		$this->assertEquals($expected['One']['Two'], $result);

		$result = Configure::read('Key.One.Two.Three.Four.Five');

		$this->assertEquals('cool', $result);

		Configure::write('one.two.three.four', '4');

		$result = Configure::read('one.two.three.four');

		$this->assertEquals('4', $result);

	}

/**

 * Test the consume method.

 *

 * @return void

 */

	public function testConsume() {

		$this->assertNull(Configure::consume('DoesNotExist'), 'Should be null on empty value');

		Configure::write('Test', array('key' => 'value', 'key2' => 'value2'));

		$result = Configure::consume('Test.key');

		$this->assertEquals('value', $result);

		$result = Configure::read('Test.key2');

		$this->assertEquals('value2', $result, 'Other values should remain.');

		$result = Configure::consume('Test');

		$expected = array('key2' => 'value2');

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

	}

/**

 * testConsumeEmpty

 *

 * @return void

 */

	public function testConsumeEmpty() {

		Configure::write('Test', array('key' => 'value', 'key2' => 'value2'));

		$result = Configure::consume('');

		$this->assertNull($result);

		$result = Configure::consume(null);

		$this->assertNull($result);

	}

/**

 * test setting display_errors with debug.

 *

 * @return void

 */

	public function testDebugSettingDisplayErrors() {

		Configure::write('debug', 0);

		$result = ini_get('display_errors');

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

		Configure::write('debug', 2);

		$result = ini_get('display_errors');

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

	}

/**

 * testDelete method

 *

 * @return void

 */

	public function testDelete() {

		Configure::write('SomeName.someKey', 'myvalue');

		$result = Configure::read('SomeName.someKey');

		$this->assertEquals('myvalue', $result);

		Configure::delete('SomeName.someKey');

		$result = Configure::read('SomeName.someKey');

		$this->assertNull($result);

		Configure::write('SomeName', array('someKey' => 'myvalue', 'otherKey' => 'otherValue'));

		$result = Configure::read('SomeName.someKey');

		$this->assertEquals('myvalue', $result);

		$result = Configure::read('SomeName.otherKey');

		$this->assertEquals('otherValue', $result);

		Configure::delete('SomeName');

		$result = Configure::read('SomeName.someKey');

		$this->assertNull($result);

		$result = Configure::read('SomeName.otherKey');

		$this->assertNull($result);

	}

/**

 * testCheck method

 *

 * @return void

 */

	public function testCheck() {

		Configure::write('ConfigureTestCase', 'value');

		$this->assertTrue(Configure::check('ConfigureTestCase'));

		$this->assertFalse(Configure::check('NotExistingConfigureTestCase'));

	}

/**

 * testCheckingSavedEmpty method

 *

 * @return void

 */

	public function testCheckingSavedEmpty() {

		$this->assertTrue(Configure::write('ConfigureTestCase', 0));

		$this->assertTrue(Configure::check('ConfigureTestCase'));

		$this->assertTrue(Configure::write('ConfigureTestCase', '0'));

		$this->assertTrue(Configure::check('ConfigureTestCase'));

		$this->assertTrue(Configure::write('ConfigureTestCase', false));

		$this->assertTrue(Configure::check('ConfigureTestCase'));

		$this->assertTrue(Configure::write('ConfigureTestCase', null));

		$this->assertFalse(Configure::check('ConfigureTestCase'));

	}

/**

 * testCheckKeyWithSpaces method

 *

 * @return void

 */

	public function testCheckKeyWithSpaces() {

		$this->assertTrue(Configure::write('Configure Test', "test"));

		$this->assertTrue(Configure::check('Configure Test'));

		Configure::delete('Configure Test');

		$this->assertTrue(Configure::write('Configure Test.Test Case', "test"));

		$this->assertTrue(Configure::check('Configure Test.Test Case'));

	}

/**

 * testCheckEmpty

 *

 * @return void

 */

	public function testCheckEmpty() {

		$this->assertFalse(Configure::check(''));

		$this->assertFalse(Configure::check(null));

	}

/**

 * testLoad method

 *

 * @expectedException RuntimeException

 * @return void

 */

	public function testLoadExceptionOnNonExistantFile() {

		Configure::config('test', new PhpReader());

		Configure::load('non_existing_configuration_file', 'test');

	}

/**

 * test load method for default config creation

 *

 * @return void

 */

	public function testLoadDefaultConfig() {

		try {

			Configure::load('non_existing_configuration_file');

		} catch (Exception $e) {

			$result = Configure::configured('default');

			$this->assertTrue($result);

		}

	}

/**

 * test load with merging

 *

 * @return void

 */

	public function testLoadWithMerge() {

		Configure::config('test', new PhpReader(CAKE . 'Test' . DS . 'test_app' . DS . 'Config' . DS));

		$result = Configure::load('var_test', 'test');

		$this->assertTrue($result);

		$this->assertEquals('value', Configure::read('Read'));

		$result = Configure::load('var_test2', 'test', true);

		$this->assertTrue($result);

		$this->assertEquals('value2', Configure::read('Read'));

		$this->assertEquals('buried2', Configure::read('Deep.Second.SecondDeepest'));

		$this->assertEquals('buried', Configure::read('Deep.Deeper.Deepest'));

		$this->assertEquals('Overwrite', Configure::read('TestAcl.classname'));

		$this->assertEquals('one', Configure::read('TestAcl.custom'));

	}

/**

 * test loading with overwrite

 *

 * @return void

 */

	public function testLoadNoMerge() {

		Configure::config('test', new PhpReader(CAKE . 'Test' . DS . 'test_app' . DS . 'Config' . DS));

		$result = Configure::load('var_test', 'test');

		$this->assertTrue($result);

		$this->assertEquals('value', Configure::read('Read'));

		$result = Configure::load('var_test2', 'test', false);

		$this->assertTrue($result);

		$this->assertEquals('value2', Configure::read('Read'));

		$this->assertEquals('buried2', Configure::read('Deep.Second.SecondDeepest'));

		$this->assertNull(Configure::read('Deep.Deeper.Deepest'));

	}

/**

 * testLoad method

 *

 * @return void

 */

	public function testLoadPlugin() {

		App::build(array(

			'Plugin' => array(CAKE . 'Test' . DS . 'test_app' . DS . 'Plugin' . DS)

		), App::RESET);

		Configure::config('test', new PhpReader());

		CakePlugin::load('TestPlugin');

		$result = Configure::load('TestPlugin.load', 'test');

		$this->assertTrue($result);

		$expected = '/test_app/plugins/test_plugin/config/load.php';

		$config = Configure::read('plugin_load');

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

		$result = Configure::load('TestPlugin.more.load', 'test');

		$this->assertTrue($result);

		$expected = '/test_app/plugins/test_plugin/config/more.load.php';

		$config = Configure::read('plugin_more_load');

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

		CakePlugin::unload();

	}

/**

 * testStore method

 *

 * @return void

 */

	public function testStoreAndRestore() {

		Configure::write('Cache.disable', false);

		Configure::write('Testing', 'yummy');

		$this->assertTrue(Configure::store('store_test', 'default'));

		Configure::delete('Testing');

		$this->assertNull(Configure::read('Testing'));

		Configure::restore('store_test', 'default');

		$this->assertEquals('yummy', Configure::read('Testing'));

		Cache::delete('store_test', 'default');

	}

/**

 * test that store and restore only store/restore the provided data.

 *

 * @return void

 */

	public function testStoreAndRestoreWithData() {

		Configure::write('Cache.disable', false);

		Configure::write('testing', 'value');

		Configure::store('store_test', 'default', array('store_test' => 'one'));

		Configure::delete('testing');

		$this->assertNull(Configure::read('store_test'), 'Calling store with data shouldn\'t modify runtime.');

		Configure::restore('store_test', 'default');

		$this->assertEquals('one', Configure::read('store_test'));

		$this->assertNull(Configure::read('testing'), 'Values that were not stored are not restored.');

		Cache::delete('store_test', 'default');

	}

/**

 * testVersion method

 *

 * @return void

 */

	public function testVersion() {

		$result = Configure::version();

		$this->assertTrue(version_compare($result, '1.2', '>='));

	}

/**

 * test adding new readers.

 *

 * @return void

 */

	public function testReaderSetup() {

		$reader = new PhpReader();

		Configure::config('test', $reader);

		$configured = Configure::configured();

		$this->assertTrue(in_array('test', $configured));

		$this->assertTrue(Configure::configured('test'));

		$this->assertFalse(Configure::configured('fake_garbage'));

		$this->assertTrue(Configure::drop('test'));

		$this->assertFalse(Configure::drop('test'), 'dropping things that do not exist should return false.');

	}

/**

 * test reader() throwing exceptions on missing interface.

 *

 * @expectedException PHPUnit_Framework_Error

 * @return void

 */

	public function testReaderExceptionOnIncorrectClass() {

		$reader = new StdClass();

		Configure::config('test', $reader);

	}

/**

 * Test that clear wipes all values.

 *

 * @return void

 */

	public function testClear() {

		Configure::write('test', 'value');

		$this->assertTrue(Configure::clear());

		$this->assertNull(Configure::read('debug'));

		$this->assertNull(Configure::read('test'));

	}

/**

 * @expectedException ConfigureException

 * @return void

 */

	public function testDumpNoAdapter() {

		Configure::dump(TMP . 'test.php', 'does_not_exist');

	}

/**

 * test dump integrated with the PhpReader.

 *

 * @return void

 */

	public function testDump() {

		Configure::config('test_reader', new PhpReader(TMP));

		$result = Configure::dump('config_test.php', 'test_reader');

		$this->assertTrue($result > 0);

		$result = file_get_contents(TMP . 'config_test.php');

		$this->assertContains('<?php', $result);

		$this->assertContains('$config = ', $result);

		if (file_exists(TMP . 'config_test.php')) {

			unlink(TMP . 'config_test.php');

		}

	}

/**

 * Test dumping only some of the data.

 *

 * @return void

 */

	public function testDumpPartial() {

		Configure::config('test_reader', new PhpReader(TMP));

		$result = Configure::dump('config_test.php', 'test_reader', array('Error'));

		$this->assertTrue($result > 0);

		$result = file_get_contents(TMP . 'config_test.php');

		$this->assertContains('<?php', $result);

		$this->assertContains('$config = ', $result);

		$this->assertContains('Error', $result);

		$this->assertNotContains('debug', $result);

		if (file_exists(TMP . 'config_test.php')) {

			unlink(TMP . 'config_test.php');

		}

	}

}