Subversion Repositories SmartDukaan

<?php
/**
 * CakeTestCaseTest file
 *
 * Test Case for CakeTestCase class
 *
 * 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.TestSuite
 * @since         CakePHP v 1.2.0.4487
 * @license       http://www.opensource.org/licenses/mit-license.php MIT License
 */

App::uses('Controller', 'Controller');
App::uses('CakeHtmlReporter', 'TestSuite/Reporter');

/**
 * CakeTestCaseTest
 *
 * @package       Cake.Test.Case.TestSuite
 */
class CakeTestCaseTest extends CakeTestCase {

/**
 * fixtures property
 *
 * @var array
 */
        public $fixtures = array('core.post', 'core.author', 'core.test_plugin_comment');

/**
 * CakeTestCaseTest::setUpBeforeClass()
 *
 * @return void
 */
        public static function setUpBeforeClass() {
                require_once CAKE . 'Test' . DS . 'Fixture' . DS . 'AssertTagsTestCase.php';
                require_once CAKE . 'Test' . DS . 'Fixture' . DS . 'FixturizedTestCase.php';
        }

/**
 * setUp
 *
 * @return void
 */
        public function setUp() {
                parent::setUp();
                $this->Reporter = $this->getMock('CakeHtmlReporter');
        }

/**
 * tearDown
 *
 * @return void
 */
        public function tearDown() {
                parent::tearDown();
                unset($this->Result);
                unset($this->Reporter);
        }

/**
 * testAssertTags
 *
 * @return void
 */
        public function testAssertTagsBasic() {
                $test = new AssertTagsTestCase('testAssertTagsQuotes');
                $result = $test->run();
                $this->assertEquals(0, $result->errorCount());
                $this->assertTrue($result->wasSuccessful());
                $this->assertEquals(0, $result->failureCount());
        }

/**
 * test assertTags works with single and double quotes
 *
 * @return void
 */
        public function testAssertTagsQuoting() {
                $input = '<a href="/test.html" class="active">My link</a>';
                $pattern = array(
                        'a' => array('href' => '/test.html', 'class' => 'active'),
                        'My link',
                        '/a'
                );
                $this->assertTags($input, $pattern);

                $input = "<a href='/test.html' class='active'>My link</a>";
                $pattern = array(
                        'a' => array('href' => '/test.html', 'class' => 'active'),
                        'My link',
                        '/a'
                );
                $this->assertTags($input, $pattern);

                $input = "<a href='/test.html' class='active'>My link</a>";
                $pattern = array(
                        'a' => array('href' => 'preg:/.*\.html/', 'class' => 'active'),
                        'My link',
                        '/a'
                );
                $this->assertTags($input, $pattern);

                $input = "<span><strong>Text</strong></span>";
                $pattern = array(
                        '<span',
                        '<strong',
                        'Text',
                        '/strong',
                        '/span'
                );
                $this->assertTags($input, $pattern);

                $input = "<span class='active'><strong>Text</strong></span>";
                $pattern = array(
                        'span' => array('class'),
                        '<strong',
                        'Text',
                        '/strong',
                        '/span'
                );
                $this->assertTags($input, $pattern);
        }

/**
 * Test that assertTags runs quickly.
 *
 * @return void
 */
        public function testAssertTagsRuntimeComplexity() {
                $pattern = array(
                        'div' => array(
                                'attr1' => 'val1',
                                'attr2' => 'val2',
                                'attr3' => 'val3',
                                'attr4' => 'val4',
                                'attr5' => 'val5',
                                'attr6' => 'val6',
                                'attr7' => 'val7',
                                'attr8' => 'val8',
                        ),
                        'My div',
                        '/div'
                );
                $input = '<div attr8="val8" attr6="val6" attr4="val4" attr2="val2"' .
                        ' attr1="val1" attr3="val3" attr5="val5" attr7="val7" />' .
                        'My div' .
                        '</div>';
                $this->assertTags($input, $pattern);
        }

/**
 * testNumericValuesInExpectationForAssertTags
 *
 * @return void
 */
        public function testNumericValuesInExpectationForAssertTags() {
                $test = new AssertTagsTestCase('testNumericValuesInExpectationForAssertTags');
                $result = $test->run();
                $this->assertEquals(0, $result->errorCount());
                $this->assertTrue($result->wasSuccessful());
                $this->assertEquals(0, $result->failureCount());
        }

/**
 * testBadAssertTags
 *
 * @return void
 */
        public function testBadAssertTags() {
                $test = new AssertTagsTestCase('testBadAssertTags');
                $result = $test->run();
                $this->assertEquals(0, $result->errorCount());
                $this->assertFalse($result->wasSuccessful());
                $this->assertEquals(1, $result->failureCount());

                $test = new AssertTagsTestCase('testBadAssertTags2');
                $result = $test->run();
                $this->assertEquals(0, $result->errorCount());
                $this->assertFalse($result->wasSuccessful());
                $this->assertEquals(1, $result->failureCount());
        }

/**
 * testLoadFixtures
 *
 * @return void
 */
        public function testLoadFixtures() {
                $test = new FixturizedTestCase('testFixturePresent');
                $manager = $this->getMock('CakeFixtureManager');
                $manager->fixturize($test);
                $test->fixtureManager = $manager;
                $manager->expects($this->once())->method('load');
                $manager->expects($this->once())->method('unload');
                $result = $test->run();
                $this->assertEquals(0, $result->errorCount());
                $this->assertTrue($result->wasSuccessful());
                $this->assertEquals(0, $result->failureCount());
        }

/**
 * testLoadFixturesOnDemand
 *
 * @return void
 */
        public function testLoadFixturesOnDemand() {
                $test = new FixturizedTestCase('testFixtureLoadOnDemand');
                $test->autoFixtures = false;
                $manager = $this->getMock('CakeFixtureManager');
                $manager->fixturize($test);
                $test->fixtureManager = $manager;
                $manager->expects($this->once())->method('loadSingle');
                $result = $test->run();
                $this->assertEquals(0, $result->errorCount());
        }

/**
 * testLoadFixturesOnDemand
 *
 * @return void
 */
        public function testUnoadFixturesAfterFailure() {
                $test = new FixturizedTestCase('testFixtureLoadOnDemand');
                $test->autoFixtures = false;
                $manager = $this->getMock('CakeFixtureManager');
                $manager->fixturize($test);
                $test->fixtureManager = $manager;
                $manager->expects($this->once())->method('loadSingle');
                $result = $test->run();
                $this->assertEquals(0, $result->errorCount());
        }

/**
 * testThrowException
 *
 * @return void
 */
        public function testThrowException() {
                $test = new FixturizedTestCase('testThrowException');
                $test->autoFixtures = false;
                $manager = $this->getMock('CakeFixtureManager');
                $manager->fixturize($test);
                $test->fixtureManager = $manager;
                $manager->expects($this->once())->method('unload');
                $result = $test->run();
                $this->assertEquals(1, $result->errorCount());
        }

/**
 * testSkipIf
 *
 * @return void
 */
        public function testSkipIf() {
                $test = new FixturizedTestCase('testSkipIfTrue');
                $result = $test->run();
                $this->assertEquals(1, $result->skippedCount());

                $test = new FixturizedTestCase('testSkipIfFalse');
                $result = $test->run();
                $this->assertEquals(0, $result->skippedCount());
        }

/**
 * Test that CakeTestCase::setUp() backs up values.
 *
 * @return void
 */
        public function testSetupBackUpValues() {
                $this->assertArrayHasKey('debug', $this->_configure);
                $this->assertArrayHasKey('Plugin', $this->_pathRestore);
        }

/**
 * test assertTextNotEquals()
 *
 * @return void
 */
        public function testAssertTextNotEquals() {
                $one = "\r\nOne\rTwooo";
                $two = "\nOne\nTwo";
                $this->assertTextNotEquals($one, $two);
        }

/**
 * test assertTextEquals()
 *
 * @return void
 */
        public function testAssertTextEquals() {
                $one = "\r\nOne\rTwo";
                $two = "\nOne\nTwo";
                $this->assertTextEquals($one, $two);
        }

/**
 * test assertTextStartsWith()
 *
 * @return void
 */
        public function testAssertTextStartsWith() {
                $stringDirty = "some\nstring\r\nwith\rdifferent\nline endings!";
                $stringClean = "some\nstring\nwith\ndifferent\nline endings!";

                $this->assertStringStartsWith("some\nstring", $stringDirty);
                $this->assertStringStartsNotWith("some\r\nstring\r\nwith", $stringDirty);
                $this->assertStringStartsNotWith("some\nstring\nwith", $stringDirty);

                $this->assertTextStartsWith("some\nstring\nwith", $stringDirty);
                $this->assertTextStartsWith("some\r\nstring\r\nwith", $stringDirty);
        }

/**
 * test assertTextStartsNotWith()
 *
 * @return void
 */
        public function testAssertTextStartsNotWith() {
                $stringDirty = "some\nstring\r\nwith\rdifferent\nline endings!";
                $stringClean = "some\nstring\nwith\ndifferent\nline endings!";

                $this->assertTextStartsNotWith("some\nstring\nwithout", $stringDirty);
        }

/**
 * test assertTextEndsWith()
 *
 * @return void
 */
        public function testAssertTextEndsWith() {
                $stringDirty = "some\nstring\r\nwith\rdifferent\nline endings!";
                $stringClean = "some\nstring\nwith\ndifferent\nline endings!";

                $this->assertTextEndsWith("string\nwith\r\ndifferent\rline endings!", $stringDirty);
                $this->assertTextEndsWith("string\r\nwith\ndifferent\nline endings!", $stringDirty);
        }

/**
 * test assertTextEndsNotWith()
 *
 * @return void
 */
        public function testAssertTextEndsNotWith() {
                $stringDirty = "some\nstring\r\nwith\rdifferent\nline endings!";
                $stringClean = "some\nstring\nwith\ndifferent\nline endings!";

                $this->assertStringEndsNotWith("different\nline endings", $stringDirty);
                $this->assertTextEndsNotWith("different\rline endings", $stringDirty);
        }

/**
 * test assertTextContains()
 *
 * @return void
 */
        public function testAssertTextContains() {
                $stringDirty = "some\nstring\r\nwith\rdifferent\nline endings!";
                $stringClean = "some\nstring\nwith\ndifferent\nline endings!";

                $this->assertContains("different", $stringDirty);
                $this->assertNotContains("different\rline", $stringDirty);

                $this->assertTextContains("different\rline", $stringDirty);
        }

/**
 * test assertTextNotContains()
 *
 * @return void
 */
        public function testAssertTextNotContains() {
                $stringDirty = "some\nstring\r\nwith\rdifferent\nline endings!";
                $stringClean = "some\nstring\nwith\ndifferent\nline endings!";

                $this->assertTextNotContains("different\rlines", $stringDirty);
        }

/**
 * test getMockForModel()
 *
 * @return void
 */
        public function testGetMockForModel() {
                App::build(array(
                                'Model' => array(
                                        CAKE . 'Test' . DS . 'test_app' . DS . 'Model' . DS
                                )
                ), App::RESET);
                $Post = $this->getMockForModel('Post');

                $this->assertInstanceOf('Post', $Post);
                $this->assertNull($Post->save(array()));
                $this->assertNull($Post->find('all'));
                $this->assertEquals('posts', $Post->useTable);

                $Post = $this->getMockForModel('Post', array('save'));

                $this->assertNull($Post->save(array()));
                $this->assertInternalType('array', $Post->find('all'));
        }

/**
 * test getMockForModel() with plugin models
 *
 * @return void
 */
        public function testGetMockForModelWithPlugin() {
                App::build(array(
                                'Plugin' => array(
                                        CAKE . 'Test' . DS . 'test_app' . DS . 'Plugin' . DS
                                )
                ), App::RESET);
                CakePlugin::load('TestPlugin');
                $this->getMockForModel('TestPlugin.TestPluginAppModel');
                $TestPluginComment = $this->getMockForModel('TestPlugin.TestPluginComment');

                $result = ClassRegistry::init('TestPlugin.TestPluginComment');
                $this->assertInstanceOf('TestPluginComment', $result);

                $TestPluginComment = $this->getMockForModel('TestPlugin.TestPluginComment', array('save'));

                $this->assertInstanceOf('TestPluginComment', $TestPluginComment);
                $TestPluginComment->expects($this->at(0))
                        ->method('save')
                        ->will($this->returnValue(true));
                $TestPluginComment->expects($this->at(1))
                        ->method('save')
                        ->will($this->returnValue(false));
                $this->assertTrue($TestPluginComment->save(array()));
                $this->assertFalse($TestPluginComment->save(array()));
        }

/**
 * testGetMockForModelModel
 *
 * @return void
 */
        public function testGetMockForModelModel() {
                $Mock = $this->getMockForModel('Model', array('save'), array('name' => 'Comment'));

                $result = ClassRegistry::init('Comment');
                $this->assertInstanceOf('Model', $result);

                $Mock->expects($this->at(0))
                        ->method('save')
                        ->will($this->returnValue(true));
                $Mock->expects($this->at(1))
                        ->method('save')
                        ->will($this->returnValue(false));

                $this->assertTrue($Mock->save(array()));
                $this->assertFalse($Mock->save(array()));
        }

/**
 * testGetMockForModelDoesNotExist
 *
 * @expectedException MissingModelException
 * @expectedExceptionMessage Model IDoNotExist could not be found
 * @return void
 */
        public function testGetMockForModelDoesNotExist() {
                $this->getMockForModel('IDoNotExist');
        }
}