Admin Control Panel v2.0

✎ Editing: ConfigTest.php ← Back

<?php

class HTMLPurifier_ConfigTest extends HTMLPurifier_Harness

{

protected $schema;

protected $oldFactory;

public function setUp()

{

// set up a dummy schema object for testing

$this->schema = new HTMLPurifier_ConfigSchema();

}

// test functionality based on ConfigSchema

public function testNormal()

{

$this->schema->add('Element.Abbr', 'H', 'string', false);

$this->schema->add('Element.Name', 'hydrogen', 'istring', false);

$this->schema->add('Element.Number', 1, 'int', false);

$this->schema->add('Element.Mass', 1.00794, 'float', false);

$this->schema->add('Element.Radioactive', false, 'bool', false);

$this->schema->add('Element.Isotopes', array(1 => true, 2 => true, 3 => true), 'lookup', false);

$this->schema->add('Element.Traits', array('nonmetallic', 'odorless', 'flammable'), 'list', false);

$this->schema->add('Element.IsotopeNames', array(1 => 'protium', 2 => 'deuterium', 3 => 'tritium'), 'hash', false);

$this->schema->add('Element.Object', new stdClass(), 'mixed', false);

$config = new HTMLPurifier_Config($this->schema);

$config->autoFinalize = false;

$config->chatty = false;

// test default value retrieval

$this->assertIdentical($config->get('Element.Abbr'), 'H');

$this->assertIdentical($config->get('Element.Name'), 'hydrogen');

$this->assertIdentical($config->get('Element.Number'), 1);

$this->assertIdentical($config->get('Element.Mass'), 1.00794);

$this->assertIdentical($config->get('Element.Radioactive'), false);

$this->assertIdentical($config->get('Element.Isotopes'), array(1 => true, 2 => true, 3 => true));

$this->assertIdentical($config->get('Element.Traits'), array('nonmetallic', 'odorless', 'flammable'));

$this->assertIdentical($config->get('Element.IsotopeNames'), array(1 => 'protium', 2 => 'deuterium', 3 => 'tritium'));

$this->assertIdentical($config->get('Element.Object'), new stdClass());

// test setting values

$config->set('Element.Abbr', 'Pu');

$config->set('Element.Name', 'PLUTONIUM'); // test decaps

$config->set('Element.Number', '94'); // test parsing

$config->set('Element.Mass', '244.'); // test parsing

$config->set('Element.Radioactive', true);

$config->set('Element.Isotopes', array(238, 239)); // test inversion

$config->set('Element.Traits', 'nuclear, heavy, actinide'); // test parsing

$config->set('Element.IsotopeNames', array(238 => 'Plutonium-238', 239 => 'Plutonium-239'));

$config->set('Element.Object', false); // unmodeled

$this->expectError('Cannot set undefined directive Element.Metal to value');

$config->set('Element.Metal', true);

$this->expectError('Value for Element.Radioactive is of invalid type, should be bool');

$config->set('Element.Radioactive', 'very');

// test value retrieval

$this->assertIdentical($config->get('Element.Abbr'), 'Pu');

$this->assertIdentical($config->get('Element.Name'), 'plutonium');

$this->assertIdentical($config->get('Element.Number'), 94);

$this->assertIdentical($config->get('Element.Mass'), 244.);

$this->assertIdentical($config->get('Element.Radioactive'), true);

$this->assertIdentical($config->get('Element.Isotopes'), array(238 => true, 239 => true));

$this->assertIdentical($config->get('Element.Traits'), array('nuclear', 'heavy', 'actinide'));

$this->assertIdentical($config->get('Element.IsotopeNames'), array(238 => 'Plutonium-238', 239 => 'Plutonium-239'));

$this->assertIdentical($config->get('Element.Object'), false);

$this->expectError('Cannot retrieve value of undefined directive Element.Metal');

$config->get('Element.Metal');

}

public function testEnumerated()

{

// case sensitive

$this->schema->add('Instrument.Manufacturer', 'Yamaha', 'string', false);

$this->schema->addAllowedValues('Instrument.Manufacturer', array(

'Yamaha' => true, 'Conn-Selmer' => true, 'Vandoren' => true,

'Laubin' => true, 'Buffet' => true, 'other' => true));

$this->schema->addValueAliases('Instrument.Manufacturer', array(

'Selmer' => 'Conn-Selmer'));

// case insensitive

$this->schema->add('Instrument.Family', 'woodwind', 'istring', false);

$this->schema->addAllowedValues('Instrument.Family', array(

'brass' => true, 'woodwind' => true, 'percussion' => true,

'string' => true, 'keyboard' => true, 'electronic' => true));

$this->schema->addValueAliases('Instrument.Family', array(

'synth' => 'electronic'));

$config = new HTMLPurifier_Config($this->schema);

$config->autoFinalize = false;

$config->chatty = false;

// case sensitive

$config->set('Instrument.Manufacturer', 'Vandoren');

$this->assertIdentical($config->get('Instrument.Manufacturer'), 'Vandoren');

$config->set('Instrument.Manufacturer', 'Selmer');

$this->assertIdentical($config->get('Instrument.Manufacturer'), 'Conn-Selmer');

$this->expectError('Value not supported, valid values are: Yamaha, Conn-Selmer, Vandoren, Laubin, Buffet, other');

$config->set('Instrument.Manufacturer', 'buffet');

// case insensitive

$config->set('Instrument.Family', 'brass');

$this->assertIdentical($config->get('Instrument.Family'), 'brass');

$config->set('Instrument.Family', 'PERCUSSION');

$this->assertIdentical($config->get('Instrument.Family'), 'percussion');

$config->set('Instrument.Family', 'synth');

$this->assertIdentical($config->get('Instrument.Family'), 'electronic');

$config->set('Instrument.Family', 'Synth');

$this->assertIdentical($config->get('Instrument.Family'), 'electronic');

}

public function testNull()

{

$this->schema->add('ReportCard.English', null, 'string', true);

$this->schema->add('ReportCard.Absences', 0, 'int', false);

$config = new HTMLPurifier_Config($this->schema);

$config->autoFinalize = false;

$config->chatty = false;

$config->set('ReportCard.English', 'B-');

$this->assertIdentical($config->get('ReportCard.English'), 'B-');

$config->set('ReportCard.English', null); // not yet graded

$this->assertIdentical($config->get('ReportCard.English'), null);

// error

$this->expectError('Value for ReportCard.Absences is of invalid type, should be int');

$config->set('ReportCard.Absences', null);

}

public function testAliases()

{

$this->schema->add('Home.Rug', 3, 'int', false);

$this->schema->addAlias('Home.Carpet', 'Home.Rug');

$config = new HTMLPurifier_Config($this->schema);

$config->autoFinalize = false;

$config->chatty = false;

$this->assertIdentical($config->get('Home.Rug'), 3);

$this->expectError('Cannot get value from aliased directive, use real name Home.Rug');

$config->get('Home.Carpet');

$this->expectError('Home.Carpet is an alias, preferred directive name is Home.Rug');

$config->set('Home.Carpet', 999);

$this->assertIdentical($config->get('Home.Rug'), 999);

}

// test functionality based on method

public function test_getBatch()

{

$this->schema->add('Variables.TangentialAcceleration', 'a_tan', 'string', false);

$this->schema->add('Variables.AngularAcceleration', 'alpha', 'string', false);

$config = new HTMLPurifier_Config($this->schema);

$config->autoFinalize = false;

$config->chatty = false;

// grab a namespace

$this->assertIdentical(

$config->getBatch('Variables'),

array(

'TangentialAcceleration' => 'a_tan',

'AngularAcceleration' => 'alpha'

)

);

// grab a non-existant namespace

$this->expectError('Cannot retrieve undefined namespace Constants');

$config->getBatch('Constants');

}

public function test_loadIni()

{

$this->schema->add('Shortcut.Copy', 'c', 'istring', false);

$this->schema->add('Shortcut.Paste', 'v', 'istring', false);

$this->schema->add('Shortcut.Cut', 'x', 'istring', false);

$config = new HTMLPurifier_Config($this->schema);

$config->autoFinalize = false;

$config->loadIni(dirname(__FILE__) . '/ConfigTest-loadIni.ini');

$this->assertIdentical($config->get('Shortcut.Copy'), 'q');

$this->assertIdentical($config->get('Shortcut.Paste'), 'p');

$this->assertIdentical($config->get('Shortcut.Cut'), 't');

}

public function test_getHTMLDefinition()

{

// we actually want to use the old copy, because the definition

// generation routines have dependencies on configuration values

$config = HTMLPurifier_Config::createDefault();

$config->set('HTML.Doctype', 'XHTML 1.0 Strict');

$config->autoFinalize = false;

$def = $config->getCSSDefinition();

$this->assertIsA($def, 'HTMLPurifier_CSSDefinition');

$def  = $config->getHTMLDefinition();

$def2 = $config->getHTMLDefinition();

$this->assertIsA($def, 'HTMLPurifier_HTMLDefinition');

$this->assertTrue($def === $def2);

$this->assertTrue($def->setup);

$old_def = clone $def2;

$config->set('HTML.Doctype', 'HTML 4.01 Transitional');

$def = $config->getHTMLDefinition();

$this->assertIsA($def, 'HTMLPurifier_HTMLDefinition');

$this->assertTrue($def !== $old_def);

$this->assertTrue($def->setup);

}

public function test_getHTMLDefinition_deprecatedRawError()

{

$config = HTMLPurifier_Config::createDefault();

$config->chatty = false;

// test deprecated retrieval of raw definition

$config->set('HTML.DefinitionID', 'HTMLPurifier_ConfigTest->test_getHTMLDefinition()');

$config->set('HTML.DefinitionRev', 3);

$this->expectError("Useless DefinitionID declaration");

$def = $config->getHTMLDefinition(true);

$this->assertEqual(false, $def->setup);

// auto initialization

$config->getHTMLDefinition();

$this->assertTrue($def->setup);

}

public function test_getHTMLDefinition_optimizedRawError()

{

$this->expectException(new HTMLPurifier_Exception("Cannot set optimized = true when raw = false"));

$config = HTMLPurifier_Config::createDefault();

$config->getHTMLDefinition(false, true);

}

public function test_getHTMLDefinition_rawAfterSetupError()

{

$this->expectException(new HTMLPurifier_Exception("Cannot retrieve raw definition after it has already been setup"));

$config = HTMLPurifier_Config::createDefault();

$config->chatty = false;

$config->getHTMLDefinition();

$config->getHTMLDefinition(true);

}

public function test_getHTMLDefinition_inconsistentOptimizedError()

{

$this->expectError("Useless DefinitionID declaration");

$this->expectException(new HTMLPurifier_Exception("Inconsistent use of optimized and unoptimized raw definition retrievals"));

$config = HTMLPurifier_Config::create(array('HTML.DefinitionID' => 'HTMLPurifier_ConfigTest->test_getHTMLDefinition_inconsistentOptimizedError'));

$config->chatty = false;

$config->getHTMLDefinition(true, false);

$config->getHTMLDefinition(true, true);

}

public function test_getHTMLDefinition_inconsistentOptimizedError2()

{

$this->expectException(new HTMLPurifier_Exception("Inconsistent use of optimized and unoptimized raw definition retrievals"));

$config = HTMLPurifier_Config::create(array('HTML.DefinitionID' => 'HTMLPurifier_ConfigTest->test_getHTMLDefinition_inconsistentOptimizedError2'));

$config->chatty = false;

$config->getHTMLDefinition(true, true);

$config->getHTMLDefinition(true, false);

}

public function test_getHTMLDefinition_rawError()

{

$config = HTMLPurifier_Config::createDefault();

$this->expectException(new HTMLPurifier_Exception('Cannot retrieve raw version without specifying %HTML.DefinitionID'));

$def = $config->getHTMLDefinition(true, true);

}

public function test_getCSSDefinition()

{

$config = HTMLPurifier_Config::createDefault();

$def = $config->getCSSDefinition();

$this->assertIsA($def, 'HTMLPurifier_CSSDefinition');

}

public function test_getDefinition()

{

$this->schema->add('Cache.DefinitionImpl', null, 'string', true);

$config = new HTMLPurifier_Config($this->schema);

$this->expectException(new HTMLPurifier_Exception("Definition of Crust type not supported"));

$config->getDefinition('Crust');

}

public function test_loadArray()

{

// setup a few dummy namespaces/directives for our testing

$this->schema->add('Zoo.Aadvark', 0, 'int', false);

$this->schema->add('Zoo.Boar',    0, 'int', false);

$this->schema->add('Zoo.Camel',   0, 'int', false);

$this->schema->add('Zoo.Others', array(), 'list', false);

$config_manual   = new HTMLPurifier_Config($this->schema);

$config_loadabbr = new HTMLPurifier_Config($this->schema);

$config_loadfull = new HTMLPurifier_Config($this->schema);

$config_manual->set('Zoo.Aadvark', 3);

$config_manual->set('Zoo.Boar', 5);

$config_manual->set('Zoo.Camel', 2000); // that's a lotta camels!

$config_manual->set('Zoo.Others', array('Peacock', 'Dodo')); // wtf!

// condensed form

$config_loadabbr->loadArray(array(

'Zoo.Aadvark' => 3,

'Zoo.Boar' => 5,

'Zoo.Camel' => 2000,

'Zoo.Others' => array('Peacock', 'Dodo')

));

// fully expanded form

$config_loadfull->loadArray(array(

'Zoo' => array(

'Aadvark' => 3,

'Boar' => 5,

'Camel' => 2000,

'Others' => array('Peacock', 'Dodo')

)

));

$this->assertIdentical($config_manual, $config_loadabbr);

$this->assertIdentical($config_manual, $config_loadfull);

}

public function test_create()

{

$this->schema->add('Cake.Sprinkles', 666, 'int', false);

$this->schema->add('Cake.Flavor', 'vanilla', 'string', false);

$config = new HTMLPurifier_Config($this->schema);

$config->set('Cake.Sprinkles', 42);

// test flat pass-through

$created_config = HTMLPurifier_Config::create($config, $this->schema);

$this->assertIdentical($config, $created_config);

// test loadArray

$created_config = HTMLPurifier_Config::create(array('Cake.Sprinkles' => 42), $this->schema);

$this->assertIdentical($config, $created_config);

// test loadIni

$created_config = HTMLPurifier_Config::create(dirname(__FILE__) . '/ConfigTest-create.ini', $this->schema);

$this->assertIdentical($config, $created_config);

}

public function test_finalize()

{

// test finalization

$this->schema->add('Poem.Meter', 'iambic', 'string', false);

$config = new HTMLPurifier_Config($this->schema);

$config->autoFinalize = false;

$config->chatty = false;

$config->set('Poem.Meter', 'irregular');

$config->finalize();

$this->expectError('Cannot set directive after finalization');

$config->set('Poem.Meter', 'vedic');

$this->expectError('Cannot load directives after finalization');

$config->loadArray(array('Poem.Meter' => 'octosyllable'));

$this->expectError('Cannot load directives after finalization');

$config->loadIni(dirname(__FILE__) . '/ConfigTest-finalize.ini');

}

public function test_loadArrayFromForm()

{

$this->schema->add('Pancake.Mix', 'buttermilk', 'string', false);

$this->schema->add('Pancake.Served', true, 'bool', false);

$this->schema->add('Toppings.Syrup', true, 'bool', false);

$this->schema->add('Toppings.Flavor', 'maple', 'string', false);

$this->schema->add('Toppings.Strawberries', 3, 'int', false);

$this->schema->add('Toppings.Calories', 2000, 'int', true);

$this->schema->add('Toppings.DefinitionID', null, 'string', true);

$this->schema->add('Toppings.DefinitionRev', 1, 'int', false);

$this->schema->add('Toppings.Protected', 1, 'int', false);

$get = array(

'breakfast' => array(

'Pancake.Mix' => 'nasty',

'Pancake.Served' => '0',

'Toppings.Syrup' => '0',

'Toppings.Flavor' => "juice",

'Toppings.Strawberries' => '999',

'Toppings.Calories' => '',

'Null_Toppings.Calories' => '1',

'Toppings.DefinitionID' => '<argh>',

'Toppings.DefinitionRev' => '65',

'Toppings.Protected' => '4',

)

);

$config_expect = HTMLPurifier_Config::create(array(

'Pancake.Served' => false,

'Toppings.Syrup' => false,

'Toppings.Flavor' => "juice",

'Toppings.Strawberries' => 999,

'Toppings.Calories' => null

), $this->schema);

$config_result = HTMLPurifier_Config::loadArrayFromForm(

$get, 'breakfast',

array('Pancake.Served', 'Toppings', '-Toppings.Protected'),

false, // mq fix

$this->schema

);

$this->assertEqual($config_expect, $config_result);

MAGIC QUOTES NOT TESTED!!!

$get = array(

'breakfast' => array(

'Pancake.Mix' => 'n\\asty'

)

);

$config_expect = HTMLPurifier_Config::create(array(

'Pancake.Mix' => 'n\\asty'

));

$config_result = HTMLPurifier_Config::loadArrayFromForm($get, 'breakfast', true, false);

$this->assertEqual($config_expect, $config_result);

}

public function test_getAllowedDirectivesForForm()

{

$this->schema->add('Unused.Unused', 'Foobar', 'string', false);

$this->schema->add('Partial.Allowed', true, 'bool', false);

$this->schema->add('Partial.Unused', 'Foobar', 'string', false);

$this->schema->add('All.Allowed', true, 'bool', false);

$this->schema->add('All.Blacklisted', 'Foobar', 'string', false); // explicitly blacklisted

$this->schema->add('All.DefinitionID', 'Foobar', 'string', true); // auto-blacklisted

$this->schema->add('All.DefinitionRev', 2, 'int', false); // auto-blacklisted

$input = array('Partial.Allowed', 'All', '-All.Blacklisted');

$output = HTMLPurifier_Config::getAllowedDirectivesForForm($input, $this->schema);

$expect = array(

array('Partial', 'Allowed'),

array('All', 'Allowed')

);

$this->assertEqual($output, $expect);

}

public function testDeprecatedAPI()

{

$this->schema->add('Foo.Bar', 2, 'int', false);

$config = new HTMLPurifier_Config($this->schema);

$config->chatty = false;

$this->expectError('Using deprecated API: use $config->set(\'Foo.Bar\', ...) instead');

$config->set('Foo', 'Bar', 4);

$this->expectError('Using deprecated API: use $config->get(\'Foo.Bar\') instead');

$this->assertIdentical($config->get('Foo', 'Bar'), 4);

}

public function testInherit()

{

$this->schema->add('Phantom.Masked', 25, 'int', false);

$this->schema->add('Phantom.Unmasked', 89, 'int', false);

$this->schema->add('Phantom.Latemasked', 11, 'int', false);

$config = new HTMLPurifier_Config($this->schema);

$config->set('Phantom.Masked', 800);

$subconfig = HTMLPurifier_Config::inherit($config);

$config->set('Phantom.Latemasked', 100, 'int', false);

$this->assertIdentical($subconfig->get('Phantom.Masked'), 800);

$this->assertIdentical($subconfig->get('Phantom.Unmasked'), 89);

$this->assertIdentical($subconfig->get('Phantom.Latemasked'), 100);

}

public function testSerialize()

{

$config = HTMLPurifier_Config::createDefault();

$config->set('HTML.Allowed', 'a');

$config2 = unserialize($config->serialize());

$this->assertIdentical($config->get('HTML.Allowed'), $config2->get('HTML.Allowed'));

}

public function testDefinitionCachingNothing()

{

list($mock, $config) = $this->setupCacheMock('HTML');

// should not touch the cache

$mock->expectNever('get');

$mock->expectNever('add');

$mock->expectNever('set');

$config->getDefinition('HTML', true);

$config->getDefinition('HTML');

$this->teardownCacheMock();

}

public function testDefinitionCachingOptimized()

{

list($mock, $config) = $this->setupCacheMock('HTML');

$mock->expectNever('set');

$config->set('HTML.DefinitionID', 'HTMLPurifier_ConfigTest->testDefinitionCachingOptimized');

$mock->expectOnce('get');

$mock->setReturnValue('get', null);

$this->assertTrue($config->maybeGetRawHTMLDefinition());

$mock->expectOnce('add');

$config->getDefinition('HTML');

$this->teardownCacheMock();

}

public function testDefinitionCachingOptimizedHit()

{

$fake_config = HTMLPurifier_Config::createDefault();

$fake_def = $fake_config->getHTMLDefinition();

list($mock, $config) = $this->setupCacheMock('HTML');

// should never frob cache

$mock->expectNever('add');

$mock->expectNever('set');

$config->set('HTML.DefinitionID', 'HTMLPurifier_ConfigTest->testDefinitionCachingOptimizedHit');

$mock->expectOnce('get');

$mock->setReturnValue('get', $fake_def);

$this->assertNull($config->maybeGetRawHTMLDefinition());

$config->getDefinition('HTML');

$this->teardownCacheMock();

}

protected function setupCacheMock($type)

{

// inject our definition cache mock globally (borrowed from

// DefinitionFactoryTest)

generate_mock_once("HTMLPurifier_DefinitionCacheFactory");

$factory = new HTMLPurifier_DefinitionCacheFactoryMock();

$this->oldFactory = HTMLPurifier_DefinitionCacheFactory::instance();

HTMLPurifier_DefinitionCacheFactory::instance($factory);

generate_mock_once("HTMLPurifier_DefinitionCache");

$mock = new HTMLPurifier_DefinitionCacheMock();

$config = HTMLPurifier_Config::createDefault();

$factory->setReturnValue('create', $mock, array($type, $config));

return array($mock, $config);

}

protected function teardownCacheMock()

{

HTMLPurifier_DefinitionCacheFactory::instance($this->oldFactory);

}

// vim: et sw=4 sts=4

Cancel