← Back to branch summary

~clinton-collins/familyproject/trunk

« back to all changes in this revision

Viewing changes to ZendFramework/tests/Zend/Cache/CoreTest.php

  • Committer: Clinton Collins
  • Date: 2009-06-26 19:54:58 UTC
  • Revision ID: clinton.collins@gmail.com-20090626195458-5ebba0qcvo15xlpy
Initial Import

Show diffs side-by-side

added added

removed removed

Lines of Context:
ZendFramework/tests/Zend/Cache/CoreTest.php
 
1
<?php
 
2
/**
 
3
 * @package    Zend_Cache
 
4
 * @subpackage UnitTests
 
5
 */
 
6
 
 
7
 /**
 
8
 * Zend_Cache
 
9
 */
 
10
require_once 'Zend/Cache.php';
 
11
require_once 'Zend/Cache/Core.php';
 
12
require_once 'Zend/Cache/Backend/File.php'; // TODO : use only Test backend ?
 
13
require_once 'Zend/Cache/Backend/Test.php';
 
14
 
 
15
/**
 
16
 * PHPUnit test case
 
17
 */
 
18
require_once 'PHPUnit/Framework/TestCase.php';
 
19
 
 
20
/**
 
21
 * @package    Zend_Cache
 
22
 * @subpackage UnitTests
 
23
 */
 
24
class Zend_Cache_CoreTest extends PHPUnit_Framework_TestCase 
 
