public function testCookieIsNotUpdatedWithFalseSetCookieOnChange()
{
$listener = $this->getLocaleUpdateListener(array('cookie'), false);
$listener->onLocaleChange($this->getFilterLocaleSwitchEvent(false));
$addedListeners = $this->dispatcher->getListeners(KernelEvents::RESPONSE);
$this->assertSame(array(), $addedListeners);
}
public function testConsoleEvent()
{
$dispatcher = new EventDispatcher();
$listener = new DebugHandlersListener(null);
$app = $this->getMock('Symfony\\Component\\Console\\Application');
$app->expects($this->once())->method('getHelperSet')->will($this->returnValue(new HelperSet()));
$command = new Command(__FUNCTION__);
$command->setApplication($app);
$event = new ConsoleEvent($command, new ArgvInput(), new ConsoleOutput());
$dispatcher->addSubscriber($listener);
$xListeners = array(KernelEvents::REQUEST => array(array($listener, 'configure')), ConsoleEvents::COMMAND => array(array($listener, 'configure')));
$this->assertSame($xListeners, $dispatcher->getListeners());
$exception = null;
$eHandler = new ErrorHandler();
set_error_handler(array($eHandler, 'handleError'));
set_exception_handler(array($eHandler, 'handleException'));
try {
$dispatcher->dispatch(ConsoleEvents::COMMAND, $event);
} catch (\Exception $exception) {
}
restore_exception_handler();
restore_error_handler();
if (null !== $exception) {
throw $exception;
}
$this->assertSame(array(), $dispatcher->getListeners());
$xHandler = $eHandler->setExceptionHandler('var_dump');
$this->assertInstanceOf('Closure', $xHandler);
$app->expects($this->once())->method('renderException');
$xHandler(new \Exception());
}
/**
* Find event recorder
*
* @return EventRecorder|null
*/
private function findEventRecorder()
{
$listeners = $this->eventDispatcher->getListeners('beforeFeature');
foreach ($listeners as $listener) {
$formatter = isset($listener[0]) ? $listener[0] : null;
if (is_object($formatter) && get_class($formatter) === 'saimon7\\ParallelRunner\\Formatter\\EventRecorder') {
return $formatter;
}
}
return null;
}
public function testGetHasListeners()
{
$dispatcher = new EventDispatcher();
$this->assertFalse($dispatcher->hasListeners('foo'), '->hasListeners() returns false if the event has no listener');
$dispatcher->connect('foo', 'listenToFoo');
$this->assertEquals(true, $dispatcher->hasListeners('foo'), '->hasListeners() returns true if the event has some listeners');
$dispatcher->disconnect('foo', 'listenToFoo');
$this->assertFalse($dispatcher->hasListeners('foo'), '->hasListeners() returns false if the event has no listener');
$dispatcher->connect('bar', 'listenToBar');
$this->assertEquals(array('listenToBar'), $dispatcher->getListeners('bar'), '->getListeners() returns an array of listeners connected to the given event name');
$this->assertEquals(array(), $dispatcher->getListeners('foobar'), '->getListeners() returns an empty array if no listener are connected to the given event name');
}
public function testAddRemoveSubscriber()
{
$dispatcher = new EventDispatcher();
$tdispatcher = new TraceableEventDispatcher($dispatcher, new Stopwatch());
$subscriber = new EventSubscriber();
$tdispatcher->addSubscriber($subscriber);
$listeners = $dispatcher->getListeners('foo');
$this->assertCount(1, $listeners);
$this->assertSame(array($subscriber, 'call'), $listeners[0]);
$tdispatcher->removeSubscriber($subscriber);
$this->assertCount(0, $dispatcher->getListeners('foo'));
}
/**
* {@inheritdoc}
*/
public function getListeners($eventName = null)
{
if (null == $eventName || self::BEFORE_ALL_EVENTS === $eventName) {
return parent::getListeners($eventName);
}
return array_merge(parent::getListeners(self::BEFORE_ALL_EVENTS), parent::getListeners($eventName), parent::getListeners(self::AFTER_ALL_EVENTS));
}
public function testGetListenersWhenAddedCallbackListenerIsRemoved()
{
$listener = function () {
};
$this->dispatcher->addListener('foo', $listener);
$this->dispatcher->removeListener('foo', $listener);
$this->assertSame(array(), $this->dispatcher->getListeners());
}
/**
* Removes old listener from dispatcher
*
* @param EventDispatcher $dispatcher
*/
private function removeOldListener(EventDispatcher $dispatcher)
{
$listeners = $dispatcher->getListeners(KernelEvents::REQUEST);
foreach ($listeners as $listener) {
if (is_array($listener) && $listener[0] instanceof RouterListenerBase) {
$dispatcher->removeSubscriber($listener[0]);
}
}
}
/**
* Removes all registered event listeners.
*/
private function removeListeners()
{
$listeners = $this->dispatcher->getListeners();
foreach ($listeners as $event => $list) {
foreach ($list as $listener) {
$this->dispatcher->removeListener($event, $listener);
}
}
}
public function testRemoveSubscriberWithMultipleListeners()
{
$eventSubscriber = new TestEventSubscriberWithMultipleListeners();
$this->dispatcher->addSubscriber($eventSubscriber);
$this->assertTrue($this->dispatcher->hasListeners(self::preFoo));
$this->assertCount(2, $this->dispatcher->getListeners(self::preFoo));
$this->dispatcher->removeSubscriber($eventSubscriber);
$this->assertFalse($this->dispatcher->hasListeners(self::preFoo));
}
public function testShouldFindAndAttachListenersToDispatcher()
{
$dispatcher = new EventDispatcher();
// There are no listeners on new dispatcher
$this->assertEmpty($dispatcher->getListeners());
$this->instantiator->instantiate($dispatcher, __DIR__);
$listeners = $dispatcher->getListeners();
$this->assertNotEmpty($listeners);
$this->assertArrayHasKey('foo', $listeners);
}
public function getListeners($eventName = null)
{
if (null === $eventName) {
foreach ($this->listenerIds as $serviceEventName => $args) {
$this->lazyLoad($serviceEventName);
}
} else {
$this->lazyLoad($eventName);
}
return parent::getListeners($eventName);
}
/**
* @inheritdoc
*/
public function getListeners($eventName = null)
{
$processedListeners = array();
foreach (parent::getListeners($eventName) as $listener) {
if (is_string($listener)) {
$processedListeners[] = $this->getCallable($listener);
} else {
$processedListeners[] = $listener;
}
}
return $processedListeners;
}
/**
* {@inheritdoc}
*/
public function getListeners($eventName = null)
{
if ($eventName === null) {
return parent::getListeners($eventName);
}
$listeners = [];
foreach (parent::getListeners() as $name => $eventListeners) {
$namePattern = str_replace(["*", "#"], ["(\\w+)", "([\\w\\.]+)"], $name);
if (preg_match("~^{$namePattern}\$~", $eventName)) {
$listeners = array_merge($listeners, $eventListeners);
}
}
return $listeners;
}
/**
* @see AbstractDispatcherAdapter::get
*/
public function get($name)
{
return $this->dispatcher->getListeners($name);
}
public function getListeners($eventName = null)
{
return array_filter($this->eventDispatcher->getListeners($eventName));
}
/**
* @test
* We are not checking Laravel's listeners as its interface does not contain a getListeners function
*/
public function it_gets_listeners_from_the_symfony_dispatcher()
{
$this->symfony->getListeners(static::EVENT)->willReturn(['bar']);
$this->assertEquals(['bar'], $this->dispatcher->getListeners(static::EVENT));
}
