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