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