www.aleph1.co.uk Git - yaffs-website/blob - vendor/symfony/event-dispatcher/Tests/Debug/TraceableEventDispatcherTest.php

   1 <?php
   2
   3 /*
   4  * This file is part of the Symfony package.
   5  *
   6  * (c) Fabien Potencier <fabien@symfony.com>
   7  *
   8  * For the full copyright and license information, please view the LICENSE
   9  * file that was distributed with this source code.
  10  */
  11
  12 namespace Symfony\Component\EventDispatcher\Tests\Debug;
  13
  14 use PHPUnit\Framework\TestCase;
  15 use Symfony\Component\EventDispatcher\Debug\TraceableEventDispatcher;
  16 use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  17 use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  18 use Symfony\Component\EventDispatcher\EventDispatcher;
  19 use Symfony\Component\EventDispatcher\Event;
  20 use Symfony\Component\Stopwatch\Stopwatch;
  21
  22 class TraceableEventDispatcherTest extends TestCase
  23 {
  24     public function testAddRemoveListener()
  25     {
  26         $dispatcher = new EventDispatcher();
  27         $tdispatcher = new TraceableEventDispatcher($dispatcher, new Stopwatch());
  28
  29         $tdispatcher->addListener('foo', $listener = function () {});
  30         $listeners = $dispatcher->getListeners('foo');
  31         $this->assertCount(1, $listeners);
  32         $this->assertSame($listener, $listeners[0]);
  33
  34         $tdispatcher->removeListener('foo', $listener);
  35         $this->assertCount(0, $dispatcher->getListeners('foo'));
  36     }
  37
  38     public function testGetListeners()
  39     {
  40         $dispatcher = new EventDispatcher();
  41         $tdispatcher = new TraceableEventDispatcher($dispatcher, new Stopwatch());
  42
  43         $tdispatcher->addListener('foo', $listener = function () {});
  44         $this->assertSame($dispatcher->getListeners('foo'), $tdispatcher->getListeners('foo'));
  45     }
  46
  47     public function testHasListeners()
  48     {
  49         $dispatcher = new EventDispatcher();
  50         $tdispatcher = new TraceableEventDispatcher($dispatcher, new Stopwatch());
  51
  52         $this->assertFalse($dispatcher->hasListeners('foo'));
  53         $this->assertFalse($tdispatcher->hasListeners('foo'));
  54
  55         $tdispatcher->addListener('foo', $listener = function () {});
  56         $this->assertTrue($dispatcher->hasListeners('foo'));
  57         $this->assertTrue($tdispatcher->hasListeners('foo'));
  58     }
  59
  60     public function testGetListenerPriority()
  61     {
  62         $dispatcher = new EventDispatcher();
  63         $tdispatcher = new TraceableEventDispatcher($dispatcher, new Stopwatch());
  64
  65         $tdispatcher->addListener('foo', function () {}, 123);
  66
  67         $listeners = $dispatcher->getListeners('foo');
  68         $this->assertSame(123, $tdispatcher->getListenerPriority('foo', $listeners[0]));
  69
  70         // Verify that priority is preserved when listener is removed and re-added
  71         // in preProcess() and postProcess().
  72         $tdispatcher->dispatch('foo', new Event());
  73         $listeners = $dispatcher->getListeners('foo');
  74         $this->assertSame(123, $tdispatcher->getListenerPriority('foo', $listeners[0]));
  75     }
  76
  77     public function testGetListenerPriorityWhileDispatching()
  78     {
  79         $tdispatcher = new TraceableEventDispatcher(new EventDispatcher(), new Stopwatch());
  80         $priorityWhileDispatching = null;
  81
  82         $listener = function () use ($tdispatcher, &$priorityWhileDispatching, &$listener) {
  83             $priorityWhileDispatching = $tdispatcher->getListenerPriority('bar', $listener);
  84         };
  85
  86         $tdispatcher->addListener('bar', $listener, 5);
  87         $tdispatcher->dispatch('bar');
  88         $this->assertSame(5, $priorityWhileDispatching);
  89     }
  90
  91     public function testAddRemoveSubscriber()
  92     {
  93         $dispatcher = new EventDispatcher();
  94         $tdispatcher = new TraceableEventDispatcher($dispatcher, new Stopwatch());
  95
  96         $subscriber = new EventSubscriber();
  97
  98         $tdispatcher->addSubscriber($subscriber);
  99         $listeners = $dispatcher->getListeners('foo');
 100         $this->assertCount(1, $listeners);
 101         $this->assertSame(array($subscriber, 'call'), $listeners[0]);
 102
 103         $tdispatcher->removeSubscriber($subscriber);
 104         $this->assertCount(0, $dispatcher->getListeners('foo'));
 105     }
 106
 107     public function testGetCalledListeners()
 108     {
 109         $tdispatcher = new TraceableEventDispatcher(new EventDispatcher(), new Stopwatch());
 110         $tdispatcher->addListener('foo', function () {}, 5);
 111
 112         $listeners = $tdispatcher->getNotCalledListeners();
 113         $this->assertArrayHasKey('stub', $listeners['foo.closure']);
 114         unset($listeners['foo.closure']['stub']);
 115         $this->assertEquals(array(), $tdispatcher->getCalledListeners());
 116         $this->assertEquals(array('foo.closure' => array('event' => 'foo', 'pretty' => 'closure', 'priority' => 5)), $listeners);
 117
 118         $tdispatcher->dispatch('foo');
 119
 120         $listeners = $tdispatcher->getCalledListeners();
 121         $this->assertArrayHasKey('stub', $listeners['foo.closure']);
 122         unset($listeners['foo.closure']['stub']);
 123         $this->assertEquals(array('foo.closure' => array('event' => 'foo', 'pretty' => 'closure', 'priority' => 5)), $listeners);
 124         $this->assertEquals(array(), $tdispatcher->getNotCalledListeners());
 125     }
 126
 127     public function testClearCalledListeners()
 128     {
 129         $tdispatcher = new TraceableEventDispatcher(new EventDispatcher(), new Stopwatch());
 130         $tdispatcher->addListener('foo', function () {}, 5);
 131
 132         $tdispatcher->dispatch('foo');
 133         $tdispatcher->reset();
 134
 135         $listeners = $tdispatcher->getNotCalledListeners();
 136         $this->assertArrayHasKey('stub', $listeners['foo.closure']);
 137         unset($listeners['foo.closure']['stub']);
 138         $this->assertEquals(array(), $tdispatcher->getCalledListeners());
 139         $this->assertEquals(array('foo.closure' => array('event' => 'foo', 'pretty' => 'closure', 'priority' => 5)), $listeners);
 140     }
 141
 142     public function testGetCalledListenersNested()
 143     {
 144         $tdispatcher = null;
 145         $dispatcher = new TraceableEventDispatcher(new EventDispatcher(), new Stopwatch());
 146         $dispatcher->addListener('foo', function (Event $event, $eventName, $dispatcher) use (&$tdispatcher) {
 147             $tdispatcher = $dispatcher;
 148             $dispatcher->dispatch('bar');
 149         });
 150         $dispatcher->addListener('bar', function (Event $event) {});
 151         $dispatcher->dispatch('foo');
 152         $this->assertSame($dispatcher, $tdispatcher);
 153         $this->assertCount(2, $dispatcher->getCalledListeners());
 154     }
 155
 156     public function testLogger()
 157     {
 158         $logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
 159
 160         $dispatcher = new EventDispatcher();
 161         $tdispatcher = new TraceableEventDispatcher($dispatcher, new Stopwatch(), $logger);
 162         $tdispatcher->addListener('foo', $listener1 = function () {});
 163         $tdispatcher->addListener('foo', $listener2 = function () {});
 164
 165         $logger->expects($this->at(0))->method('debug')->with('Notified event "{event}" to listener "{listener}".', array('event' => 'foo', 'listener' => 'closure'));
 166         $logger->expects($this->at(1))->method('debug')->with('Notified event "{event}" to listener "{listener}".', array('event' => 'foo', 'listener' => 'closure'));
 167
 168         $tdispatcher->dispatch('foo');
 169     }
 170
 171     public function testLoggerWithStoppedEvent()
 172     {
 173         $logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
 174
 175         $dispatcher = new EventDispatcher();
 176         $tdispatcher = new TraceableEventDispatcher($dispatcher, new Stopwatch(), $logger);
 177         $tdispatcher->addListener('foo', $listener1 = function (Event $event) { $event->stopPropagation(); });
 178         $tdispatcher->addListener('foo', $listener2 = function () {});
 179
 180         $logger->expects($this->at(0))->method('debug')->with('Notified event "{event}" to listener "{listener}".', array('event' => 'foo', 'listener' => 'closure'));
 181         $logger->expects($this->at(1))->method('debug')->with('Listener "{listener}" stopped propagation of the event "{event}".', array('event' => 'foo', 'listener' => 'closure'));
 182         $logger->expects($this->at(2))->method('debug')->with('Listener "{listener}" was not called for event "{event}".', array('event' => 'foo', 'listener' => 'closure'));
 183
 184         $tdispatcher->dispatch('foo');
 185     }
 186
 187     public function testDispatchCallListeners()
 188     {
 189         $called = array();
 190
 191         $dispatcher = new EventDispatcher();
 192         $tdispatcher = new TraceableEventDispatcher($dispatcher, new Stopwatch());
 193         $tdispatcher->addListener('foo', function () use (&$called) { $called[] = 'foo1'; }, 10);
 194         $tdispatcher->addListener('foo', function () use (&$called) { $called[] = 'foo2'; }, 20);
 195
 196         $tdispatcher->dispatch('foo');
 197
 198         $this->assertSame(array('foo2', 'foo1'), $called);
 199     }
 200
 201     public function testDispatchNested()
 202     {
 203         $dispatcher = new TraceableEventDispatcher(new EventDispatcher(), new Stopwatch());
 204         $loop = 1;
 205         $dispatchedEvents = 0;
 206         $dispatcher->addListener('foo', $listener1 = function () use ($dispatcher, &$loop) {
 207             ++$loop;
 208             if (2 == $loop) {
 209                 $dispatcher->dispatch('foo');
 210             }
 211         });
 212         $dispatcher->addListener('foo', function () use (&$dispatchedEvents) {
 213             ++$dispatchedEvents;
 214         });
 215
 216         $dispatcher->dispatch('foo');
 217
 218         $this->assertSame(2, $dispatchedEvents);
 219     }
 220
 221     public function testDispatchReusedEventNested()
 222     {
 223         $nestedCall = false;
 224         $dispatcher = new TraceableEventDispatcher(new EventDispatcher(), new Stopwatch());
 225         $dispatcher->addListener('foo', function (Event $e) use ($dispatcher) {
 226             $dispatcher->dispatch('bar', $e);
 227         });
 228         $dispatcher->addListener('bar', function (Event $e) use (&$nestedCall) {
 229             $nestedCall = true;
 230         });
 231
 232         $this->assertFalse($nestedCall);
 233         $dispatcher->dispatch('foo');
 234         $this->assertTrue($nestedCall);
 235     }
 236
 237     public function testListenerCanRemoveItselfWhenExecuted()
 238     {
 239         $eventDispatcher = new TraceableEventDispatcher(new EventDispatcher(), new Stopwatch());
 240         $listener1 = function ($event, $eventName, EventDispatcherInterface $dispatcher) use (&$listener1) {
 241             $dispatcher->removeListener('foo', $listener1);
 242         };
 243         $eventDispatcher->addListener('foo', $listener1);
 244         $eventDispatcher->addListener('foo', function () {});
 245         $eventDispatcher->dispatch('foo');
 246
 247         $this->assertCount(1, $eventDispatcher->getListeners('foo'), 'expected listener1 to be removed');
 248     }
 249 }
 250
 251 class EventSubscriber implements EventSubscriberInterface
 252 {
 253     public static function getSubscribedEvents()
 254     {
 255         return array('foo' => 'call');
 256     }
 257 }