Newer
Older
catch
committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
<?php
class MemcacheTestCase extends DrupalWebTestCase {
protected $default_bin = 'cache';
protected $default_cid = 'test_temporary';
protected $default_value = 'MemcacheTest';
function setUp() {
parent::setUp();
}
/**
* Check whether or not a cache entry exists.
*
* @param $cid
* The cache id.
* @param $var
* The variable the cache should contain.
* @param $bin
* The bin the cache item was stored in.
* @return
* TRUE on pass, FALSE on fail.
*/
protected function checkCacheExists($cid, $var, $bin = NULL) {
if ($bin == NULL) {
$bin = $this->default_bin;
}
$cache = cache_get($cid, $bin);
return isset($cache->data) && $cache->data == $var;
}
/**
* Assert or a cache entry exists.
*
* @param $message
* Message to display.
* @param $var
* The variable the cache should contain.
* @param $cid
* The cache id.
* @param $bin
* The bin the cache item was stored in.
*/
protected function assertCacheExists($message, $var = NULL, $cid = NULL, $bin = NULL) {
if ($bin == NULL) {
$bin = $this->default_bin;
}
if ($cid == NULL) {
$cid = $this->default_cid;
}
if ($var == NULL) {
$var = $this->default_value;
}
$this->assertTrue($this->checkCacheExists($cid, $var, $bin), $message);
}
/**
* Assert or a cache entry has been removed.
*
* @param $message
* Message to display.
* @param $cid
* The cache id.
* @param $bin
* The bin the cache item was stored in.
*/
function assertCacheRemoved($message, $cid = NULL, $bin = NULL) {
if ($bin == NULL) {
$bin = $this->default_bin;
}
if ($cid == NULL) {
$cid = $this->default_cid;
}
$cache = cache_get($cid, $bin);
$this->assertFalse($cache, $message);
}
/**
* Perform the general wipe.
* @param $bin
* The bin to perform the wipe on.
*/
protected function generalWipe($bin = NULL) {
if ($bin == NULL) {
$bin = $this->default_bin;
}
cache_clear_all(NULL, $bin);
}
/**
* Setup the lifetime settings for caching.
*
* @param $time
* The time in seconds the cache should minimal live.
*/
protected function setupLifetime($time) {
variable_set('cache_lifetime', $time);
variable_set('cache_flush', 0);
}
}
class MemCacheSavingCase extends MemcacheTestCase {
public static function getInfo() {
return array(
'name' => 'Memcache saving test',
'description' => 'Check our variables are saved and restored the right way.',
'group' => 'Memcache'
);
}
function setUp() {
parent::setUp();
variable_set("cache_flush_cache", 0);
}
/**
* Test the saving and restoring of a string.
*/
function testString() {
$this->checkVariable($this->randomName(100));
}
/**
* Test the saving and restoring of an integer.
*/
function testInteger() {
$this->checkVariable(100);
}
/**
* Test the saving and restoring of a double.
*/
function testDouble() {
$this->checkVariable(1.29);
}
/**
* Test the saving and restoring of an array.
*/
function testArray() {
$this->checkVariable(array('drupal1', 'drupal2' => 'drupal3', 'drupal4' => array('drupal5', 'drupal6')));
}
/**
* Test the saving and restoring of an object.
*/
function testObject() {
$test_object = new stdClass();
$test_object->test1 = $this->randomName(100);
$test_object->test2 = 100;
$test_object->test3 = array('drupal1', 'drupal2' => 'drupal3', 'drupal4' => array('drupal5', 'drupal6'));
cache_set('test_object', $test_object, 'cache');
$cache = cache_get('test_object', 'cache');
$this->assertTrue(isset($cache->data) && $cache->data == $test_object, t('Object is saved and restored properly.'));
}
/*
* Check or a variable is stored and restored properly.
**/
function checkVariable($var) {
cache_set('test_var', $var, 'cache');
$cache = cache_get('test_var', 'cache');
$this->assertTrue(isset($cache->data) && $cache->data === $var, t('@type is saved and restored properly.', array('@type' => ucfirst(gettype($var)))));
}
}
/**
* Test cache_get_multiple().
*/
class MemCacheGetMultipleUnitTest extends MemcacheTestCase {
public static function getInfo() {
return array(
'name' => 'Fetching multiple cache items',
'description' => 'Confirm that multiple records are fetched correctly.',
'group' => 'Memcache',
);
}
function setUp() {
$this->default_bin = 'cache_page';
parent::setUp();
}
/**
* Test cache_get_multiple().
*/
function testCacheMultiple() {
$item1 = $this->randomName(10);
$item2 = $this->randomName(10);
cache_set('item1', $item1, $this->default_bin);
cache_set('item2', $item2, $this->default_bin);
$this->assertTrue($this->checkCacheExists('item1', $item1), t('Item 1 is cached.'));
$this->assertTrue($this->checkCacheExists('item2', $item2), t('Item 2 is cached.'));
// Fetch both records from the database with cache_get_multiple().
$item_ids = array('item1', 'item2');
$items = cache_get_multiple($item_ids, $this->default_bin);
$this->assertEqual($items['item1']->data, $item1, t('Item was returned from cache successfully.'));
$this->assertEqual($items['item2']->data, $item2, t('Item was returned from cache successfully.'));
// Remove one item from the cache.
cache_clear_all('item2', $this->default_bin);
// Confirm that only one item is returned by cache_get_multiple().
$item_ids = array('item1', 'item2');
$items = cache_get_multiple($item_ids, $this->default_bin);
$this->assertEqual($items['item1']->data, $item1, t('Item was returned from cache successfully.'));
$this->assertFalse(isset($items['item2']), t('Item was not returned from the cache.'));
$this->assertTrue(count($items) == 1, t('Only valid cache entries returned.'));
}
}
/**
* Test cache clearing methods.
*/
class MemCacheClearCase extends MemcacheTestCase {
public static function getInfo() {
return array(
'name' => 'Cache clear test',
'description' => 'Check our clearing is done the proper way.',
'group' => 'Memcache'
);
}
function setUp() {
$this->default_bin = 'cache_page';
$this->default_value = $this->randomName(10);
parent::setUp();
}
/**
* Test clearing the cache with a cid, no cache lifetime.
*/
function testClearCidNoLifetime() {
$this->clearCidTest();
}
/**
* Test clearing the cache with a cid, with cache lifetime.
*/
function testClearCidLifetime() {
variable_set('cache_lifetime', 6000);
$this->clearCidTest();
}
/**
* Test clearing using wildcard prefixes, no cache lifetime.
*/
function testClearWildcardNoLifetime() {
$this->clearWildcardPrefixTest();
}
/**
* Test clearing using wildcard prefix, with cache lifetime.
*/
function testClearWildcardLifetime() {
variable_set('cache_lifetime', 6000);
$this->clearWildcardPrefixTest();
}
/**
* Test full bin flushes with no cache lifetime.
*/
function testClearWildcardFull() {
variable_set("cache_flush_$this->default_bin", 0);
cache_set('test_cid_clear1', $this->default_value, $this->default_bin);
cache_set('test_cid_clear2', $this->default_value, $this->default_bin);
$this->assertTrue($this->checkCacheExists('test_cid_clear1', $this->default_value)
&& $this->checkCacheExists('test_cid_clear2', $this->default_value),
t('Two caches were created for checking cid "*" with wildcard true.'));
cache_clear_all('*', $this->default_bin, TRUE);
$this->assertFalse($this->checkCacheExists('test_cid_clear1', $this->default_value)
|| $this->checkCacheExists('test_cid_clear2', $this->default_value),
t('Two caches removed after clearing cid "*" with wildcard true.'));
}
/**
* Test full bin flushes with cache lifetime.
*/
function testClearCacheLifetime() {
variable_set("cache_flush_$this->default_bin", 0);
variable_set('cache_lifetime', 600);
// Set a cache item with an expiry.
cache_set('test_cid', $this->default_value, $this->default_bin, time() + 3600);
$this->assertTrue($this->checkCacheExists('test_cid', $this->default_value), 'Cache item was created successfully.');
// Set a permanent cache item.
cache_set('test_cid_2', $this->default_value, $this->default_bin);
// Clear the page and block caches.
cache_clear_all();
// Since the cache was cleared within the current session, cache_get()
// should return false.
$this->assertFalse($this->checkCacheExists('test_cid', $this->default_value), 'Cache item was cleared successfully.');
// However permament items should stay in place.
$this->assertTrue($this->checkCacheExists('test_cid_2', $this->default_value), 'Cache item was not cleared');
// If $_SESSION['cache_flush'] is not set, then the expired item should be returned.
unset($_SESSION['cache_flush']);
$this->assertTrue($this->checkCacheExists('test_cid', $this->default_value), 'Cache item is still returned due to minimum cache lifetime.');
// Set a much shorter cache lifetime.
variable_set('cache_content_flush_' . $this->default_bin, 0);
variable_set('cache_lifetime', 1);
cache_set('test_cid_1', $this->default_value, $this->default_bin, time() + 6000);
$this->assertTrue($this->checkCacheExists('test_cid', $this->default_value), 'Cache item was created successfully.');
sleep(2);
cache_clear_all();
$this->assertFalse($this->checkCacheExists('test_cid', $this->default_value), 'Cache item is not returned once minimum cache lifetime has expired.');
// Reset the cache clear variables.
variable_set('cache_content_flush_' . $this->default_bin, 0);
variable_set('cache_lifetime', 6000);
sleep(1);
// Confirm that cache_lifetime does not take effect for full bin flushes.
cache_set('test_cid', $this->default_value, $this->default_bin, time() + 6000);
$this->assertTrue($this->checkCacheExists('test_cid', $this->default_value), 'Cache item was created successfully.');
cache_set('test_cid_2', $this->default_value, $this->default_bin);
$this->assertTrue($this->checkCacheExists('test_cid_2', $this->default_value), 'Cache item was created successfully.');
// Now flush the bin.
cache_clear_all('*', $this->default_bin, TRUE);
$this->assertFalse($this->checkCacheExists('test_cid', $this->default_value), 'Cache item was cleared successfully.');
$this->assertFalse($this->checkCacheExists('test_cid_2', $this->default_value), 'Cache item was cleared successfully.');
}
/**
* Test clearing using a cid.
*/
function clearCidTest() {
variable_set("cache_flush_$this->default_bin", 0);
cache_set('test_cid_clear', $this->default_value, $this->default_bin);
$this->assertCacheExists(t('Cache was set for clearing cid.'), $this->default_value, 'test_cid_clear');
cache_clear_all('test_cid_clear', $this->default_bin);
$this->assertCacheRemoved(t('Cache was removed after clearing cid.'), 'test_cid_clear');
cache_set('test_cid_clear1', $this->default_value, $this->default_bin);
cache_set('test_cid_clear2', $this->default_value, $this->default_bin);
$this->assertTrue($this->checkCacheExists('test_cid_clear1', $this->default_value)
&& $this->checkCacheExists('test_cid_clear2', $this->default_value),
t('Two caches were created for checking cid "*" with wildcard false.'));
cache_clear_all('*', $this->default_bin);
$this->assertTrue($this->checkCacheExists('test_cid_clear1', $this->default_value)
&& $this->checkCacheExists('test_cid_clear2', $this->default_value),
t('Two caches still exists after clearing cid "*" with wildcard false.'));
}
/**
* Test cache clears using wildcard prefixes.
*/
function clearWildcardPrefixTest() {
variable_set("cache_flush_$this->default_bin", 0);
cache_set('test_cid_clear1', $this->default_value, $this->default_bin);
cache_set('test_cid_clear2', $this->default_value, $this->default_bin);
$this->assertTrue($this->checkCacheExists('test_cid_clear1', $this->default_value)
&& $this->checkCacheExists('test_cid_clear2', $this->default_value),
t('Two caches were created for checking cid substring with wildcard true.'));
cache_clear_all('test_', $this->default_bin, TRUE);
$this->assertFalse($this->checkCacheExists('test_cid_clear1', $this->default_value)
|| $this->checkCacheExists('test_cid_clear2', $this->default_value),
t('Two caches removed after clearing cid substring with wildcard true.'));
// Test for the case where a wildcard object disappears, for example a
// partial memcache restart or eviction.
cache_set('test_cid_clear1', $this->default_value, $this->default_bin);
$this->assertTrue($this->checkCacheExists('test_cid_clear1', $this->default_value), 'The cache was created successfully.');
cache_clear_all('test_', $this->default_bin, TRUE);
$this->assertFalse($this->checkCacheExists('test_cid_clear1', $this->default_value), 'The cache was cleared successfully.');
// Delete the wildcard manually to simulate an eviction.
$wildcard = '.wildcard-' . 'test_';
dmemcache_delete($wildcard, $this->default_bin);
// Reset the memcache_wildcards() static cache.
// @todo: this is a class object in D7.
//memcache_wildcards(FALSE, FALSE, FALSE, TRUE);
$this->assertFalse($this->checkCacheExists('test_cid_clear1', $this->default_value), 'The cache was cleared successfully.');
}
}