Subversion Repositories SmartDukaan

<?php
/**
 * CakePHP : Rapid Development Framework (http://cakephp.org)
 * Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
 *
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE.txt
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright     Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
 * @link                  http://cakephp.org CakePHP Project
 * @package               Cake.Test.Case.Event
 * @since                 CakePHP v 2.1
 * @license       http://www.opensource.org/licenses/mit-license.php MIT License
 */

App::uses('CakeEvent', 'Event');
App::uses('CakeEventManager', 'Event');
App::uses('CakeEventListener', 'Event');

/**
 * Mock class used to test event dispatching
 *
 * @package Cake.Test.Case.Event
 */
class CakeEventTestListener {

        public $callStack = array();

/**
 * Test function to be used in event dispatching
 *
 * @return void
 */
        public function listenerFunction() {
                $this->callStack[] = __FUNCTION__;
        }

/**
 * Test function to be used in event dispatching
 *
 * @return void
 */
        public function secondListenerFunction() {
                $this->callStack[] = __FUNCTION__;
        }

/**
 * Auxiliary function to help in stopPropagation testing
 *
 * @param CakeEvent $event
 * @return void
 */
        public function stopListener($event) {
                $event->stopPropagation();
        }

}

/**
 * Mock used for testing the subscriber objects
 *
 * @package Cake.Test.Case.Event
 */
class CustomTestEventListener extends CakeEventTestListener implements CakeEventListener {

        public function implementedEvents() {
                return array(
                        'fake.event' => 'listenerFunction',
                        'another.event' => array('callable' => 'secondListenerFunction', 'passParams' => true),
                        'multiple.handlers' => array(
                                array('callable' => 'listenerFunction'),
                                array('callable' => 'thirdListenerFunction')
                        )
                );
        }

/**
 * Test function to be used in event dispatching
 *
 * @return void
 */
        public function thirdListenerFunction() {
                $this->callStack[] = __FUNCTION__;
        }

}

/**
 * Tests the CakeEventManager class functionality
 *
 */
