/** * Test JPathway::getInstance(). * * @return void * * @since 3.1 */ public function testGetInstance() { $current = TestReflection::getValue('JApplicationHelper', '_clients'); // Test Client $obj = new stdClass(); $obj->id = 0; $obj->name = 'inspector'; $obj->path = JPATH_TESTS; $obj2 = new stdClass(); $obj2->id = 1; $obj2->name = 'inspector2'; $obj2->path = __DIR__ . '/stubs'; TestReflection::setValue('JApplicationHelper', '_clients', array($obj, $obj2)); $pathway = JPathway::getInstance(''); $this->assertInstanceOf('JPathway', $pathway); $pathway = JPathway::getInstance('Inspector2'); $this->assertInstanceOf('JPathwayInspector2', $pathway); $ret = true; try { JPathway::getInstance('Error'); } catch (Exception $e) { $ret = false; } if ($ret) { $this->fail('JPathway did not throw a proper exception with a false client.'); } TestReflection::setValue('JApplicationHelper', '_clients', $current); }
/** * Test JModelAdmin::__construct * * @since 3.4 * * @return void * * @testdox Constructor applies default configuration */ public function testConstructorAppliesDefaultConfiguration() { $config = array('event_after_delete' => 'onContentAfterDelete', 'event_after_save' => 'onContentAfterSave', 'event_before_delete' => 'onContentBeforeDelete', 'event_before_save' => 'onContentBeforeSave', 'event_change_state' => 'onContentChangeState', 'text_prefix' => 'COM_MOCK_J'); foreach ($config as $key => $value) { $this->assertEquals($value, TestReflection::getValue($this->object, $key)); } }
/** * Tests the JImage::__construct method. * * @return void * * @since 11.4 */ public function testConstructor() { // Create a image handle of the correct size. $imageHandle = imagecreatetruecolor(100, 100); $filter = new JImageFilterBrightness($imageHandle); $this->assertEquals(TestReflection::getValue($filter, 'handle'), $imageHandle); }
/** * Cache the JLoader settings while we are resetting things for testing. * * @return void * * @since 12.3 */ public static function setUpBeforeClass() { self::$cache['classes'] = \TestReflection::getValue('JLoader', 'classes'); self::$cache['imported'] = \TestReflection::getValue('JLoader', 'imported'); self::$cache['prefixes'] = \TestReflection::getValue('JLoader', 'prefixes'); self::$cache['namespaces'] = \TestReflection::getValue('JLoader', 'namespaces'); }
/** * Test the JInput::parseArguments method. * * @dataProvider provider_parseArguments */ public function test_parseArguments($inputArgv, $expectedData, $expectedArgs) { $_SERVER['argv'] = $inputArgv; $this->inspector = new JInputCLI(null, array('filter' => new JFilterInputMock())); $this->assertThat(TestReflection::getValue($this->inspector, 'data'), $this->identicalTo($expectedData)); $this->assertThat(TestReflection::getValue($this->inspector, 'args'), $this->identicalTo($expectedArgs)); }
/** * Overrides TestCaseCache::testCacheTimeout to deal with the adapter's stored time values in this test * * @testdox The cache handler correctly handles expired cache data * * @medium */ public function testCacheTimeout() { /** @var Cache_Lite $cacheLiteInstance */ $cacheLiteInstance = TestReflection::getValue('JCacheStorageCachelite', 'CacheLiteInstance'); $cacheLiteInstance->_lifeTime = 0.1; // For parent class $this->handler->_lifetime =& $cacheLiteInstance->_lifeTime; parent::testCacheTimeout(); }
/** * Tests the JApplicationBase::loadIdentity method. * * @return void * * @since 12.1 * @covers JApplicationBase::loadIdentity */ public function testLoadIdentity() { $this->class->loadIdentity($this->getMock('JUser', array(), array(), '', false)); $this->assertAttributeInstanceOf('JUser', 'identity', $this->class, 'Tests that the identity object is the correct class.'); // Mock the session. JFactory::$session = $this->getMockSession(array('get.user.id' => 99)); $this->class->loadIdentity(); $this->assertEquals(99, TestReflection::getValue($this->class, 'identity')->get('id'), 'Tests that we got the identity from the factory.'); }
/** * Test the getInput method. * @covers JFormFieldTemplateStyle::getGroups */ public function testGetInput() { $form = new JForm('form1'); $this->assertThat($form->load('<form><field name="templatestyle" type="templatestyle" /></form>'), $this->isTrue(), 'Line:' . __LINE__ . ' XML string should load successfully.'); $field = new JFormFieldTemplatestyle($form); $this->assertThat($field->setup(TestReflection::getValue($form, 'xml')->field, 'value'), $this->isTrue(), 'Line:' . __LINE__ . ' The setup method should return true.'); $this->markTestIncomplete('Problems encountered in next assertion'); $this->assertThat(strlen($field->input), $this->greaterThan(0), 'Line:' . __LINE__ . ' The getInput method should return something without error.'); // TODO: Should check all the attributes have come in properly. }
/** * Overrides TestCaseCache::testCacheTimeout to deal with the adapter's stored time values in this test * * @testdox The cache handler correctly handles expired cache data * * @medium */ public function testCacheTimeout() { /** @var Cache_Lite $cacheLiteInstance */ $cacheLiteInstance = TestReflection::getValue('JCacheStorageCachelite', 'CacheLiteInstance'); $cacheLiteInstance->_lifeTime = 2; $data = 'testData'; $this->assertTrue($this->handler->store($this->id, $this->group, $data), 'Initial Store Failed'); sleep(5); $this->assertFalse($this->handler->get($this->id, $this->group), 'No data should be returned from the cache store when expired.'); }
/** * Tests the __construct method. * * @return void * * @since 12.1 */ public function test__construct() { // New controller with no dependencies. $this->assertEquals('default', TestReflection::getValue($this->_instance, 'app')->input, 'Checks the mock application came from the factory.'); $this->assertAttributeEquals('default', 'input', $this->_instance, 'Checks the input came from the application.'); // New controller with dependencies $app = TestMockApplicationWeb::create($this); $app->test = 'ok'; $class = new BaseController(new JInputCookie(), $app); $this->assertAttributeInstanceOf('JInputCookie', 'input', $class, 'Checks the type of the injected input.'); $this->assertAttributeSame($app, 'app', $class, 'Checks the injected application.'); }
/** * Sets up the fixture, for example, opens a network connection. * This method is called before a test is executed. * * @return void */ protected function setUp() { if (!JCacheStorageRedis::isSupported()) { $this->markTestSkipped('The Redis cache handler is not supported on this system.'); } parent::setUp(); $this->handler = new JCacheStorageRedis(); // This adapter doesn't throw an Exception on a connection failure so we'll have to use Reflection to get into the class to check it if (!TestReflection::getValue($this->handler, '_redis') instanceof Redis) { $this->markTestSkipped('Failed to connect to Redis'); } // Override the lifetime because the JCacheStorage API multiplies it by 60 (converts minutes to seconds) $this->handler->_lifetime = 2; }
/** * Sets up the fixture, for example, opens a network connection. * This method is called before a test is executed. * * @return void */ protected function setUp() { if (!JCacheStorageRedis::isSupported()) { $this->markTestSkipped('The Redis cache handler is not supported on this system.'); } parent::setUp(); // Mock the returns on JApplicationCms::get() to use the default values JFactory::$application->expects($this->any())->method('get')->willReturnArgument(1); $this->handler = new JCacheStorageRedis(); // This adapter doesn't throw an Exception on a connection failure so we'll have to use Reflection to get into the class to check it if (!TestReflection::getValue($this->handler, '_redis') instanceof Redis) { $this->markTestSkipped('Failed to connect to Redis'); } // Override the lifetime because the JCacheStorage API multiplies it by 60 (converts minutes to seconds) $this->handler->_lifetime = 2; }
/** * Tests JUser::load(). * * @param integer $id User ID to load * @param boolean $expected Expected result of load operation * @param boolean $isGuest Boolean marking an user as guest * * @return void * * @since 12.1 * * @dataProvider casesLoad * @covers JUser::load */ public function testLoad($id, $expected, $isGuest) { $testUser = new JUser($id); $this->assertThat($testUser->load($id), $this->equalTo($expected)); $this->assertThat($isGuest, $this->equalTo(TestReflection::getValue($testUser, 'guest'))); }
/** * Tests the JLoader::setup method with $enablePrefixes = false. * * @return void * * @since 12.3 */ public function testSetupWithoutPrefixes() { // Reset the prefixes. TestReflection::setValue('JLoader', 'prefixes', array()); // We unregister all loader functions if registered. $this->unregisterLoaders(); // Setup the loader with $enablePrefixes = false. JLoader::setup(false, false, true); // Get the autoload functions $loaders = spl_autoload_functions(); $foundAutoLoad = false; // We search the list of autoload functions to see if our methods are there. foreach ($loaders as $loader) { if (is_array($loader) && $loader[0] === 'JLoader') { if ($loader[1] === '_autoload') { $foundAutoLoad = true; } } } // We don't expect to find it. $this->assertFalse($foundAutoLoad); // Assert the J prefix hasn't been registered. $prefixes = TestReflection::getValue('JLoader', 'prefixes'); $this->assertFalse(isset($prefixes['J'])); }
/** * Tests JFeedFactory::registerParser() * * @return void * * @expectedException InvalidArgumentException * @since 12.3 */ public function testRegisterParserWithInvalidTag() { TestReflection::setValue($this->_instance, 'parsers', array()); $this->_instance->registerParser('42tag', 'JFeedParserMock'); $this->assertNotEmpty(TestReflection::getValue($this->_instance, 'parsers')); }
/** * Tests the setHttpMethodSuffix method. * * @return void * * @covers JApplicationWebRouterRest::setHttpMethodSuffix * @since 12.3 */ public function testSetHttpMethodSuffix() { $this->_instance->setHttpMethodSuffix('FOO', 'Bar'); $s = TestReflection::getValue($this->_instance, 'suffixMap'); $this->assertEquals('Bar', $s['FOO']); }
/** * Tests the JApplicationWeb::setHeader method. * * @return void * * @since 11.3 */ public function testSetHeader() { // Fill the header body with an arbitrary value. TestReflection::setValue($this->class, 'response', (object) array('cachable' => null, 'headers' => array(array('name' => 'foo', 'value' => 'bar')), 'body' => null)); $this->class->setHeader('foo', 'car'); $this->assertEquals(array(array('name' => 'foo', 'value' => 'bar'), array('name' => 'foo', 'value' => 'car')), TestReflection::getValue($this->class, 'response')->headers); $this->class->setHeader('foo', 'car', true); $this->assertEquals(array(array('name' => 'foo', 'value' => 'car')), TestReflection::getValue($this->class, 'response')->headers); }
/** * Test JPathway::setItemName(). * * @return void * * @since 3.1 */ public function testSetItemName() { $pathway = array(); $object1 = new stdClass(); $object1->name = 'Item1'; $object1->link = 'index.php?key=item1'; $pathway[] = $object1; $object2 = new stdClass(); $object2->name = 'Item2'; $object2->link = 'index.php?key=item2'; $pathway[] = $object2; TestReflection::setValue($this->fixture, '_pathway', $pathway); $this->assertTrue($this->fixture->setItemName(1, 'Item3')); $pathway[1]->name = 'Item3'; $this->assertThat(TestReflection::getValue($this->fixture, '_pathway'), $this->equalTo($pathway)); $this->assertFalse($this->fixture->setItemName(3, 'False')); $this->assertThat(TestReflection::getValue($this->fixture, '_pathway'), $this->equalTo($pathway)); }
/** * Tests the JApplicationWeb::setHeader method. * * @return void * * @since 11.3 */ public function testSetHeader() { // Fill the header body with an arbitrary value. TestReflection::setValue($this->class, 'response', (object) array('cachable' => null, 'headers' => array(array('name' => 'foo', 'value' => 'bar')), 'body' => null)); $this->class->setHeader('foo', 'car'); $this->assertThat(TestReflection::getValue($this->class, 'response')->headers, $this->equalTo(array(array('name' => 'foo', 'value' => 'bar'), array('name' => 'foo', 'value' => 'car'))), 'Tests that a header is added.'); $this->class->setHeader('foo', 'car', true); $this->assertThat(TestReflection::getValue($this->class, 'response')->headers, $this->equalTo(array(array('name' => 'foo', 'value' => 'car'))), 'Tests that headers of the same name are replaced.'); }
/** * Tests the `debug` method. * * @return void * * @since 12.1 */ public function testDebug() { $this->class->debug(99); $this->assertEquals(99, TestReflection::getValue($this->class, '_debug')); }
/** * Test getExpire() * * @covers JSession::getExpire * * @return void */ public function testGetExpire() { $this->assertEquals(TestReflection::getValue($this->object, '_expire'), $this->object->getExpire(), 'Session expire time should be the same'); }
/** * This method tests the set method. * * @param integer $property The property to set * @param string $value The value of the property to set * @param array $expected The expected results for the JPagination object * * @return void * * @covers JPagination::set * @dataProvider dataSet * @since 3.2 */ public function testSet($property, $value, $expected) { $pagination = new JPagination(100, 50, 20, '', $this->app); $pagination->set($property, $value); if ($property == 'viewall') { $result = TestReflection::getValue($pagination, $property); } elseif (strpos($property, '.')) { $prop = explode('.', $property); $prop[1] = ucfirst($prop[1]); $property = implode($prop); $result = $pagination->{$property}; } else { $result = $pagination->{$property}; } $this->assertEquals($result, $expected, 'The expected output of the property is incorrect'); unset($pagination); }
/** * Tests the getItems method. * * @since 3.4 * * @return void * * @testdox getItems() stores result in object cache */ public function testGetItemsStoresItemsInObjectCache() { $object = new ListModelTest(); // Don't run populateState as this blows up TestReflection::setValue($object, '__state_set', true); $object->setState('list.start', 0); $object->setState('list.limit', 1); $object->getItems(); $objectCache = TestReflection::getValue($object, 'cache'); $this->assertArrayHasKey('ecbe76894d32ce7af659e46be7f2a9f0', $objectCache); $this->assertEquals(array((object) array("id" => 1)), $objectCache['ecbe76894d32ce7af659e46be7f2a9f0']); }
/** * Method to test JStringInflector::addSingulariseRule(). * * @return void * * @since 12.1 * @covers JStringInflector::addSingulariseRule */ public function testAddSingulariseRule() { $chain = $this->inflector->addSingulariseRule(array('/foo/', '/bar/')); $this->assertThat( $chain, $this->identicalTo($this->inflector), 'Checks chaining.' ); $rules = TestReflection::getValue($this->inflector, '_rules'); $this->assertThat( in_array('/bar/', $rules['singular']), $this->isTrue(), 'Checks a singularisation rule was added.' ); }
/** * Tests the JDatabaseQuery::unionAll method. * * @return void * * @since 13.1 */ public function testUnionAllTwo() { TestReflection::setValue($this->_instance, 'unionAll', null); $this->_instance->unionAll('SELECT name FROM foo'); $this->_instance->unionAll('SELECT name FROM bar'); $teststring = (string) TestReflection::getValue($this->_instance, 'unionAll'); $this->assertThat($teststring, $this->equalTo(PHP_EOL . "UNION ALL (SELECT name FROM foo)" . PHP_EOL . "UNION ALL (SELECT name FROM bar)"), 'Tests rendered query with two union alls sequentially.'); }
/** * Tests the withStructure method. * * @return void * * @since 3.4 */ public function testWithStructure() { $instance = new JDatabaseExporterPdomysql(); $result = $instance->withStructure(); $this->assertThat($result, $this->identicalTo($instance), 'withStructure must return an object to support chaining.'); $options = TestReflection::getValue($instance, 'options'); $this->assertThat($options->withStructure, $this->isTrue(), 'The default use of withStructure should result in true.'); $instance->withStructure(true); $options = TestReflection::getValue($instance, 'options'); $this->assertThat($options->withStructure, $this->isTrue(), 'The explicit use of withStructure with true should result in true.'); $instance->withStructure(false); $options = TestReflection::getValue($instance, 'options'); $this->assertThat($options->withStructure, $this->isFalse(), 'The explicit use of withStructure with false should result in false.'); }
/** * @testdox Test setting a string as the route * * @covers JInstallerAdapter::setRoute */ public function testSetRoute() { $mockInstaller = $this->getMock('JInstaller'); $mockDatabase = $this->getMockDatabase(); $object = $this->getMockForAbstractClass('JInstallerAdapter', array($mockInstaller, $mockDatabase)); $this->assertEquals('install', TestReflection::getValue($object, 'route'), 'The default route of JInstallerAdapter should be "install"'); $this->assertInstanceOf('JInstallerAdapter', $object->setRoute('update'), 'JInstallerAdapter::setRoute() should return an instance of itself'); $this->assertEquals('update', TestReflection::getValue($object, 'route'), 'The route was not set correctly as a class variable'); }
/** * Tests the __construct() * * @return void * * @since 3.2 */ public function test__construct() { $object = new JUcmBase('com_content.article'); $this->assertInstanceOf('JUcmType', TestReflection::getValue($object, 'type'), 'Ensure the type property is an instance of JUcmType'); }
/** * Tests the authenticate method * * @param array $token The passed token. * @param boolean $fail Mark if should fail or not. * @param string $version Specify oauth version 1.0 or 1.0a. * * @return void * * @dataProvider seedAuthenticate * @since 13.1 */ public function testAuthenticate($token, $fail, $version) { // Already got some credentials stored? if (!is_null($token)) { $this->object->setToken($token); $result = $this->object->authenticate(); $this->assertEquals($result, $token); } else { $this->object->setOption('requestTokenURL', 'https://example.com/request_token'); $this->object->setOption('authoriseURL', 'https://example.com/authorize'); $this->object->setOption('accessTokenURL', 'https://example.com/access_token'); // Request token. $returnData = new stdClass(); $returnData->code = 200; $returnData->body = 'oauth_token=token&oauth_token_secret=secret&oauth_callback_confirmed=true'; $this->client->expects($this->at(0))->method('post')->with($this->object->getOption('requestTokenURL'))->will($this->returnValue($returnData)); $input = TestReflection::getValue($this->object, 'input'); TestReflection::setValue($this->object, 'input', $input); if (strcmp($version, '1.0a') === 0) { $this->object->setOption('callback', 'TEST_URL'); } $this->object->authenticate(); $token = $this->object->getToken(); $this->assertEquals($token['key'], 'token'); $this->assertEquals($token['secret'], 'secret'); // Access token. $input = TestReflection::getValue($this->object, 'input'); if (strcmp($version, '1.0a') === 0) { TestReflection::setValue($this->object, 'version', $version); $data = array('oauth_verifier' => 'verifier', 'oauth_token' => 'token'); } else { TestReflection::setValue($this->object, 'version', $version); $data = array('oauth_token' => 'token'); } TestReflection::setValue($input, 'data', $data); // Get mock session $mockSession = $this->getMock('JSession', array('_start', 'get')); if ($fail) { $mockSession->expects($this->at(0))->method('get')->with('key', null, 'oauth_token')->will($this->returnValue('bad')); $mockSession->expects($this->at(1))->method('get')->with('secret', null, 'oauth_token')->will($this->returnValue('session')); JFactory::$session = $mockSession; $this->setExpectedException('DomainException'); $result = $this->object->authenticate(); } $mockSession->expects($this->at(0))->method('get')->with('key', null, 'oauth_token')->will($this->returnValue('token')); $mockSession->expects($this->at(1))->method('get')->with('secret', null, 'oauth_token')->will($this->returnValue('secret')); JFactory::$session = $mockSession; $returnData = new stdClass(); $returnData->code = 200; $returnData->body = 'oauth_token=token_key&oauth_token_secret=token_secret'; $this->client->expects($this->at(0))->method('post')->with($this->object->getOption('accessTokenURL'))->will($this->returnValue($returnData)); $result = $this->object->authenticate(); $this->assertEquals($result['key'], 'token_key'); $this->assertEquals($result['secret'], 'token_secret'); } }
/** * Tests the JApplicationBase::loadIdentity and JApplicationBase::getIdentity methods. * * @return void * * @since 12.3 */ public function testLoadGetIdentity99() { // Mock the session. JFactory::$session = $this->getMockSession(array('get.user.id' => 99)); $this->class->loadIdentity(); $this->assertEquals(99, TestReflection::getValue($this->class, 'identity')->get('id'), 'Tests that we got the identity from the factory.'); }