tests/HTMLPurifier/ConfigTest.php

   1 <?php
   2
   3 require_once 'HTMLPurifier/Config.php';
   4
   5 class HTMLPurifier_ConfigTest extends UnitTestCase
   6 {
   7
   8     var $our_copy, $old_copy;
   9
  10     function setUp() {
  11         // set up a dummy schema object for testing
  12         $our_copy = new HTMLPurifier_ConfigSchema();
  13         $this->old_copy = HTMLPurifier_ConfigSchema::instance();
  14         $this->our_copy =& HTMLPurifier_ConfigSchema::instance($our_copy);
  15     }
  16
  17     function tearDown() {
  18         HTMLPurifier_ConfigSchema::instance($this->old_copy);
  19     }
  20
  21     function test() {
  22
  23         HTMLPurifier_ConfigSchema::defineNamespace('Core', 'Corestuff');
  24         HTMLPurifier_ConfigSchema::defineNamespace('Attr', 'Attributes');
  25         HTMLPurifier_ConfigSchema::defineNamespace('Extension', 'Extensible');
  26
  27         HTMLPurifier_ConfigSchema::define(
  28             'Core', 'Key', false, 'bool', 'A boolean directive.'
  29         );
  30         HTMLPurifier_ConfigSchema::define(
  31             'Attr', 'Key', 42, 'int', 'An integer directive.'
  32         );
  33         HTMLPurifier_ConfigSchema::define(
  34             'Extension', 'Pert', 'foo', 'string', 'A string directive.'
  35         );
  36         HTMLPurifier_ConfigSchema::define(
  37             'Core', 'Encoding', 'utf-8', 'istring', 'Case insensitivity!'
  38         );
  39
  40         HTMLPurifier_ConfigSchema::define(
  41             'Extension', 'CanBeNull', null, 'string/null', 'Null or string!'
  42         );
  43
  44         HTMLPurifier_ConfigSchema::defineAllowedValues(
  45             'Extension', 'Pert', array('foo', 'moo')
  46         );
  47         HTMLPurifier_ConfigSchema::defineValueAliases(
  48             'Extension', 'Pert', array('cow' => 'moo')
  49         );
  50         HTMLPurifier_ConfigSchema::defineAllowedValues(
  51             'Core', 'Encoding', array('utf-8', 'iso-8859-1')
  52         );
  53
  54         $config = HTMLPurifier_Config::createDefault();
  55
  56         // test default value retrieval
  57         $this->assertIdentical($config->get('Core', 'Key'), false);
  58         $this->assertIdentical($config->get('Attr', 'Key'), 42);
  59         $this->assertIdentical($config->get('Extension', 'Pert'), 'foo');
  60
  61         // set some values
  62         $config->set('Core', 'Key', true);
  63         $this->assertIdentical($config->get('Core', 'Key'), true);
  64
  65         // try to retrieve undefined value
  66         $config->get('Core', 'NotDefined');
  67         $this->assertError('Cannot retrieve value of undefined directive');
  68         $this->assertNoErrors();
  69
  70         // try to set undefined value
  71         $config->set('Foobar', 'Key', 'foobar');
  72         $this->assertError('Cannot set undefined directive to value');
  73         $this->assertNoErrors();
  74
  75         // try to set not allowed value
  76         $config->set('Extension', 'Pert', 'wizard');
  77         $this->assertError('Value not supported');
  78         $this->assertNoErrors();
  79
  80         // try to set not allowed value
  81         $config->set('Extension', 'Pert', 34);
  82         $this->assertError('Value is of invalid type');
  83         $this->assertNoErrors();
  84
  85         // set aliased value
  86         $config->set('Extension', 'Pert', 'cow');
  87         $this->assertNoErrors();
  88         $this->assertIdentical($config->get('Extension', 'Pert'), 'moo');
  89
  90         // case-insensitive attempt to set value that is allowed
  91         $config->set('Core', 'Encoding', 'ISO-8859-1');
  92         $this->assertNoErrors();
  93         $this->assertIdentical($config->get('Core', 'Encoding'), 'iso-8859-1');
  94
  95         // set null to directive that allows null
  96         $config->set('Extension', 'CanBeNull', null);
  97         $this->assertNoErrors();
  98         $this->assertIdentical($config->get('Extension', 'CanBeNull'), null);
  99
 100         $config->set('Extension', 'CanBeNull', 'foobar');
 101         $this->assertNoErrors();
 102         $this->assertIdentical($config->get('Extension', 'CanBeNull'), 'foobar');
 103
 104         // set null to directive that doesn't allow null
 105         $config->set('Extension', 'Pert', null);
 106         $this->assertError('Value is of invalid type');
 107         $this->assertNoErrors();
 108
 109         // grab a namespace
 110         $config->set('Attr', 'Key', 0xBEEF);
 111         $this->assertIdentical(
 112             $config->getBatch('Attr'),
 113             array(
 114                 'Key' => 0xBEEF
 115             )
 116         );
 117
 118         // grab a non-existant namespace
 119         $config->getBatch('FurnishedGoods');
 120         $this->assertError('Cannot retrieve undefined namespace');
 121         $this->assertNoErrors();
 122
 123     }
 124
 125     function test_getDefinition() {
 126
 127         // we actually want to use the old copy, because the definition
 128         // generation routines have dependencies on configuration values
 129
 130         $this->old_copy = HTMLPurifier_ConfigSchema::instance($this->old_copy);
 131
 132         $config = HTMLPurifier_Config::createDefault();
 133         $def = $config->getHTMLDefinition();
 134         $this->assertIsA($def, 'HTMLPurifier_HTMLDefinition');
 135
 136         $def = $config->getCSSDefinition();
 137         $this->assertIsA($def, 'HTMLPurifier_CSSDefinition');
 138
 139     }
 140
 141     function test_loadArray() {
 142         // setup a few dummy namespaces/directives for our testing
 143         HTMLPurifier_ConfigSchema::defineNamespace('Zoo', 'Animals we have.');
 144         HTMLPurifier_ConfigSchema::define('Zoo', 'Aadvark', 0, 'int', 'Have?');
 145         HTMLPurifier_ConfigSchema::define('Zoo', 'Boar',    0, 'int', 'Have?');
 146         HTMLPurifier_ConfigSchema::define('Zoo', 'Camel',   0, 'int', 'Have?');
 147         HTMLPurifier_ConfigSchema::define(
 148             'Zoo', 'Others', array(), 'list', 'Other animals we have one of.'
 149         );
 150
 151         $config_manual = HTMLPurifier_Config::createDefault();
 152         $config_loadabbr = HTMLPurifier_Config::createDefault();
 153         $config_loadfull = HTMLPurifier_Config::createDefault();
 154
 155         $config_manual->set('Zoo', 'Aadvark', 3);
 156         $config_manual->set('Zoo', 'Boar', 5);
 157         $config_manual->set('Zoo', 'Camel', 2000); // that's a lotta camels!
 158         $config_manual->set('Zoo', 'Others', array('Peacock', 'Dodo')); // wtf!
 159
 160         // condensed form
 161         $config_loadabbr->loadArray(array(
 162             'Zoo.Aadvark' => 3,
 163             'Zoo.Boar' => 5,
 164             'Zoo.Camel' => 2000,
 165             'Zoo.Others' => array('Peacock', 'Dodo')
 166         ));
 167
 168         // fully expanded form
 169         $config_loadfull->loadArray(array(
 170             'Zoo' => array(
 171                 'Aadvark' => 3,
 172                 'Boar' => 5,
 173                 'Camel' => 2000,
 174                 'Others' => array('Peacock', 'Dodo')
 175             )
 176         ));
 177
 178         $this->assertEqual($config_manual, $config_loadabbr);
 179         $this->assertEqual($config_manual, $config_loadfull);
 180
 181     }
 182
 183     function test_create() {
 184
 185         HTMLPurifier_ConfigSchema::defineNamespace('Cake', 'Properties of it.');
 186         HTMLPurifier_ConfigSchema::define('Cake', 'Sprinkles', 666, 'int', 'Number of.');
 187         HTMLPurifier_ConfigSchema::define('Cake', 'Flavor', 'vanilla', 'string', 'Flavor of the batter.');
 188
 189         $config = HTMLPurifier_Config::createDefault();
 190         $config->set('Cake', 'Sprinkles', 42);
 191
 192         // test flat pass-through
 193         $created_config = HTMLPurifier_Config::create($config);
 194         $this->assertEqual($config, $created_config);
 195
 196         // test loadArray
 197         $created_config = HTMLPurifier_Config::create(array('Cake.Sprinkles' => 42));
 198         $this->assertEqual($config, $created_config);
 199
 200     }
 201
 202 }
 203
 204 ?>