tests/HTMLPurifier/DefinitionCache/SerializerTest.php

   1 <?php
   2
   3 class HTMLPurifier_DefinitionCache_SerializerTest extends HTMLPurifier_DefinitionCacheHarness
   4 {
   5
   6     function test() {
   7         // XXX SimpleTest does some really crazy stuff in the background
   8         // to do equality checks. Unfortunately, this makes some
   9         // versions of PHP segfault. So we need to define a better,
  10         // homebrew notion of equality and use that instead.  For now,
  11         // the identical asserts are commented out.
  12
  13         $cache = new HTMLPurifier_DefinitionCache_Serializer('Test');
  14
  15         $config = $this->generateConfigMock('serial');
  16         $config->setReturnValue('get', 2, array('Test.DefinitionRev'));
  17         $config->version = '1.0.0';
  18
  19         $config_md5   = '1.0.0,serial,2';
  20
  21         $file = realpath(
  22             $rel_file = HTMLPURIFIER_PREFIX . '/HTMLPurifier/DefinitionCache/Serializer/Test/' .
  23             $config_md5 . '.ser'
  24         );
  25         if($file && file_exists($file)) unlink($file); // prevent previous failures from causing problems
  26
  27         $this->assertIdentical($config_md5, $cache->generateKey($config));
  28
  29         $def_original = $this->generateDefinition();
  30
  31         $cache->add($def_original, $config);
  32         $this->assertFileExist($rel_file);
  33
  34         $file_generated = $cache->generateFilePath($config);
  35         $this->assertIdentical(realpath($rel_file), realpath($file_generated));
  36
  37         $def_1 = $cache->get($config);
  38         // $this->assertIdentical($def_original, $def_1);
  39
  40         $def_original->info_random = 'changed';
  41
  42         $cache->set($def_original, $config);
  43         $def_2 = $cache->get($config);
  44
  45         // $this->assertIdentical($def_original, $def_2);
  46         // $this->assertNotEqual ($def_original, $def_1);
  47
  48         $def_original->info_random = 'did it change?';
  49
  50         $this->assertFalse($cache->add($def_original, $config));
  51         $def_3 = $cache->get($config);
  52
  53         // $this->assertNotEqual ($def_original, $def_3); // did not change!
  54         // $this->assertIdentical($def_3, $def_2);
  55
  56         $cache->replace($def_original, $config);
  57         $def_4 = $cache->get($config);
  58         // $this->assertIdentical($def_original, $def_4);
  59
  60         $cache->remove($config);
  61         $this->assertFileNotExist($file);
  62
  63         $this->assertFalse($cache->replace($def_original, $config));
  64         $def_5 = $cache->get($config);
  65         $this->assertFalse($def_5);
  66
  67     }
  68
  69     function test_errors() {
  70         $cache = new HTMLPurifier_DefinitionCache_Serializer('Test');
  71         $def = $this->generateDefinition();
  72         $def->setup = true;
  73         $def->type = 'NotTest';
  74         $config = $this->generateConfigMock('testfoo');
  75
  76         $this->expectError('Cannot use definition of type NotTest in cache for Test');
  77         $cache->add($def, $config);
  78
  79         $this->expectError('Cannot use definition of type NotTest in cache for Test');
  80         $cache->set($def, $config);
  81
  82         $this->expectError('Cannot use definition of type NotTest in cache for Test');
  83         $cache->replace($def, $config);
  84     }
  85
  86     function test_flush() {
  87
  88         $cache = new HTMLPurifier_DefinitionCache_Serializer('Test');
  89
  90         $config1 = $this->generateConfigMock('test1');
  91         $config2 = $this->generateConfigMock('test2');
  92         $config3 = $this->generateConfigMock('test3');
  93
  94         $def1 = $this->generateDefinition(array('info_candles' => 1));
  95         $def2 = $this->generateDefinition(array('info_candles' => 2));
  96         $def3 = $this->generateDefinition(array('info_candles' => 3));
  97
  98         $cache->add($def1, $config1);
  99         $cache->add($def2, $config2);
 100         $cache->add($def3, $config3);
 101
 102         $this->assertEqual($def1, $cache->get($config1));
 103         $this->assertEqual($def2, $cache->get($config2));
 104         $this->assertEqual($def3, $cache->get($config3));
 105
 106         $cache->flush($config1); // only essential directive is %Cache.SerializerPath
 107
 108         $this->assertFalse($cache->get($config1));
 109         $this->assertFalse($cache->get($config2));
 110         $this->assertFalse($cache->get($config3));
 111
 112     }
 113
 114     function testCleanup() {
 115
 116         $cache = new HTMLPurifier_DefinitionCache_Serializer('Test');
 117
 118         // in order of age, oldest first
 119         // note that configurations are all identical, but version/revision
 120         // are different
 121
 122         $config1 = $this->generateConfigMock();
 123         $config1->version = '0.9.0';
 124         $config1->setReturnValue('get', 574, array('Test.DefinitionRev'));
 125         $def1 = $this->generateDefinition(array('info' => 1));
 126
 127         $config2 = $this->generateConfigMock();
 128         $config2->version = '1.0.0beta';
 129         $config2->setReturnValue('get', 1, array('Test.DefinitionRev'));
 130         $def2 = $this->generateDefinition(array('info' => 3));
 131
 132         $cache->set($def1, $config1);
 133         $cache->cleanup($config1);
 134         $this->assertEqual($def1, $cache->get($config1)); // no change
 135
 136         $cache->cleanup($config2);
 137         $this->assertFalse($cache->get($config1));
 138         $this->assertFalse($cache->get($config2));
 139
 140     }
 141
 142     function testCleanupOnlySameID() {
 143
 144         $cache = new HTMLPurifier_DefinitionCache_Serializer('Test');
 145
 146         $config1 = $this->generateConfigMock('serial1');
 147         $config1->version = '1.0.0';
 148         $config1->setReturnValue('get', 1, array('Test.DefinitionRev'));
 149         $def1 = $this->generateDefinition(array('info' => 1));
 150
 151         $config2 = $this->generateConfigMock('serial2');
 152         $config2->version = '1.0.0';
 153         $config2->setReturnValue('get', 34, array('Test.DefinitionRev'));
 154         $def2 = $this->generateDefinition(array('info' => 3));
 155
 156         $cache->set($def1, $config1);
 157         $cache->cleanup($config1);
 158         $this->assertEqual($def1, $cache->get($config1)); // no change
 159
 160         $cache->set($def2, $config2);
 161         $cache->cleanup($config2);
 162         $this->assertEqual($def1, $cache->get($config1));
 163         $this->assertEqual($def2, $cache->get($config2));
 164
 165         $cache->flush($config1);
 166     }
 167
 168     /**
 169      * Asserts that a file exists, ignoring the stat cache
 170      */
 171     function assertFileExist($file) {
 172         clearstatcache();
 173         $this->assertTrue(file_exists($file), 'Expected ' . $file . ' exists');
 174     }
 175
 176     /**
 177      * Asserts that a file does not exist, ignoring the stat cache
 178      */
 179     function assertFileNotExist($file) {
 180         clearstatcache();
 181         $this->assertFalse(file_exists($file), 'Expected ' . $file . ' does not exist');
 182     }
 183
 184     function testAlternatePath() {
 185
 186         $cache = new HTMLPurifier_DefinitionCache_Serializer('Test');
 187         $config = $this->generateConfigMock('serial');
 188         $config->version = '1.0.0';
 189         $config->setReturnValue('get', 1, array('Test.DefinitionRev'));
 190         $dir = dirname(__FILE__) . '/SerializerTest';
 191         $config->setReturnValue('get', $dir, array('Cache.SerializerPath'));
 192
 193         $def_original = $this->generateDefinition();
 194         $cache->add($def_original, $config);
 195         $this->assertFileExist($dir . '/Test/1.0.0,serial,1.ser');
 196
 197         unlink($dir . '/Test/1.0.0,serial,1.ser');
 198         rmdir( $dir . '/Test');
 199
 200     }
 201
 202     function testAlternatePermissions() {
 203
 204         $cache = new HTMLPurifier_DefinitionCache_Serializer('Test');
 205         $config = $this->generateConfigMock('serial');
 206         $config->version = '1.0.0';
 207         $config->setReturnValue('get', 1, array('Test.DefinitionRev'));
 208         $dir = dirname(__FILE__) . '/SerializerTest';
 209         $config->setReturnValue('get', $dir, array('Cache.SerializerPath'));
 210         $config->setReturnValue('get', 0777, array('Cache.SerializerPermissions'));
 211
 212         $def_original = $this->generateDefinition();
 213         $cache->add($def_original, $config);
 214         $this->assertFileExist($dir . '/Test/1.0.0,serial,1.ser');
 215
 216         $this->assertEqual(0666, 0777 & fileperms($dir . '/Test/1.0.0,serial,1.ser'));
 217         $this->assertEqual(0777, 0777 & fileperms($dir . '/Test'));
 218
 219         unlink($dir . '/Test/1.0.0,serial,1.ser');
 220         rmdir( $dir . '/Test');
 221
 222     }
 223 }
 224
 225 // vim: et sw=4 sts=4