class CakeEventManagerTest extends CakeTestCase {

/**
 * Tests the attach() method for a single event key in multiple queues
 *
 * @return void
 */
        public function testAttachListeners() {
                $manager = new CakeEventManager();
                $manager->attach('fakeFunction', 'fake.event');
                $expected = array(
                        array('callable' => 'fakeFunction', 'passParams' => false)
                );
                $this->assertEquals($expected, $manager->listeners('fake.event'));

                $manager->attach('fakeFunction2', 'fake.event');
                $expected[] = array('callable' => 'fakeFunction2', 'passParams' => false);
                $this->assertEquals($expected, $manager->listeners('fake.event'));

                $manager->attach('inQ5', 'fake.event', array('priority' => 5));
                $manager->attach('inQ1', 'fake.event', array('priority' => 1));
                $manager->attach('otherInQ5', 'fake.event', array('priority' => 5));

                $expected = array_merge(
                        array(
                                array('callable' => 'inQ1', 'passParams' => false),
                                array('callable' => 'inQ5', 'passParams' => false),
                                array('callable' => 'otherInQ5', 'passParams' => false)
                        ),
                        $expected
                );
                $this->assertEquals($expected, $manager->listeners('fake.event'));
        }

/**
 * Tests the attach() method for multiple event key in multiple queues
 *
 * @return void
 */
        public function testAttachMultipleEventKeys() {
                $manager = new CakeEventManager();
                $manager->attach('fakeFunction', 'fake.event');
                $manager->attach('fakeFunction2', 'another.event');
                $manager->attach('fakeFunction3', 'another.event', array('priority' => 1, 'passParams' => true));
                $expected = array(
                        array('callable' => 'fakeFunction', 'passParams' => false)
                );
                $this->assertEquals($expected, $manager->listeners('fake.event'));

                $expected = array(
                        array('callable' => 'fakeFunction3', 'passParams' => true),
                        array('callable' => 'fakeFunction2', 'passParams' => false)
                );
                $this->assertEquals($expected, $manager->listeners('another.event'));
        }

/**
 * Tests detaching an event from a event key queue
 *
 * @return void
 */
        public function testDetach() {
                $manager = new CakeEventManager();
                $manager->attach(array('AClass', 'aMethod'), 'fake.event');
                $manager->attach(array('AClass', 'anotherMethod'), 'another.event');
                $manager->attach('fakeFunction', 'another.event', array('priority' => 1));

                $manager->detach(array('AClass', 'aMethod'), 'fake.event');
                $this->assertEquals(array(), $manager->listeners('fake.event'));

                $manager->detach(array('AClass', 'anotherMethod'), 'another.event');
                $expected = array(
                        array('callable' => 'fakeFunction', 'passParams' => false)
                );
                $this->assertEquals($expected, $manager->listeners('another.event'));

                $manager->detach('fakeFunction', 'another.event');
                $this->assertEquals(array(), $manager->listeners('another.event'));
        }

/**
 * Tests detaching an event from all event queues
 *
 * @return void
 */
        public function testDetachFromAll() {
                $manager = new CakeEventManager();
                $manager->attach(array('AClass', 'aMethod'), 'fake.event');
                $manager->attach(array('AClass', 'aMethod'), 'another.event');
                $manager->attach('fakeFunction', 'another.event', array('priority' => 1));

                $manager->detach(array('AClass', 'aMethod'));
                $expected = array(
                        array('callable' => 'fakeFunction', 'passParams' => false)
                );
                $this->assertEquals($expected, $manager->listeners('another.event'));
                $this->assertEquals(array(), $manager->listeners('fake.event'));
        }

/**
 * Tests event dispatching
 *
 * @return void
 */
        public function testDispatch() {
                $manager = new CakeEventManager();
                $listener = $this->getMock('CakeEventTestListener');
                $anotherListener = $this->getMock('CakeEventTestListener');
                $manager->attach(array($listener, 'listenerFunction'), 'fake.event');
                $manager->attach(array($anotherListener, 'listenerFunction'), 'fake.event');
                $event = new CakeEvent('fake.event');

                $listener->expects($this->once())->method('listenerFunction')->with($event);
                $anotherListener->expects($this->once())->method('listenerFunction')->with($event);
                $manager->dispatch($event);
        }

/**
 * Tests event dispatching using event key name
 *
 * @return void
 */
        public function testDispatchWithKeyName() {
                $manager = new CakeEventManager();
                $listener = new CakeEventTestListener();
                $manager->attach(array($listener, 'listenerFunction'), 'fake.event');
                $event = 'fake.event';
                $manager->dispatch($event);

                $expected = array('listenerFunction');
                $this->assertEquals($expected, $listener->callStack);
        }

/**
 * Tests event dispatching with a return value
 *
 * @return void
 */
        public function testDispatchReturnValue() {
                $this->skipIf(
                        version_compare(PHPUnit_Runner_Version::id(), '3.7', '<'),
                        'These tests fail in PHPUnit 3.6'
                );
                $manager = new CakeEventManager();
                $listener = $this->getMock('CakeEventTestListener');
                $anotherListener = $this->getMock('CakeEventTestListener');
                $manager->attach(array($listener, 'listenerFunction'), 'fake.event');
                $manager->attach(array($anotherListener, 'listenerFunction'), 'fake.event');
                $event = new CakeEvent('fake.event');

                $listener->expects($this->at(0))->method('listenerFunction')
                        ->with($event)
                        ->will($this->returnValue('something special'));
                $anotherListener->expects($this->at(0))
                        ->method('listenerFunction')
                        ->with($event);
                $manager->dispatch($event);
                $this->assertEquals('something special', $event->result);
        }

/**
 * Tests that returning false in a callback stops the event
 *
 * @return void
 */
        public function testDispatchFalseStopsEvent() {
                $this->skipIf(
                        version_compare(PHPUnit_Runner_Version::id(), '3.7', '<'),
                        'These tests fail in PHPUnit 3.6'
                );

                $manager = new CakeEventManager();
                $listener = $this->getMock('CakeEventTestListener');
                $anotherListener = $this->getMock('CakeEventTestListener');
                $manager->attach(array($listener, 'listenerFunction'), 'fake.event');
                $manager->attach(array($anotherListener, 'listenerFunction'), 'fake.event');
                $event = new CakeEvent('fake.event');

                $listener->expects($this->at(0))->method('listenerFunction')
                        ->with($event)
                        ->will($this->returnValue(false));
                $anotherListener->expects($this->never())
                        ->method('listenerFunction');
                $manager->dispatch($event);
                $this->assertTrue($event->isStopped());
        }

/**
 * Tests event dispatching using priorities
 *
 * @return void
 */
        public function testDispatchPrioritized() {
                $manager = new CakeEventManager();
                $listener = new CakeEventTestListener();
                $manager->attach(array($listener, 'listenerFunction'), 'fake.event');
                $manager->attach(array($listener, 'secondListenerFunction'), 'fake.event', array('priority' => 5));
                $event = new CakeEvent('fake.event');
                $manager->dispatch($event);

                $expected = array('secondListenerFunction', 'listenerFunction');
                $this->assertEquals($expected, $listener->callStack);
        }

/**
 * Tests event dispatching with passed params
 *
 * @return void
 */
        public function testDispatchPassingParams() {
                $manager = new CakeEventManager();
                $listener = $this->getMock('CakeEventTestListener');
                $anotherListener = $this->getMock('CakeEventTestListener');
                $manager->attach(array($listener, 'listenerFunction'), 'fake.event');
                $manager->attach(array($anotherListener, 'secondListenerFunction'), 'fake.event', array('passParams' => true));
                $event = new CakeEvent('fake.event', $this, array('some' => 'data'));

                $listener->expects($this->once())->method('listenerFunction')->with($event);
                $anotherListener->expects($this->once())->method('secondListenerFunction')->with('data');
                $manager->dispatch($event);
        }

/**
 * Tests subscribing a listener object and firing the events it subscribed to
 *
 * @return void
 */
        public function testAttachSubscriber() {
                $manager = new CakeEventManager();
                $listener = $this->getMock('CustomTestEventListener', array('secondListenerFunction'));
                $manager->attach($listener);
                $event = new CakeEvent('fake.event');

                $manager->dispatch($event);

                $expected = array('listenerFunction');
                $this->assertEquals($expected, $listener->callStack);

                $listener->expects($this->at(0))->method('secondListenerFunction')->with('data');
                $event = new CakeEvent('another.event', $this, array('some' => 'data'));
                $manager->dispatch($event);

                $manager = new CakeEventManager();
                $listener = $this->getMock('CustomTestEventListener', array('listenerFunction', 'thirdListenerFunction'));
                $manager->attach($listener);
                $event = new CakeEvent('multiple.handlers');
                $listener->expects($this->once())->method('listenerFunction')->with($event);
                $listener->expects($this->once())->method('thirdListenerFunction')->with($event);
                $manager->dispatch($event);
        }

/**
 * Tests subscribing a listener object and firing the events it subscribed to
 *
 * @return void
 */
        public function testDetachSubscriber() {
                $manager = new CakeEventManager();
                $listener = $this->getMock('CustomTestEventListener', array('secondListenerFunction'));
                $manager->attach($listener);
                $expected = array(
                        array('callable' => array($listener, 'secondListenerFunction'), 'passParams' => true)
                );
                $this->assertEquals($expected, $manager->listeners('another.event'));
                $expected = array(
                        array('callable' => array($listener, 'listenerFunction'), 'passParams' => false)
                );
                $this->assertEquals($expected, $manager->listeners('fake.event'));
                $manager->detach($listener);
                $this->assertEquals(array(), $manager->listeners('fake.event'));
                $this->assertEquals(array(), $manager->listeners('another.event'));
        }

/**
 * Tests that it is possible to get/set the manager singleton
 *
 * @return void
 */
        public function testGlobalDispatcherGetter() {
                $this->assertInstanceOf('CakeEventManager', CakeEventManager::instance());
                $manager = new CakeEventManager();

                CakeEventManager::instance($manager);
                $this->assertSame($manager, CakeEventManager::instance());
        }

/**
 * Tests that the global event manager gets the event too from any other manager
 *
 * @return void
 */
        public function testDispatchWithGlobal() {
                $generalManager = $this->getMock('CakeEventManager', array('prioritisedListeners'));
                $manager = new CakeEventManager();
                $event = new CakeEvent('fake.event');
                CakeEventManager::instance($generalManager);

                $generalManager->expects($this->once())->method('prioritisedListeners')->with('fake.event');
                $manager->dispatch($event);
                CakeEventManager::instance(new CakeEventManager());
        }

/**
 * Tests that stopping an event will not notify the rest of the listeners
 *
 * @return void
 */
        public function testStopPropagation() {
                $generalManager = $this->getMock('CakeEventManager');
                $manager = new CakeEventManager();
                $listener = new CakeEventTestListener();

                CakeEventManager::instance($generalManager);
                $generalManager->expects($this->any())
                                ->method('prioritisedListeners')
                                ->with('fake.event')
                                ->will($this->returnValue(array()));

                $manager->attach(array($listener, 'listenerFunction'), 'fake.event');
                $manager->attach(array($listener, 'stopListener'), 'fake.event', array('priority' => 8));
                $manager->attach(array($listener, 'secondListenerFunction'), 'fake.event', array('priority' => 5));
                $event = new CakeEvent('fake.event');
                $manager->dispatch($event);

                $expected = array('secondListenerFunction');
                $this->assertEquals($expected, $listener->callStack);
                CakeEventManager::instance(new CakeEventManager());
        }

/**
 * Tests event dispatching using priorities
 *
 * @return void
 */
        public function testDispatchPrioritizedWithGlobal() {
                $generalManager = $this->getMock('CakeEventManager');
                $manager = new CakeEventManager();
                $listener = new CustomTestEventListener();
                $event = new CakeEvent('fake.event');

                CakeEventManager::instance($generalManager);
                $generalManager->expects($this->any())
                                ->method('prioritisedListeners')
                                ->with('fake.event')
                                ->will($this->returnValue(
                                        array(11 => array(
                                                array('callable' => array($listener, 'secondListenerFunction'), 'passParams' => false)
                                        ))
                                ));

                $manager->attach(array($listener, 'listenerFunction'), 'fake.event');
                $manager->attach(array($listener, 'thirdListenerFunction'), 'fake.event', array('priority' => 15));

                $manager->dispatch($event);

                $expected = array('listenerFunction', 'secondListenerFunction', 'thirdListenerFunction');
                $this->assertEquals($expected, $listener->callStack);
                CakeEventManager::instance(new CakeEventManager());
        }

/**
 * Tests event dispatching using priorities
 *
 * @return void
 */
        public function testDispatchGlobalBeforeLocal() {
                $generalManager = $this->getMock('CakeEventManager');
                $manager = new CakeEventManager();
                $listener = new CustomTestEventListener();
                $event = new CakeEvent('fake.event');

                CakeEventManager::instance($generalManager);
                $generalManager->expects($this->any())
                                ->method('prioritisedListeners')
                                ->with('fake.event')
                                ->will($this->returnValue(
                                        array(10 => array(
                                                array('callable' => array($listener, 'listenerFunction'), 'passParams' => false)
                                        ))
                                ));

                $manager->attach(array($listener, 'secondListenerFunction'), 'fake.event');

                $manager->dispatch($event);

                $expected = array('listenerFunction', 'secondListenerFunction');
                $this->assertEquals($expected, $listener->callStack);
                CakeEventManager::instance(new CakeEventManager());
        }

/**
 * test callback
 */
        public function onMyEvent($event) {
                $event->data['callback'] = 'ok';
        }

/**
 * Tests events dispatched by a local manager can be handled by
 * handler registered in the global event manager
 */
        public function testDispatchLocalHandledByGlobal() {
                $callback = array($this, 'onMyEvent');
                CakeEventManager::instance()->attach($callback, 'my_event');
                $manager = new CakeEventManager();
                $event = new CakeEvent('my_event', $manager);
                $manager->dispatch($event);
                $this->assertEquals('ok', $event->data['callback']);
        }

/**
 * Test that events are dispatched properly when there are global and local
 * listeners at the same priority.
 *
 * @return void
 */
        public function testDispatchWithGlobalAndLocalEvents() {
                $listener = new CustomTestEventListener();
                CakeEventManager::instance()->attach($listener);
                $listener2 = new CakeEventTestListener();
                $manager = new CakeEventManager();
                $manager->attach(array($listener2, 'listenerFunction'), 'fake.event');

                $manager->dispatch(new CakeEvent('fake.event', $this));
                $this->assertEquals(array('listenerFunction'), $listener->callStack);
                $this->assertEquals(array('listenerFunction'), $listener2->callStack);
        }

}