統計
| ブランチ: | リビジョン:

pictcode / lib / Cake / Test / Case / Utility / ObjectCollectionTest.php @ 0b1b8047

履歴 | 表示 | アノテート | ダウンロード (17.018 KB)

1 635eef61 spyder1211
<?php
2
/**
3
 * ObjectCollectionTest file
4
 *
5
 * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
6
 * Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
7
 *
8
 * Licensed under The MIT License
9
 * For full copyright and license information, please see the LICENSE.txt
10
 * Redistributions of files must retain the above copyright notice.
11
 *
12
 * @copyright     Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
13
 * @link          http://book.cakephp.org/2.0/en/development/testing.html CakePHP(tm) Tests
14
 * @package       Cake.Test.Case.Utility
15
 * @since         CakePHP(tm) v 2.0
16
 * @license       http://www.opensource.org/licenses/mit-license.php MIT License
17
 */
18
19
App::uses('ObjectCollection', 'Utility');
20
App::uses('CakeEvent', 'Event');
21
22
/**
23
 * A generic object class
24
 */
25
class GenericObject {
26
27
/**
28
 * Constructor
29
 *
30
 * @param GenericObjectCollection $collection A collection.
31
 * @param array $settings Settings.
32
 */
33
        public function __construct(GenericObjectCollection $collection, $settings = array()) {
34
                $this->_Collection = $collection;
35
                $this->settings = $settings;
36
        }
37
38
}
39
40
/**
41
 * First Extension of Generic Object
42
 */
43
class FirstGenericObject extends GenericObject {
44
45
/**
46
 * A generic callback
47
 *
48
 * @return void
49
 */
50
        public function callback() {
51
        }
52
53
}
54
55
/**
56
 * Second Extension of Generic Object
57
 */
58
class SecondGenericObject extends GenericObject {
59
60
/**
61
 * @return void
62
 */
63
        public function callback() {
64
        }
65
66
}
67
68
/**
69
 * Third Extension of Generic Object
70
 */
71
class ThirdGenericObject extends GenericObject {
72
73
/**
74
 * @return void
75
 */
76
        public function callback() {
77
        }
78
79
}
80
81
/**
82
 * A collection of Generic objects
83
 */
