tests/HTMLPurifier/DefinitionCache/SerializerTest.php

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