tests/HTMLPurifier/DefinitionCache/SerializerTest.php

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