PHP EventManager::getListeners方法代码示例

 public function testEventListeners()
 {
     $events = new EventManager();
     $events->attachAggregate($this->strategy);
     $listeners = $events->getListeners(MvcEvent::EVENT_DISPATCH_ERROR);
     $expectedCallback = array($this->strategy, 'prepareExceptionViewModel');
     $expectedPriority = 1;
     $found = false;
     foreach ($listeners as $listener) {
         $callback = $listener->getCallback();
         if ($callback === $expectedCallback) {
             if ($listener->getMetadatum('priority') == $expectedPriority) {
                 $found = true;
                 break;
             }
         }
     }
     $this->assertTrue($found, 'MvcEvent::EVENT_DISPATCH_ERROR not found');
     $listeners = $events->getListeners(MvcEvent::EVENT_RENDER_ERROR);
     $expectedCallback = array($this->strategy, 'prepareExceptionViewModel');
     $expectedPriority = 1;
     $found = false;
     foreach ($listeners as $listener) {
         $callback = $listener->getCallback();
         if ($callback === $expectedCallback) {
             if ($listener->getMetadatum('priority') == $expectedPriority) {
                 $found = true;
                 break;
             }
         }
     }
     $this->assertTrue($found, 'MvcEvent::EVENT_RENDER_ERROR not found');
 }

 public function testCanDetachListenersFromEventManager()
 {
     $events = new EventManager();
     $events->attachAggregate($this->strategy);
     $this->assertEquals(1, count($events->getListeners(MvcEvent::EVENT_RENDER)));
     $events->detachAggregate($this->strategy);
     $this->assertEquals(0, count($events->getListeners(MvcEvent::EVENT_RENDER)));
 }

 /**
  * 测试能正常注册身份验证过程中的事件监听器。
  */
 public function testEventManagerHasDefaultListeners()
 {
     $eventManager = new EventManager();
     $eventManager->attach($this->stub);
     $this->assertFalse($eventManager->getListeners(Event::EVENT_VERIFY_POST)->isEmpty());
     $this->assertFalse($eventManager->getListeners(Event::EVENT_TOKEN_POST)->isEmpty());
     $this->assertFalse($eventManager->getListeners(Event::EVENT_FAILURE)->isEmpty());
 }

 public function testAttach()
 {
     $em = new EventManager();
     $this->assertEmpty($em->getListeners(ViewEvent::EVENT_RENDERER));
     $this->assertEmpty($em->getListeners(ViewEvent::EVENT_RESPONSE));
     $this->strategy->attach($em);
     $this->assertCount(1, $em->getListeners(ViewEvent::EVENT_RENDERER));
     $this->assertCount(1, $em->getListeners(ViewEvent::EVENT_RESPONSE));
 }

 public function testDetachesListeners()
 {
     $events = new EventManager();
     $events->attachAggregate($this->listener);
     $listeners = $events->getListeners(MvcEvent::EVENT_DISPATCH);
     $this->assertEquals(2, count($listeners));
     $events->detachAggregate($this->listener);
     $listeners = $events->getListeners(MvcEvent::EVENT_DISPATCH);
     $this->assertEquals(0, count($listeners));
 }

 public function testAttach()
 {
     $eventManager = new EventManager();
     $listener = new BodyClassListener(new BodyClass());
     $before = $eventManager->getListeners(\Zend\Mvc\MvcEvent::EVENT_DISPATCH);
     $this->assertCount(0, $before);
     $eventManager->attach($listener);
     $after = $eventManager->getListeners(\Zend\Mvc\MvcEvent::EVENT_DISPATCH);
     $this->assertCount(1, $after);
 }

 public function testEventSubscribers()
 {
     $manager = new EventManager();
     $this->assertCount(0, $manager->getListeners(ViewEvent::EVENT_RENDERER), 'Renderer listener before attach');
     $this->assertCount(0, $manager->getListeners(ViewEvent::EVENT_RESPONSE), 'Response listener before attach');
     $this->strategy->attach($manager);
     $this->assertCount(1, $manager->getListeners(ViewEvent::EVENT_RENDERER), 'Renderer listener after attach');
     $this->assertCount(1, $manager->getListeners(ViewEvent::EVENT_RESPONSE), 'Response listener after attach');
     $this->strategy->detach($manager);
     $this->assertCount(0, $manager->getListeners(ViewEvent::EVENT_RENDERER), 'Renderer listener after detach');
     $this->assertCount(0, $manager->getListeners(ViewEvent::EVENT_RESPONSE), 'Response listener after detach');
 }

 public function testListenerAttached()
 {
     $events = new EventManager();
     $events->attach($this->listener);
     $listeners = $events->getListeners(MvcEvent::EVENT_DISPATCH_ERROR);
     $this->assertEquals(1, count($listeners));
     $listeners = $events->getListeners(MvcEvent::EVENT_RENDER_ERROR);
     $this->assertEquals(1, count($listeners));
     $events->detach($this->listener);
     $listeners = $events->getListeners(MvcEvent::EVENT_DISPATCH_ERROR);
     $this->assertEquals(0, count($listeners));
     $listeners = $events->getListeners(MvcEvent::EVENT_RENDER_ERROR);
     $this->assertEquals(0, count($listeners));
 }

 public function testDetachesListeners()
 {
     $events = new EventManager();
     $events->attachAggregate($this->listener);
     $listeners = $events->getListeners('dispatch');
     $this->assertEquals(1, count($listeners));
     $events->detachAggregate($this->listener);
     $listeners = $events->getListeners('dispatch');
     $this->assertEquals(0, count($listeners));
 }

 public function testAttachesToRouteEventAtNegativePriority()
 {
     $events = new EventManager();
     $events->attach($this->listener);
     $listeners = $events->getListeners('route');
     $this->assertEquals(1, count($listeners));
     $this->assertTrue($listeners->hasPriority(-41));
     $callback = $listeners->getIterator()->current()->getCallback();
     $test     = array_shift($callback);
     $this->assertSame($this->listener, $test);
 }

 /**
  * {@inheritDoc}
  */
 public function removeListener($eventName, $listener)
 {
     $listeners = $this->eventManager->getListeners($eventName);
     foreach ($listeners as $callbackHanler) {
         $callback = $callbackHanler->getCallback();
         if (is_array($callback)) {
             if (is_array($listener)) {
                 if ($callback[0] === $listener[0] && $callback[1] === $listener[1]) {
                     return $this->eventManager->detach($callbackHanler);
                 }
             } else {
                 continue;
             }
         }
         if ($callback === $listener) {
             return $this->eventManager->detach($callbackHanler);
         }
     }
     return true;
 }

 public function testListenerAttachesDispatchEventAtExpectedPriority()
 {
     $events = new EventManager();
     $events->attachAggregate($this->listener);
     $listeners = $events->getListeners(MvcEvent::EVENT_DISPATCH);
     $expectedCallback = [$this->listener, 'injectActionHandles'];
     $expectedPriority = 1000;
     $found = false;
     foreach ($listeners as $listener) {
         $callback = $listener->getCallback();
         if ($callback === $expectedCallback) {
             if ($listener->getMetadatum('priority') == $expectedPriority) {
                 $found = true;
                 break;
             }
         }
     }
     $this->assertTrue($found, 'Listener not found');
 }

 /**
  * Retrieve an interable list of listeners for an event.
  *
  * Given an event and an event manager, returns an iterator with the
  * listeners for that event, in priority order.
  *
  * If $withPriority is true, the key values will be the priority at which
  * the given listener is attached.
  *
  * Do not pass $withPriority if you want to cast the iterator to an array,
  * as many listeners will likely have the same priority, and thus casting
  * will collapse to the last added.
  *
  * @param string $event
  * @param EventManager $events
  * @param bool $withPriority
  * @return \Traversable
  */
 private function getListenersForEvent($event, EventManager $events, $withPriority = false)
 {
     $listeners = $events->getListeners($event);
     return $this->traverseListeners($listeners, $withPriority);
 }

 public function testAttach()
 {
     $this->strategy->attach($this->em);
     $this->assertCount(1, $this->em->getListeners(ViewEvent::EVENT_RENDERER));
     $this->assertCount(1, $this->em->getListeners(ViewEvent::EVENT_RESPONSE));
 }

 public function testAttachAndDetachListener()
 {
     $events = new EventManager();
     $events->attach($this->listener);
     $listeners = $events->getListeners(MvcEvent::EVENT_FINISH);
     $this->assertEquals(1, count($listeners));
     $events->detach($this->listener);
     $listeners = $events->getListeners(MvcEvent::EVENT_FINISH);
     $this->assertEquals(0, count($listeners));
 }