tests/HTMLPurifier/ConfigTest.php

   1 <?php
   2
   3 class HTMLPurifier_ConfigTest extends HTMLPurifier_Harness
   4 {
   5
   6     protected $schema;
   7
   8     public function setUp() {
   9         // set up a dummy schema object for testing
  10         $this->schema = new HTMLPurifier_ConfigSchema();
  11     }
  12
  13     // test functionality based on ConfigSchema
  14
  15     function testNormal() {
  16         $this->schema->addNamespace('Element');
  17
  18         $this->schema->add('Element', 'Abbr', 'H', 'string', false);
  19         $this->schema->add('Element', 'Name', 'hydrogen', 'istring', false);
  20         $this->schema->add('Element', 'Number', 1, 'int', false);
  21         $this->schema->add('Element', 'Mass', 1.00794, 'float', false);
  22         $this->schema->add('Element', 'Radioactive', false, 'bool', false);
  23         $this->schema->add('Element', 'Isotopes', array(1 => true, 2 => true, 3 => true), 'lookup', false);
  24         $this->schema->add('Element', 'Traits', array('nonmetallic', 'odorless', 'flammable'), 'list', false);
  25         $this->schema->add('Element', 'IsotopeNames', array(1 => 'protium', 2 => 'deuterium', 3 => 'tritium'), 'hash', false);
  26         $this->schema->add('Element', 'Object', new stdClass(), 'mixed', false);
  27
  28         $config = new HTMLPurifier_Config($this->schema);
  29         $config->autoFinalize = false;
  30
  31         // test default value retrieval
  32         $this->assertIdentical($config->get('Element', 'Abbr'), 'H');
  33         $this->assertIdentical($config->get('Element', 'Name'), 'hydrogen');
  34         $this->assertIdentical($config->get('Element', 'Number'), 1);
  35         $this->assertIdentical($config->get('Element', 'Mass'), 1.00794);
  36         $this->assertIdentical($config->get('Element', 'Radioactive'), false);
  37         $this->assertIdentical($config->get('Element', 'Isotopes'), array(1 => true, 2 => true, 3 => true));
  38         $this->assertIdentical($config->get('Element', 'Traits'), array('nonmetallic', 'odorless', 'flammable'));
  39         $this->assertIdentical($config->get('Element', 'IsotopeNames'), array(1 => 'protium', 2 => 'deuterium', 3 => 'tritium'));
  40         $this->assertIdentical($config->get('Element', 'Object'), new stdClass());
  41
  42         // test setting values
  43         $config->set('Element', 'Abbr', 'Pu');
  44         $config->set('Element', 'Name', 'PLUTONIUM'); // test decaps
  45         $config->set('Element', 'Number', '94'); // test parsing
  46         $config->set('Element', 'Mass', '244.'); // test parsing
  47         $config->set('Element', 'Radioactive', true);
  48         $config->set('Element', 'Isotopes', array(238, 239)); // test inversion
  49         $config->set('Element', 'Traits', 'nuclear, heavy, actinide'); // test parsing
  50         $config->set('Element', 'IsotopeNames', array(238 => 'Plutonium-238', 239 => 'Plutonium-239'));
  51         $config->set('Element', 'Object', false); // unmodeled
  52
  53         $this->expectError('Cannot set undefined directive Element.Metal to value');
  54         $config->set('Element', 'Metal', true);
  55
  56         $this->expectError('Value for Element.Radioactive is of invalid type, should be bool');
  57         $config->set('Element', 'Radioactive', 'very');
  58
  59         // test value retrieval
  60         $this->assertIdentical($config->get('Element', 'Abbr'), 'Pu');
  61         $this->assertIdentical($config->get('Element', 'Name'), 'plutonium');
  62         $this->assertIdentical($config->get('Element', 'Number'), 94);
  63         $this->assertIdentical($config->get('Element', 'Mass'), 244.);
  64         $this->assertIdentical($config->get('Element', 'Radioactive'), true);
  65         $this->assertIdentical($config->get('Element', 'Isotopes'), array(238 => true, 239 => true));
  66         $this->assertIdentical($config->get('Element', 'Traits'), array('nuclear', 'heavy', 'actinide'));
  67         $this->assertIdentical($config->get('Element', 'IsotopeNames'), array(238 => 'Plutonium-238', 239 => 'Plutonium-239'));
  68         $this->assertIdentical($config->get('Element', 'Object'), false);
  69
  70         $this->expectError('Cannot retrieve value of undefined directive Element.Metal');
  71         $config->get('Element', 'Metal');
  72
  73     }
  74
  75     function testEnumerated() {
  76
  77         $this->schema->addNamespace('Instrument', 'Of the musical type.');
  78
  79         // case sensitive
  80         $this->schema->add('Instrument', 'Manufacturer', 'Yamaha', 'string', false);
  81         $this->schema->addAllowedValues('Instrument', 'Manufacturer', array(
  82             'Yamaha' => true, 'Conn-Selmer' => true, 'Vandoren' => true,
  83             'Laubin' => true, 'Buffet' => true, 'other' => true));
  84         $this->schema->addValueAliases('Instrument', 'Manufacturer', array(
  85             'Selmer' => 'Conn-Selmer'));
  86
  87         // case insensitive
  88         $this->schema->add('Instrument', 'Family', 'woodwind', 'istring', false);
  89         $this->schema->addAllowedValues('Instrument', 'Family', array(
  90             'brass' => true, 'woodwind' => true, 'percussion' => true,
  91             'string' => true, 'keyboard' => true, 'electronic' => true));
  92         $this->schema->addValueAliases('Instrument', 'Family', array(
  93             'synth' => 'electronic'));
  94
  95         $config = new HTMLPurifier_Config($this->schema);
  96         $config->autoFinalize = false;
  97
  98         // case sensitive
  99
 100         $config->set('Instrument', 'Manufacturer', 'Vandoren');
 101         $this->assertIdentical($config->get('Instrument', 'Manufacturer'), 'Vandoren');
 102
 103         $config->set('Instrument', 'Manufacturer', 'Selmer');
 104         $this->assertIdentical($config->get('Instrument', 'Manufacturer'), 'Conn-Selmer');
 105
 106         $this->expectError('Value not supported, valid values are: Yamaha, Conn-Selmer, Vandoren, Laubin, Buffet, other');
 107         $config->set('Instrument', 'Manufacturer', 'buffet');
 108
 109         // case insensitive
 110
 111         $config->set('Instrument', 'Family', 'brass');
 112         $this->assertIdentical($config->get('Instrument', 'Family'), 'brass');
 113
 114         $config->set('Instrument', 'Family', 'PERCUSSION');
 115         $this->assertIdentical($config->get('Instrument', 'Family'), 'percussion');
 116
 117         $config->set('Instrument', 'Family', 'synth');
 118         $this->assertIdentical($config->get('Instrument', 'Family'), 'electronic');
 119
 120         $config->set('Instrument', 'Family', 'Synth');
 121         $this->assertIdentical($config->get('Instrument', 'Family'), 'electronic');
 122
 123     }
 124
 125     function testNull() {
 126
 127         $this->schema->addNamespace('ReportCard');
 128         $this->schema->add('ReportCard', 'English', null, 'string', true);
 129         $this->schema->add('ReportCard', 'Absences', 0, 'int', false);
 130
 131         $config = new HTMLPurifier_Config($this->schema);
 132         $config->autoFinalize = false;
 133
 134         $config->set('ReportCard', 'English', 'B-');
 135         $this->assertIdentical($config->get('ReportCard', 'English'), 'B-');
 136
 137         $config->set('ReportCard', 'English', null); // not yet graded
 138         $this->assertIdentical($config->get('ReportCard', 'English'), null);
 139
 140         // error
 141         $this->expectError('Value for ReportCard.Absences is of invalid type, should be int');
 142         $config->set('ReportCard', 'Absences', null);
 143
 144     }
 145
 146     function testAliases() {
 147
 148         $this->schema->addNamespace('Home');
 149         $this->schema->add('Home', 'Rug', 3, 'int', false);
 150         $this->schema->addAlias('Home', 'Carpet', 'Home', 'Rug');
 151
 152         $config = new HTMLPurifier_Config($this->schema);
 153         $config->autoFinalize = false;
 154
 155         $this->assertIdentical($config->get('Home', 'Rug'), 3);
 156
 157         $this->expectError('Cannot get value from aliased directive, use real name Home.Rug');
 158         $config->get('Home', 'Carpet');
 159
 160         $this->expectError('Home.Carpet is an alias, preferred directive name is Home.Rug');
 161         $config->set('Home', 'Carpet', 999);
 162         $this->assertIdentical($config->get('Home', 'Rug'), 999);
 163
 164     }
 165
 166     // test functionality based on method
 167
 168     function test_getBatch() {
 169
 170         $this->schema->addNamespace('Variables');
 171         $this->schema->add('Variables', 'TangentialAcceleration', 'a_tan', 'string', false);
 172         $this->schema->add('Variables', 'AngularAcceleration', 'alpha', 'string', false);
 173
 174         $config = new HTMLPurifier_Config($this->schema);
 175         $config->autoFinalize = false;
 176
 177         // grab a namespace
 178         $this->assertIdentical(
 179             $config->getBatch('Variables'),
 180             array(
 181                 'TangentialAcceleration' => 'a_tan',
 182                 'AngularAcceleration' => 'alpha'
 183             )
 184         );
 185
 186         // grab a non-existant namespace
 187         $this->expectError('Cannot retrieve undefined namespace Constants');
 188         $config->getBatch('Constants');
 189
 190     }
 191
 192     function test_loadIni() {
 193
 194         $this->schema->addNamespace('Shortcut', 'Keyboard shortcuts for commands');
 195         $this->schema->add('Shortcut', 'Copy', 'c', 'istring', false);
 196         $this->schema->add('Shortcut', 'Paste', 'v', 'istring', false);
 197         $this->schema->add('Shortcut', 'Cut', 'x', 'istring', false);
 198
 199         $config = new HTMLPurifier_Config($this->schema);
 200         $config->autoFinalize = false;
 201
 202         $config->loadIni(dirname(__FILE__) . '/ConfigTest-loadIni.ini');
 203
 204         $this->assertIdentical($config->get('Shortcut', 'Copy'), 'q');
 205         $this->assertIdentical($config->get('Shortcut', 'Paste'), 'p');
 206         $this->assertIdentical($config->get('Shortcut', 'Cut'), 't');
 207
 208     }
 209
 210     function test_getHTMLDefinition() {
 211
 212         // we actually want to use the old copy, because the definition
 213         // generation routines have dependencies on configuration values
 214
 215         $config = HTMLPurifier_Config::createDefault();
 216         $config->set('HTML', 'Doctype', 'XHTML 1.0 Strict');
 217         $config->autoFinalize = false;
 218
 219         $def = $config->getCSSDefinition();
 220         $this->assertIsA($def, 'HTMLPurifier_CSSDefinition');
 221
 222         $def  = $config->getHTMLDefinition();
 223         $def2 = $config->getHTMLDefinition();
 224         $this->assertIsA($def, 'HTMLPurifier_HTMLDefinition');
 225         $this->assertSame($def, $def2);
 226         $this->assertTrue($def->setup);
 227
 228         $old_def = clone $def2;
 229
 230         $config->set('HTML', 'Doctype', 'HTML 4.01 Transitional');
 231         $def = $config->getHTMLDefinition();
 232         $this->assertIsA($def, 'HTMLPurifier_HTMLDefinition');
 233         $this->assertNotEqual($def, $old_def);
 234         $this->assertTrue($def->setup);
 235
 236         // test retrieval of raw definition
 237         $config->set('HTML', 'DefinitionID', 'HTMLPurifier_ConfigTest->test_getHTMLDefinition()');
 238         $config->set('HTML', 'DefinitionRev', 3);
 239         $def = $config->getHTMLDefinition(true);
 240         $this->assertNotEqual($def, $old_def);
 241         $this->assertEqual(false, $def->setup);
 242
 243         // auto initialization
 244         $config->getHTMLDefinition();
 245         $this->assertTrue($def->setup);
 246
 247     }
 248
 249     function test_getHTMLDefinition_rawError() {
 250         $config = HTMLPurifier_Config::createDefault();
 251         $this->expectException(new HTMLPurifier_Exception('Cannot retrieve raw version without specifying %HTML.DefinitionID'));
 252         $def = $config->getHTMLDefinition(true);
 253     }
 254
 255     function test_getCSSDefinition() {
 256         $config = HTMLPurifier_Config::createDefault();
 257         $def = $config->getCSSDefinition();
 258         $this->assertIsA($def, 'HTMLPurifier_CSSDefinition');
 259     }
 260
 261     function test_getDefinition() {
 262         $this->schema->addNamespace('Cache', 'Cache stuff');
 263         $this->schema->add('Cache', 'DefinitionImpl', null, 'string', true);
 264         $this->schema->addNamespace('Crust', 'Krusty Krabs');
 265         $config = new HTMLPurifier_Config($this->schema);
 266         $this->expectException(new HTMLPurifier_Exception("Definition of Crust type not supported"));
 267         $config->getDefinition('Crust');
 268     }
 269
 270     function test_loadArray() {
 271         // setup a few dummy namespaces/directives for our testing
 272         $this->schema->addNamespace('Zoo');
 273         $this->schema->add('Zoo', 'Aadvark', 0, 'int', false);
 274         $this->schema->add('Zoo', 'Boar',    0, 'int', false);
 275         $this->schema->add('Zoo', 'Camel',   0, 'int', false);
 276         $this->schema->add('Zoo', 'Others', array(), 'list', false);
 277
 278         $config_manual   = new HTMLPurifier_Config($this->schema);
 279         $config_loadabbr = new HTMLPurifier_Config($this->schema);
 280         $config_loadfull = new HTMLPurifier_Config($this->schema);
 281
 282         $config_manual->set('Zoo', 'Aadvark', 3);
 283         $config_manual->set('Zoo', 'Boar', 5);
 284         $config_manual->set('Zoo', 'Camel', 2000); // that's a lotta camels!
 285         $config_manual->set('Zoo', 'Others', array('Peacock', 'Dodo')); // wtf!
 286
 287         // condensed form
 288         $config_loadabbr->loadArray(array(
 289             'Zoo.Aadvark' => 3,
 290             'Zoo.Boar' => 5,
 291             'Zoo.Camel' => 2000,
 292             'Zoo.Others' => array('Peacock', 'Dodo')
 293         ));
 294
 295         // fully expanded form
 296         $config_loadfull->loadArray(array(
 297             'Zoo' => array(
 298                 'Aadvark' => 3,
 299                 'Boar' => 5,
 300                 'Camel' => 2000,
 301                 'Others' => array('Peacock', 'Dodo')
 302             )
 303         ));
 304
 305         $this->assertIdentical($config_manual, $config_loadabbr);
 306         $this->assertIdentical($config_manual, $config_loadfull);
 307
 308     }
 309
 310     function test_create() {
 311
 312         $this->schema->addNamespace('Cake');
 313         $this->schema->add('Cake', 'Sprinkles', 666, 'int', false);
 314         $this->schema->add('Cake', 'Flavor', 'vanilla', 'string', false);
 315
 316         $config = new HTMLPurifier_Config($this->schema);
 317         $config->set('Cake', 'Sprinkles', 42);
 318
 319         // test flat pass-through
 320         $created_config = HTMLPurifier_Config::create($config, $this->schema);
 321         $this->assertIdentical($config, $created_config);
 322
 323         // test loadArray
 324         $created_config = HTMLPurifier_Config::create(array('Cake.Sprinkles' => 42), $this->schema);
 325         $this->assertIdentical($config, $created_config);
 326
 327         // test loadIni
 328         $created_config = HTMLPurifier_Config::create(dirname(__FILE__) . '/ConfigTest-create.ini', $this->schema);
 329         $this->assertIdentical($config, $created_config);
 330
 331     }
 332
 333     function test_finalize() {
 334
 335         // test finalization
 336
 337         $this->schema->addNamespace('Poem');
 338         $this->schema->add('Poem', 'Meter', 'iambic', 'string', false);
 339
 340         $config = new HTMLPurifier_Config($this->schema);
 341         $config->autoFinalize = false;
 342
 343         $config->set('Poem', 'Meter', 'irregular');
 344
 345         $config->finalize();
 346
 347         $this->expectError('Cannot set directive after finalization');
 348         $config->set('Poem', 'Meter', 'vedic');
 349
 350         $this->expectError('Cannot load directives after finalization');
 351         $config->loadArray(array('Poem.Meter' => 'octosyllable'));
 352
 353         $this->expectError('Cannot load directives after finalization');
 354         $config->loadIni(dirname(__FILE__) . '/ConfigTest-finalize.ini');
 355
 356     }
 357
 358     function test_loadArrayFromForm() {
 359
 360         $this->schema->addNamespace('Pancake');
 361         $this->schema->add('Pancake', 'Mix', 'buttermilk', 'string', false);
 362         $this->schema->add('Pancake', 'Served', true, 'bool', false);
 363         $this->schema->addNamespace('Toppings', false);
 364         $this->schema->add('Toppings', 'Syrup', true, 'bool', false);
 365         $this->schema->add('Toppings', 'Flavor', 'maple', 'string', false);
 366         $this->schema->add('Toppings', 'Strawberries', 3, 'int', false);
 367         $this->schema->add('Toppings', 'Calories', 2000, 'int', true);
 368         $this->schema->add('Toppings', 'DefinitionID', null, 'string', true);
 369         $this->schema->add('Toppings', 'DefinitionRev', 1, 'int', false);
 370         $this->schema->add('Toppings', 'Protected', 1, 'int', false);
 371
 372         $get = array(
 373             'breakfast' => array(
 374                 'Pancake.Mix' => 'nasty',
 375                 'Pancake.Served' => '0',
 376                 'Toppings.Syrup' => '0',
 377                 'Toppings.Flavor' => "juice",
 378                 'Toppings.Strawberries' => '999',
 379                 'Toppings.Calories' => '',
 380                 'Null_Toppings.Calories' => '1',
 381                 'Toppings.DefinitionID' => '<argh>',
 382                 'Toppings.DefinitionRev' => '65',
 383                 'Toppings.Protected' => '4',
 384             )
 385         );
 386
 387         $config_expect = HTMLPurifier_Config::create(array(
 388             'Pancake.Served' => false,
 389             'Toppings.Syrup' => false,
 390             'Toppings.Flavor' => "juice",
 391             'Toppings.Strawberries' => 999,
 392             'Toppings.Calories' => null
 393         ), $this->schema);
 394
 395         $config_result = HTMLPurifier_Config::loadArrayFromForm(
 396             $get, 'breakfast',
 397             array('Pancake.Served', 'Toppings', '-Toppings.Protected'),
 398             false, // mq fix
 399             $this->schema
 400         );
 401
 402         $this->assertEqual($config_expect, $config_result);
 403
 404         /*
 405         MAGIC QUOTES NOT TESTED!!!
 406
 407         $get = array(
 408             'breakfast' => array(
 409                 'Pancake.Mix' => 'n\\asty'
 410             )
 411         );
 412         $config_expect = HTMLPurifier_Config::create(array(
 413             'Pancake.Mix' => 'n\\asty'
 414         ));
 415         $config_result = HTMLPurifier_Config::loadArrayFromForm($get, 'breakfast', true, false);
 416         $this->assertEqual($config_expect, $config_result);
 417         */
 418     }
 419
 420     function test_getAllowedDirectivesForForm() {
 421         $this->schema->addNamespace('Unused');
 422         $this->schema->add('Unused', 'Unused', 'Foobar', 'string', false);
 423         $this->schema->addNamespace('Partial');
 424         $this->schema->add('Partial', 'Allowed', true, 'bool', false);
 425         $this->schema->add('Partial', 'Unused', 'Foobar', 'string', false);
 426         $this->schema->addNamespace('All');
 427         $this->schema->add('All', 'Allowed', true, 'bool', false);
 428         $this->schema->add('All', 'Blacklisted', 'Foobar', 'string', false); // explicitly blacklisted
 429         $this->schema->add('All', 'DefinitionID', 'Foobar', 'string', true); // auto-blacklisted
 430         $this->schema->add('All', 'DefinitionRev', 2, 'int', false); // auto-blacklisted
 431
 432         $input = array('Partial.Allowed', 'All', '-All.Blacklisted');
 433         $output = HTMLPurifier_Config::getAllowedDirectivesForForm($input, $this->schema);
 434         $expect = array(
 435             array('Partial', 'Allowed'),
 436             array('All', 'Allowed')
 437         );
 438
 439         $this->assertEqual($output, $expect);
 440
 441     }
 442
 443 }
 444