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('data', $listeners['foo.closure']);
 114         unset($listeners['foo.closure']['data']);
 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         unset($listeners['foo.closure']['data']);
 122         $this->assertEquals(array('foo.closure' => array('event' => 'foo', 'pretty' => 'closure', 'priority' => 5)), $listeners);
 123         $this->assertEquals(array(), $tdispatcher->getNotCalledListeners());
 124     }
 125
 126     public function testGetCalledListenersNested()
 127     {
 128         $tdispatcher = null;
 129         $dispatcher = new TraceableEventDispatcher(new EventDispatcher(), new Stopwatch());
 130         $dispatcher->addListener('foo', function (Event $event, $eventName, $dispatcher) use (&$tdispatcher) {
 131             $tdispatcher = $dispatcher;
 132             $dispatcher->dispatch('bar');
 133         });
 134         $dispatcher->addListener('bar', function (Event $event) {});
 135         $dispatcher->dispatch('foo');
 136         $this->assertSame($dispatcher, $tdispatcher);
 137         $this->assertCount(2, $dispatcher->getCalledListeners());
 138     }
 139
 140     public function testLogger()
 141     {
 142         $logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
 143
 144         $dispatcher = new EventDispatcher();
 145         $tdispatcher = new TraceableEventDispatcher($dispatcher, new Stopwatch(), $logger);
 146         $tdispatcher->addListener('foo', $listener1 = function () {});
 147         $tdispatcher->addListener('foo', $listener2 = function () {});
 148
 149         $logger->expects($this->at(0))->method('debug')->with('Notified event "{event}" to listener "{listener}".', array('event' => 'foo', 'listener' => 'closure'));
 150         $logger->expects($this->at(1))->method('debug')->with('Notified event "{event}" to listener "{listener}".', array('event' => 'foo', 'listener' => 'closure'));
 151
 152         $tdispatcher->dispatch('foo');
 153     }
 154
 155     public function testLoggerWithStoppedEvent()
 156     {
 157         $logger = $this->getMockBuilder('Psr\Log\LoggerInterface')->getMock();
 158
 159         $dispatcher = new EventDispatcher();
 160         $tdispatcher = new TraceableEventDispatcher($dispatcher, new Stopwatch(), $logger);
 161         $tdispatcher->addListener('foo', $listener1 = function (Event $event) { $event->stopPropagation(); });
 162         $tdispatcher->addListener('foo', $listener2 = function () {});
 163
 164         $logger->expects($this->at(0))->method('debug')->with('Notified event "{event}" to listener "{listener}".', array('event' => 'foo', 'listener' => 'closure'));
 165         $logger->expects($this->at(1))->method('debug')->with('Listener "{listener}" stopped propagation of the event "{event}".', array('event' => 'foo', 'listener' => 'closure'));
 166         $logger->expects($this->at(2))->method('debug')->with('Listener "{listener}" was not called for event "{event}".', array('event' => 'foo', 'listener' => 'closure'));
 167
 168         $tdispatcher->dispatch('foo');
 169     }
 170
 171     public function testDispatchCallListeners()
 172     {
 173         $called = array();
 174
 175         $dispatcher = new EventDispatcher();
 176         $tdispatcher = new TraceableEventDispatcher($dispatcher, new Stopwatch());
 177         $tdispatcher->addListener('foo', function () use (&$called) { $called[] = 'foo1'; }, 10);
 178         $tdispatcher->addListener('foo', function () use (&$called) { $called[] = 'foo2'; }, 20);
 179
 180         $tdispatcher->dispatch('foo');
 181
 182         $this->assertSame(array('foo2', 'foo1'), $called);
 183     }
 184
 185     public function testDispatchNested()
 186     {
 187         $dispatcher = new TraceableEventDispatcher(new EventDispatcher(), new Stopwatch());
 188         $loop = 1;
 189         $dispatchedEvents = 0;
 190         $dispatcher->addListener('foo', $listener1 = function () use ($dispatcher, &$loop) {
 191             ++$loop;
 192             if (2 == $loop) {
 193                 $dispatcher->dispatch('foo');
 194             }
 195         });
 196         $dispatcher->addListener('foo', function () use (&$dispatchedEvents) {
 197             ++$dispatchedEvents;
 198         });
 199
 200         $dispatcher->dispatch('foo');
 201
 202         $this->assertSame(2, $dispatchedEvents);
 203     }
 204
 205     public function testDispatchReusedEventNested()
 206     {
 207         $nestedCall = false;
 208         $dispatcher = new TraceableEventDispatcher(new EventDispatcher(), new Stopwatch());
 209         $dispatcher->addListener('foo', function (Event $e) use ($dispatcher) {
 210             $dispatcher->dispatch('bar', $e);
 211         });
 212         $dispatcher->addListener('bar', function (Event $e) use (&$nestedCall) {
 213             $nestedCall = true;
 214         });
 215
 216         $this->assertFalse($nestedCall);
 217         $dispatcher->dispatch('foo');
 218         $this->assertTrue($nestedCall);
 219     }
 220
 221     public function testListenerCanRemoveItselfWhenExecuted()
 222     {
 223         $eventDispatcher = new TraceableEventDispatcher(new EventDispatcher(), new Stopwatch());
 224         $listener1 = function ($event, $eventName, EventDispatcherInterface $dispatcher) use (&$listener1) {
 225             $dispatcher->removeListener('foo', $listener1);
 226         };
 227         $eventDispatcher->addListener('foo', $listener1);
 228         $eventDispatcher->addListener('foo', function () {});
 229         $eventDispatcher->dispatch('foo');
 230
 231         $this->assertCount(1, $eventDispatcher->getListeners('foo'), 'expected listener1 to be removed');
 232     }
 233 }
 234
 235 class EventSubscriber implements EventSubscriberInterface
 236 {
 237     public static function getSubscribedEvents()
 238     {
 239         return array('foo' => 'call');
 240     }
 241 }