84
class GenericObjectCollection extends ObjectCollection {
85
86
/**
87
 * Loads a generic object
88
 *
89
 * @param string $object Object name
90
 * @param array $settings Settings array
91
 * @return array List of loaded objects
92
 */
93
        public function load($object, $settings = array()) {
94
                list(, $name) = pluginSplit($object);
95
                if (isset($this->_loaded[$name])) {
96
                        return $this->_loaded[$name];
97
                }
98
                $objectClass = $name . 'GenericObject';
99
                $this->_loaded[$name] = new $objectClass($this, $settings);
100
                $enable = isset($settings['enabled']) ? $settings['enabled'] : true;
101
                if ($enable === true) {
102
                        $this->enable($name);
103
                }
104
                return $this->_loaded[$name];
105
        }
106
107
/**
108
 * Helper method for adding/overwriting enabled objects including
109
 * settings
110
 *
111
 * @param string $name Name of the object
112
 * @param Object $object The object to use
113
 * @param array $settings Settings to apply for the object
114
 * @return array Loaded objects
115
 */
116
        public function setObject($name, $object, $settings = array()) {
117
                $this->_loaded[$name] = $object;
118
                if (isset($settings['priority'])) {
119
                        $this->setPriority($name, $settings['priority']);
120
                }
121
                $enable = isset($settings['enabled']) ? $settings['enabled'] : true;
122
                if ($enable === true) {
123
                        $this->enable($name);
124
                }
125
                return $this->_loaded;
126
        }
127
128
}
129
130
class ObjectCollectionTest extends CakeTestCase {
131
132
/**
133
 * setUp
134
 *
135
 * @return void
136
 */
137
        public function setUp() {
138
                parent::setUp();
139
                $this->Objects = new GenericObjectCollection();
140
        }
141
142
/**
143
 * tearDown
144
 *
145
 * @return void
146
 */
147
        public function tearDown() {
148
                parent::tearDown();
149
                unset($this->Objects);
150
        }
151
152
/**
153
 * test triggering callbacks on loaded helpers
154
 *
155
 * @return void
156
 */
157
        public function testLoad() {
158
                $result = $this->Objects->load('First');
159
                $this->assertInstanceOf('FirstGenericObject', $result);
160
                $this->assertInstanceOf('FirstGenericObject', $this->Objects->First);
161
162
                $result = $this->Objects->loaded();
163
                $this->assertEquals(array('First'), $result, 'loaded() results are wrong.');
164
165
                $this->assertTrue($this->Objects->enabled('First'));
166
167
                $result = $this->Objects->load('First');
168
                $this->assertSame($result, $this->Objects->First);
169
        }
170
171
/**
172
 * test unload()
173
 *
174
 * @return void
175
 */
176
        public function testUnload() {
177
                $this->Objects->load('First');
178
                $this->Objects->load('Second');
179
180
                $result = $this->Objects->loaded();
181
                $this->assertEquals(array('First', 'Second'), $result, 'loaded objects are wrong');
182
183
                $this->Objects->unload('First');
184
                $this->assertFalse(isset($this->Objects->First));
185
                $this->assertTrue(isset($this->Objects->Second));
186
187
                $result = $this->Objects->loaded();
188
                $this->assertEquals(array('Second'), $result, 'loaded objects are wrong');
189
190
                $result = $this->Objects->loaded();
191
                $this->assertEquals(array('Second'), $result, 'enabled objects are wrong');
192
        }
193
194
/**
195
 * Tests set()
196
 *
197
 * @return void
198
 */
199
        public function testSet() {
200
                $this->Objects->load('First');
201
202
                $result = $this->Objects->loaded();
203
                $this->assertEquals(array('First'), $result, 'loaded objects are wrong');
204
205
                $result = $this->Objects->set('First', new SecondGenericObject($this->Objects));
206
                $this->assertInstanceOf('SecondGenericObject', $result['First'], 'set failed');
207
208
                $result = $this->Objects->set('Second', new SecondGenericObject($this->Objects));
209
                $this->assertInstanceOf('SecondGenericObject', $result['Second'], 'set failed');
210
211
                $this->assertEquals(2, count($result));
212
        }
213
214
/**
215
 * creates mock classes for testing
216
 *
217
 * @return void
218
 */
219
        protected function _makeMockClasses() {
220
                $this->FirstGenericObject = $this->getMock('FirstGenericObject', array(), array(), '', false);
221
                $this->SecondGenericObject = $this->getMock('SecondGenericObject', array(), array(), '', false);
222
                $this->ThirdGenericObject = $this->getMock('ThirdGenericObject', array(), array(), '', false);
223
        }
224
225
/**
226
 * test triggering callbacks.
227
 *
228
 * @return void
229
 */
230
        public function testTrigger() {
231
                $this->_makeMockClasses();
232
                $this->Objects->setObject('TriggerMockFirst', $this->FirstGenericObject);
233
                $this->Objects->setObject('TriggerMockSecond', $this->SecondGenericObject);
234
235
                $this->Objects->TriggerMockFirst->expects($this->once())
236
                        ->method('callback')
237
                        ->will($this->returnValue(true));
238
                $this->Objects->TriggerMockSecond->expects($this->once())
239
                        ->method('callback')
240
                        ->will($this->returnValue(true));
241
242
                $this->assertTrue($this->Objects->trigger('callback'));
243
        }
244
245
/**
246
 * test trigger and disabled objects
247
 *
248
 * @return void
249
 */
250
        public function testTriggerWithDisabledObjects() {
251
                $this->_makeMockClasses();
252
                $this->Objects->setObject('TriggerMockFirst', $this->FirstGenericObject);
253
                $this->Objects->setObject('TriggerMockSecond', $this->SecondGenericObject, array('enabled' => false));
254
255
                $this->Objects->TriggerMockFirst->expects($this->once())
256
                        ->method('callback')
257
                        ->will($this->returnValue(true));
258
                $this->Objects->TriggerMockSecond->expects($this->never())
259
                        ->method('callback')
260
                        ->will($this->returnValue(true));
261
262
                $this->assertTrue($this->Objects->trigger('callback', array()));
263
        }
264
265
/**
266
 * test that the collectReturn option works.
267
 *
268
 * @return void
269
 */
270
        public function testTriggerWithCollectReturn() {
271
                $this->_makeMockClasses();
272
                $this->Objects->setObject('TriggerMockFirst', $this->FirstGenericObject);
273
                $this->Objects->setObject('TriggerMockSecond', $this->SecondGenericObject);
274
275
                $this->Objects->TriggerMockFirst->expects($this->once())
276
                        ->method('callback')
277
                        ->will($this->returnValue(array('one', 'two')));
278
                $this->Objects->TriggerMockSecond->expects($this->once())
279
                        ->method('callback')
280
                        ->will($this->returnValue(array('three', 'four')));
281
282
                $result = $this->Objects->trigger('callback', array(), array('collectReturn' => true));
283
                $expected = array(
284
                        array('one', 'two'),
285
                        array('three', 'four')
286
                );
287
                $this->assertEquals($expected, $result);
288
        }
289
290
/**
291
 * test that trigger with break & breakOn works.
292
 *
293
 * @return void
294
 */
295
        public function testTriggerWithBreak() {
296
                $this->_makeMockClasses();
297
                $this->Objects->setObject('TriggerMockFirst', $this->FirstGenericObject);
298
                $this->Objects->setObject('TriggerMockSecond', $this->SecondGenericObject);
299
300
                $this->Objects->TriggerMockFirst->expects($this->once())
301
                        ->method('callback')
302
                        ->will($this->returnValue(false));
303
                $this->Objects->TriggerMockSecond->expects($this->never())
304
                        ->method('callback');
305
306
                $result = $this->Objects->trigger(
307
                        'callback',
308
                        array(),
309
                        array('break' => true, 'breakOn' => false)
310
                );
311
                $this->assertFalse($result);
312
        }
313
314
/**
315
 * test that trigger with modParams works.
316
 *
317
 * @return void
318
 */
319
        public function testTriggerWithModParams() {
320
                $this->_makeMockClasses();
321
                $this->Objects->setObject('TriggerMockFirst', $this->FirstGenericObject);
322
                $this->Objects->setObject('TriggerMockSecond', $this->SecondGenericObject);
323
324
                $this->Objects->TriggerMockFirst->expects($this->once())
325
                        ->method('callback')
326
                        ->with(array('value'))
327
                        ->will($this->returnValue(array('new value')));
328
329
                $this->Objects->TriggerMockSecond->expects($this->once())
330
                        ->method('callback')
331
                        ->with(array('new value'))
332
                        ->will($this->returnValue(array('newer value')));
333
334
                $result = $this->Objects->trigger(
335
                        'callback',
336
                        array(array('value')),
337
                        array('modParams' => 0)
338
                );
339
                $this->assertEquals(array('newer value'), $result);
340
        }
341
342
/**
343
 * test that setting modParams to an index that doesn't exist doesn't cause errors.
344
 *
345
 * @expectedException CakeException
346
 * @return void
347
 */
348
        public function testTriggerModParamsInvalidIndex() {
349
                $this->_makeMockClasses();
350
                $this->Objects->setObject('TriggerMockFirst', $this->FirstGenericObject);
351
                $this->Objects->setObject('TriggerMockSecond', $this->SecondGenericObject);
352
353
                $this->Objects->TriggerMockFirst->expects($this->never())
354
                        ->method('callback');
355
356
                $this->Objects->TriggerMockSecond->expects($this->never())
357
                        ->method('callback');
358
359
                $this->Objects->trigger(
360
                        'callback',
361
                        array(array('value')),
362
                        array('modParams' => 2)
363
                );
364
        }
365
366
/**
367
 * test that returning null doesn't modify parameters.
368
 *
369
 * @return void
370
 */
371
        public function testTriggerModParamsNullIgnored() {
372
                $this->_makeMockClasses();
373
                $this->Objects->setObject('TriggerMockFirst', $this->FirstGenericObject);
374
                $this->Objects->setObject('TriggerMockSecond', $this->SecondGenericObject);
375
376
                $this->Objects->TriggerMockFirst->expects($this->once())
377
                        ->method('callback')
378
                        ->with(array('value'))
379
                        ->will($this->returnValue(null));
380
381
                $this->Objects->TriggerMockSecond->expects($this->once())
382
                        ->method('callback')
383
                        ->with(array('value'))
384
                        ->will($this->returnValue(array('new value')));
385
386
                $result = $this->Objects->trigger(
387
                        'callback',
388
                        array(array('value')),
389
                        array('modParams' => 0)
390
                );
391
                $this->assertEquals(array('new value'), $result);
392
        }
393
394
/**
395
 * test order of callbacks triggering based on priority.
396
 *
397
 * @return void
398
 */
399
        public function testTriggerPriority() {
400
                $this->_makeMockClasses();
401
                $this->Objects->setObject('TriggerMockFirst', $this->FirstGenericObject);
402
                $this->Objects->setObject('TriggerMockSecond', $this->SecondGenericObject, array('priority' => 5));
403
404
                $this->Objects->TriggerMockFirst->expects($this->any())
405
                        ->method('callback')
406
                        ->will($this->returnValue('1st'));
407
                $this->Objects->TriggerMockSecond->expects($this->any())
408
                        ->method('callback')
409
                        ->will($this->returnValue('2nd'));
410
411
                $result = $this->Objects->trigger('callback', array(), array('collectReturn' => true));
412
                $expected = array(
413
                        '2nd',
414
                        '1st'
415
                );
416
                $this->assertEquals($expected, $result);
417
418
                $this->Objects->setObject('TriggerMockThird', $this->ThirdGenericObject, array('priority' => 7));
419
                $this->Objects->TriggerMockThird->expects($this->any())
420
                        ->method('callback')
421
                        ->will($this->returnValue('3rd'));
422
423
                $result = $this->Objects->trigger('callback', array(), array('collectReturn' => true));
424
                $expected = array(
425
                        '2nd',
426
                        '3rd',
427
                        '1st'
428
                );
429
                $this->assertEquals($expected, $result);
430
431
                $this->Objects->disable('TriggerMockFirst');
432
                $result = $this->Objects->trigger('callback', array(), array('collectReturn' => true));
433
                $expected = array(
434
                        '2nd',
435
                        '3rd'
436
                );
437
                $this->assertEquals($expected, $result);
438
439
                $this->Objects->enable('TriggerMockFirst');
440
                $result = $this->Objects->trigger('callback', array(), array('collectReturn' => true));
441
                $expected = array(
442
                        '2nd',
443
                        '3rd',
444
                        '1st'
445
                );
446
                $this->assertEquals($expected, $result);
447
448
                $this->Objects->disable('TriggerMockThird');
449
                $result = $this->Objects->trigger('callback', array(), array('collectReturn' => true));
450
                $expected = array(
451
                        '2nd',
452
                        '1st'
453
                );
454
                $this->assertEquals($expected, $result);
455
456
                $this->Objects->enable('TriggerMockThird', false);
457
                $result = $this->Objects->trigger('callback', array(), array('collectReturn' => true));
458
                $expected = array(
459
                        '2nd',
460
                        '1st',
461
                        '3rd'
462
                );
463
                $this->assertEquals($expected, $result);
464
465
                $this->Objects->setPriority('TriggerMockThird', 1);
466
                $result = $this->Objects->trigger('callback', array(), array('collectReturn' => true));
467
                $expected = array(
468
                        '3rd',
469
                        '2nd',
470
                        '1st'
471
                );
472
                $this->assertEquals($expected, $result);
473
474
                $this->Objects->disable('TriggerMockThird');
475
                $this->Objects->setPriority('TriggerMockThird', 11);
476
                $result = $this->Objects->trigger('callback', array(), array('collectReturn' => true));
477
                $expected = array(
478
                        '2nd',
479
                        '1st'
480
                );
481
                $this->assertEquals($expected, $result);
482
483
                $this->Objects->enable('TriggerMockThird');
484
                $result = $this->Objects->trigger('callback', array(), array('collectReturn' => true));
485
                $expected = array(
486
                        '2nd',
487
                        '1st',
488
                        '3rd'
489
                );
490
                $this->assertEquals($expected, $result);
491
492
                $this->Objects->setPriority('TriggerMockThird');
493
                $result = $this->Objects->trigger('callback', array(), array('collectReturn' => true));
494
                $expected = array(
495
                        '2nd',
496
                        '1st',
497
                        '3rd'
498
                );
499
                $this->assertEquals($expected, $result);
500
        }
501
502
/**
503
 * test normalizeObjectArray
504
 *
505
 * @return void
506
 */
507
        public function testnormalizeObjectArray() {
508
                $components = array(
509
                        'Html',
510
                        'Foo.Bar' => array('one', 'two'),
511
                        'Something',
512
                        'Banana.Apple' => array('foo' => 'bar')
513
                );
514
                $result = ObjectCollection::normalizeObjectArray($components);
515
                $expected = array(
516
                        'Html' => array('class' => 'Html', 'settings' => array()),
517
                        'Bar' => array('class' => 'Foo.Bar', 'settings' => array('one', 'two')),
518
                        'Something' => array('class' => 'Something', 'settings' => array()),
519
                        'Apple' => array('class' => 'Banana.Apple', 'settings' => array('foo' => 'bar')),
520
                );
521
                $this->assertEquals($expected, $result);
522
523
                // This is the result after Controller::_mergeVars
524
                $components = array(
525
                        'Html' => null,
526
                        'Foo.Bar' => array('one', 'two'),
527
                        'Something' => null,
528
                        'Banana.Apple' => array('foo' => 'bar')
529
                );
530
                $result = ObjectCollection::normalizeObjectArray($components);
531
                $this->assertEquals($expected, $result);
532
        }
533
534
/**
535
 * tests that passing an instance of CakeEvent to trigger will prepend the subject to the list of arguments
536
 *
537
 * @return void
538
 * @triggers callback $subjectClass, array('first argument')
539
 */
540
        public function testDispatchEventWithSubject() {
541
                $this->_makeMockClasses();
542
                $this->Objects->setObject('TriggerMockFirst', $this->FirstGenericObject);
543
                $this->Objects->setObject('TriggerMockSecond', $this->SecondGenericObject);
544
545
                $subjectClass = new Object();
546
                $this->Objects->TriggerMockFirst->expects($this->once())
547
                        ->method('callback')
548
                        ->with($subjectClass, 'first argument')
549
                        ->will($this->returnValue(true));
550
                $this->Objects->TriggerMockSecond->expects($this->once())
551
                        ->method('callback')
552
                        ->with($subjectClass, 'first argument')
553
                        ->will($this->returnValue(true));
554
555
                $event = new CakeEvent('callback', $subjectClass, array('first argument'));
556
                $this->assertTrue($this->Objects->trigger($event));
557
        }
558
559
/**
560
 * tests that passing an instance of CakeEvent to trigger with omitSubject property
561
 * will NOT prepend the subject to the list of arguments
562
 *
563
 * @return void
564
 * @triggers callback $subjectClass, array('first argument')
565
 */
566
        public function testDispatchEventNoSubject() {
567
                $this->_makeMockClasses();
568
                $this->Objects->setObject('TriggerMockFirst', $this->FirstGenericObject);
569
                $this->Objects->setObject('TriggerMockSecond', $this->SecondGenericObject);
570
571
                $subjectClass = new Object();
572
                $this->Objects->TriggerMockFirst->expects($this->once())
573
                        ->method('callback')
574
                        ->with('first argument')
575
                        ->will($this->returnValue(true));
576
                $this->Objects->TriggerMockSecond->expects($this->once())
577
                        ->method('callback')
578
                        ->with('first argument')
579
                        ->will($this->returnValue(true));
580
581
                $event = new CakeEvent('callback', $subjectClass, array('first argument'));
582
                $event->omitSubject = true;
583
                $this->assertTrue($this->Objects->trigger($event));
584
        }
585
586
/**
587
 * test that the various methods ignore plugin prefixes
588
 *
589
 * plugin prefixes should be removed consistently as load() will
590
 * remove them. Furthermore the __get() method does not support
591
 * names with '.' in them.
592
 *
593
 * @return void
594
 */
595
        public function testPluginPrefixes() {
596
                $this->Objects->load('TestPlugin.First');
597
                $this->assertTrue($this->Objects->loaded('First'));
598
                $this->assertTrue($this->Objects->loaded('TestPlugin.First'));
599
600
                $this->assertTrue($this->Objects->enabled('First'));
601
                $this->assertTrue($this->Objects->enabled('TestPlugin.First'));
602
603
                $this->assertNull($this->Objects->disable('TestPlugin.First'));
604
                $this->assertFalse($this->Objects->enabled('First'));
605
                $this->assertFalse($this->Objects->enabled('TestPlugin.First'));
606
607
                $this->assertNull($this->Objects->enable('TestPlugin.First'));
608
                $this->assertTrue($this->Objects->enabled('First'));
609
                $this->assertTrue($this->Objects->enabled('TestPlugin.First'));
610
                $this->Objects->setPriority('TestPlugin.First', 1000);
611
612
                $result = $this->Objects->prioritize();
613
                $this->assertEquals(1000, $result['First'][0]);
614
        }
615
}