25
{
 
26
    private $_instance;
 
27
 
 
28
    public function setUp()
 
29
    {
 
30
        if (!$this->_instance) {
 
31
            $this->_instance = new Zend_Cache_Core(array());
 
32
            $this->_backend = new Zend_Cache_Backend_Test();
 
33
            $this->_instance->setBackend($this->_backend);
 
34
        }
 
35
    }
 
36
 
 
37
    public function tearDown()
 
38
    {
 
39
        unset($this->_instance);
 
40
    }
 
41
 
 
42
    public function testConstructorCorrectCall()
 
43
    {
 
44
        $test = new Zend_Cache_Core(array('lifetime' => 3600, 'caching' => true));
 
45
    }
 
46
 
 
47
    public function testConstructorBadOption()
 
48
    {
 
49
        try {
 
50
            $test = new Zend_Cache_Core(array(0 => 'bar', 'lifetime' => 3600));
 
51
        } catch (Zend_Cache_Exception $e) {
 
52
            return;
 
53
        }
 
54
        $this->fail('Zend_Cache_Exception was expected but not thrown');
 
55
    }
 
56
 
 
57
    public function testSetLifeTime()
 
58
    {
 
59
        $this->_instance->setLifeTime(3600);
 
60
    }
 
61
 
 
62
    public function testSetBackendCorrectCall1()
 
63
    {
 
64
        $backend = new Zend_Cache_Backend_File(array());
 
65
        $this->_instance->setBackend($backend);
 
66
    }
 
67
 
 
68
    public function testSetBackendCorrectCall2()
 
69
    {
 
70
        $backend = new Zend_Cache_Backend_Test(array());
 
71
        $this->_instance->setBackend($backend);
 
72
        $log = $backend->getLastLog();
 
73
        $this->assertEquals('setDirectives', $log['methodName']);
 
74
        $this->assertType('array', $log['args'][0]);
 
75
    }
 
76
 
 
77
    public function testSetOptionCorrectCall()
 
78
    {
 
79
        $this->_instance->setOption('caching', false);
 
80
    }
 
81
 
 
82
    public function testSetOptionBadCall()
 
83
    {
 
84
        try {
 
85
            $this->_instance->setOption(array('lifetime'), 1200);
 
86
        } catch (Zend_Cache_Exception $e) {
 
87
            return;
 
88
        }
 
89
        $this->fail('Zend_Cache_Exception was expected but not thrown');
 
90
    }
 
91
 
 
92
    /**
 
93
     * Unknown options are okay and should be silently ignored. Non-string 
 
94
     * options, however, should throw exceptions.
 
95
     *
 
96
     * @group ZF-5034
 
97
     */
 
98
    public function testSetOptionUnknownOption()
 
99
    {
 
100
        try {
 
101
            $this->_instance->setOption(0, 1200);
 
102
            $this->fail('Zend_Cache_Exception was expected but not thrown');
 
103
        } catch (Zend_Cache_Exception $e) {
 
104
        }
 
105
 
 
106
        try {
 
107
            $this->_instance->setOption('foo', 1200);
 
108
        } catch (Zend_Cache_Exception $e) {
 
109
            $this->fail('Zend_Cache_Exception was thrown but should not have been');
 
110
        }
 
111
    }
 
112
 
 
113
    public function testSaveCorrectBadCall1()
 
114
    {
 
115
        try {
 
116
            $this->_instance->save('data', 'foo bar');
 
117
        }  catch (Zend_Cache_Exception $e) {
 
118
            return;
 
119
        }
 
120
        $this->fail('Zend_Cache_Exception was expected but not thrown');
 
121
    }
 
122
 
 
123
    public function testSaveCorrectBadCall2()
 
124
    {
 
125
        try {
 
126
            $this->_instance->save('data', 'foobar', array('tag1', 'foo bar'));
 
127
        }  catch (Zend_Cache_Exception $e) {
 
128
            return;
 
129
        }
 
130
        $this->fail('Zend_Cache_Exception was expected but not thrown');
 
131
    }
 
132
 
 
133
    public function testSaveCorrectBadCall3()
 
134
    {
 
135
        try {
 
136
            $this->_instance->save(array('data'), 'foobar');
 
137
        }  catch (Zend_Cache_Exception $e) {
 
138
            return;
 
139
        }
 
140
        $this->fail('Zend_Cache_Exception was expected but not thrown');
 
141
    }
 
142
 
 
143
    public function testSaveWithABadCacheId()
 
144
    {
 
145
        try {
 
146
            $this->_instance->save(array('data'), true);
 
147
        }  catch (Zend_Cache_Exception $e) {
 
148
            return;
 
149
        }
 
150
        $this->fail('Zend_Cache_Exception was expected but not thrown');
 
151
    }
 
152
 
 
153
    public function testSaveWithABadCacheId2()
 
154
    {
 
155
        try {
 
156
            $this->_instance->save(array('data'), 'internal_foo');
 
157
        }  catch (Zend_Cache_Exception $e) {
 
158
            return;
 
159
        }
 
160
        $this->fail('Zend_Cache_Exception was expected but not thrown');
 
161
    }
 
162
 
 
163
    public function testSaveWithABadTags()
 
164
    {
 
165
        try {
 
166
            $this->_instance->save(array('data'), 'foo', 'foobar');
 
167
        }  catch (Zend_Cache_Exception $e) {
 
168
            return;
 
169
        }
 
170
        $this->fail('Zend_Cache_Exception was expected but not thrown');
 
171
    }
 
172
 
 
173
    public function testSaveCorrectCallNoCaching()
 
174
    {
 
175
        $i1 = $this->_backend->getLogIndex();
 
176
        $this->_instance->setOption('caching', false);
 
177
        $res = $this->_instance->save('data', 'foo');
 
178
        $i2 = $this->_backend->getLogIndex();
 
179
        $this->assertTrue($res);
 
180
        $this->assertEquals($i1, $i2);
 
181
    }
 
182
 
 
183
    public function testSaveCorrectCallNoWriteControl()
 
184
    {
 
185
        $this->_instance->setOption('write_control', false);
 
186
        $res = $this->_instance->save('data', 'foo', array('tag1', 'tag2'));
 
187
        $log = $this->_backend->getLastLog();
 
188
        $expected = array(
 
189
            'methodName' => 'save',
 
190
            'args' => array(
 
191
                0 => 'data',
 
192
                1 => 'foo',
 
193
                2 => array(
 
194
                    0 => 'tag1',
 
195
                    1 => 'tag2'
 
196
                )
 
197
            )
 
198
        );
 
199
        $this->assertEquals($expected, $log);
 
200
    }
 
201
 
 
202
    public function testSaveCorrectCall()
 
203
    {
 
204
        $res = $this->_instance->save('data', 'foo', array('tag1', 'tag2'));
 
205
        $logs = $this->_backend->getAllLogs();
 
206
        $expected1 = array(
 
207
            'methodName' => 'save',
 
208
            'args' => array(
 
209
                0 => 'data',
 
210
                1 => 'foo',
 
211
                2 => array(
 
212
                    0 => 'tag1',
 
213
                    1 => 'tag2'
 
214
                )
 
215
            )
 
216
        );
 
217
        $expected2 = array(
 
218
            'methodName' => 'get',
 
219
            'args' => array(
 
220
                0 => 'foo',
 
221
                1 => true
 
222
            )
 
223
        );
 
224
        $expected3 = array(
 
225
            'methodName' => 'remove',
 
226
            'args' => array(
 
227
                0 => 'foo'
 
228
            )
 
229
        );
 
230
        $this->assertFalse($res);
 
231
        $this->assertEquals($expected1, $logs[count($logs) - 3]);
 
232
        $this->assertEquals($expected2, $logs[count($logs) - 2]);
 
233
        $this->assertEquals($expected3, $logs[count($logs) - 1]);
 
234
    }
 
235
 
 
236
    public function testSaveCorrectCallButFileCorruption()
 
237
    {
 
238
        $res = $this->_instance->save('data', 'false', array('tag1', 'tag2'));
 
239
        $logs = $this->_backend->getAllLogs();
 
240
        $expected1 = array(
 
241
            'methodName' => 'save',
 
242
            'args' => array(
 
243
                0 => 'data',
 
244
                1 => 'false',
 
245
                2 => array(
 
246
                    0 => 'tag1',
 
247
                    1 => 'tag2'
 
248
                )
 
249
            )
 
250
        );
 
251
        $expected2 = array(
 
252
            'methodName' => 'remove',
 
253
            'args' => array(
 
254
                0 => 'false'
 
255
            )
 
256
        );
 
257
        $this->assertFalse($res);
 
258
        $this->assertEquals($expected1, $logs[count($logs) - 2]);
 
259
        $this->assertEquals($expected2, $logs[count($logs) - 1]);
 
260
    }
 
261
 
 
262
    public function testSaveCorrectCallWithAutomaticCleaning()
 
263
    {
 
264
        $this->_instance->setOption('automatic_cleaning_factor', 1);
 
265
        $res = $this->_instance->save('data', 'false', array('tag1', 'tag2'));
 
266
        $logs = $this->_backend->getAllLogs();
 
267
        $expected = array(
 
268
            'methodName' => 'clean',
 
269
            'args' => array(
 
270
                0 => 'old',
 
271
                1 => array()
 
272
            )
 
273
        );
 
274
        $this->assertFalse($res);
 
275
        $this->assertEquals($expected, $logs[count($logs) - 3]);
 
276
    }
 
277
 
 
278
    public function testTestCorrectCallNoCaching()
 
279
    {
 
280
        $i1 = $this->_backend->getLogIndex();
 
281
        $this->_instance->setOption('caching', false);
 
282
        $res = $this->_instance->test('foo');
 
283
        $i2 = $this->_backend->getLogIndex();
 
284
        $this->assertFalse($res);
 
285
        $this->assertEquals($i1, $i2);
 
286
    }
 
287
 
 
288
    public function testTestBadCall()
 
289
    {
 
290
        try {
 
291
            $this->_instance->test('foo bar');
 
292
        }  catch (Zend_Cache_Exception $e) {
 
293
            return;
 
294
        }
 
295
        $this->fail('Zend_Cache_Exception was expected but not thrown');
 
296
    }
 
297
 
 
298
    public function testTestCorrectCall1()
 
299
    {
 
300
         $res = $this->_instance->test('foo');
 
301
         $log = $this->_backend->getLastLog();
 
302
         $expected = array(
 
303
            'methodName' => 'test',
 
304
            'args' => array(
 
305
                0 => 'foo'
 
306
            )
 
307
         );
 
308
         $this->assertEquals(123456, $res);
 
309
         $this->assertEquals($expected, $log);
 
310
    }
 
311
 
 
312
    public function testTestCorrectCall2()
 
313
    {
 
314
         $res = $this->_instance->test('false');
 
315
         $this->assertFalse($res);
 
316
    }
 
317
 
 
318
    public function testGetCorrectCallNoCaching()
 
319
    {
 
320
        $i1 = $this->_backend->getLogIndex();
 
321
        $this->_instance->setOption('caching', false);
 
322
        $res = $this->_instance->load('foo');
 
323
        $i2 = $this->_backend->getLogIndex();
 
324
        $this->assertFalse($res);
 
325
        $this->assertEquals($i1, $i2);
 
326
    }
 
327
 
 
328
    public function testGetBadCall()
 
329
    {
 
330
        try {
 
331
            $res = $this->_instance->load('foo bar');
 
332
        }  catch (Zend_Cache_Exception $e) {
 
333
            return;
 
334
        }
 
335
        $this->fail('Zend_Cache_Exception was expected but not thrown');
 
336
    }
 
337
 
 
338
    public function testGetCorrectCall1()
 
339
    {
 
340
        $res = $this->_instance->load('false');
 
341
        $this->assertFalse($res);
 
342
    }
 
343
 
 
344
    public function testGetCorrectCall2()
 
345
    {
 
346
        $res = $this->_instance->load('bar');
 
347
        $this->assertEquals('foo', 'foo');
 
348
    }
 
349
 
 
350
    public function testGetCorrectCallWithAutomaticSerialization()
 
351
    {
 
352
        $this->_instance->setOption('automatic_serialization', true);
 
353
        $res = $this->_instance->load('serialized');
 
354
        $this->assertEquals(array('foo'), $res);
 
355
    }
 
356
 
 
357
    public function testRemoveBadCall()
 
358
    {
 
359
        try {
 
360
            $res = $this->_instance->remove('foo bar');
 
361
        }  catch (Zend_Cache_Exception $e) {
 
362
            return;
 
363
        }
 
364
        $this->fail('Zend_Cache_Exception was expected but not thrown');
 
365
    }
 
366
 
 
367
    public function testRemoveCorrectCallNoCaching()
 
368
    {
 
369
        $i1 = $this->_backend->getLogIndex();
 
370
        $this->_instance->setOption('caching', false);
 
371
        $res = $this->_instance->remove('foo');
 
372
        $i2 = $this->_backend->getLogIndex();
 
373
        $this->assertTrue($res);
 
374
        $this->assertEquals($i1, $i2);
 
375
    }
 
376
 
 
377
    public function testRemoveCorrectCall()
 
378
    {
 
379
        $res = $this->_instance->remove('foo');
 
380
        $log = $this->_backend->getLastLog();
 
381
        $expected = array(
 
382
            'methodName' => 'remove',
 
383
            'args' => array(
 
384
                0 => 'foo'
 
385
            )
 
386
        );
 
387
        $this->assertTrue($res);
 
388
        $this->assertEquals($expected, $log);
 
389
    }
 
390
 
 
391
    public function testCleanBadCall1()
 
392
    {
 
393
        try {
 
394
            $res = $this->_instance->clean('matchingTag', array('foo bar', 'foo'));
 
395
        }  catch (Zend_Cache_Exception $e) {
 
396
            return;
 
397
        }
 
398
        $this->fail('Zend_Cache_Exception was expected but not thrown');
 
399
    }
 
400
 
 
401
    public function testCleanBadCall2()
 
402
    {
 
403
        try {
 
404
            $res = $this->_instance->clean('foo');
 
405
        }  catch (Zend_Cache_Exception $e) {
 
406
            return;
 
407
        }
 
408
        $this->fail('Zend_Cache_Exception was expected but not thrown');
 
409
    }
 
410
 
 
411
    public function testCleanCorrectCallNoCaching()
 
412
    {
 
413
        $i1 = $this->_backend->getLogIndex();
 
414
        $this->_instance->setOption('caching', false);
 
415
        $res = $this->_instance->clean('all');
 
416
        $i2 = $this->_backend->getLogIndex();
 
417
        $this->assertTrue($res);
 
418
        $this->assertEquals($i1, $i2);
 
419
    }
 
420
 
 
421
    public function testCleanCorrectCall()
 
422
    {
 
423
        $res = $this->_instance->clean('matchingTag', array('tag1', 'tag2'));
 
424
        $log = $this->_backend->getLastLog();
 
425
        $expected = array(
 
426
            'methodName' => 'clean',
 
427
            'args' => array(
 
428
                0 => 'matchingTag',
 
429
                1 => array(
 
430
                    0 => 'tag1',
 
431
                    1 => 'tag2'
 
432
                )
 
433
            )
 
434
        );
 
435
        $this->assertTrue($res);
 
436
        $this->assertEquals($expected, $log);
 
437
    }
 
438
 
 
439
}
 
440
 
 
441