Allow to remove lazy listeners

src/Event/EventDispatcher.php

@@ -4,6 +4,7 @@
 
 namespace PhpSchool\PhpWorkshop\Event;
 
+use PhpSchool\PhpWorkshop\Listener\LazyContainerListener;
 use PhpSchool\PhpWorkshop\Result\ResultInterface;
 use PhpSchool\PhpWorkshop\ResultAggregator;
 
@@ -81,6 +82,10 @@ private function attachListener(string $eventName, callable $callback): void
     public function removeListener(string $eventName, callable $callback): void
     {
         foreach ($this->listeners[$eventName] ?? [] as $key => $listener) {
+            if ($listener instanceof LazyContainerListener) {
+                $listener = $listener->getWrapped();
+            }
+
             if ($listener === $callback) {
                 unset($this->listeners[$eventName][$key]);
                 $this->listeners[$eventName] = array_values($this->listeners[$eventName]);

src/Factory/EventDispatcherFactory.php

@@ -4,6 +4,7 @@
 
 namespace PhpSchool\PhpWorkshop\Factory;
 
+use PhpSchool\PhpWorkshop\Listener\LazyContainerListener;
 use Psr\Container\ContainerInterface;
 use PhpSchool\PhpWorkshop\Event\EventDispatcher;
 use PhpSchool\PhpWorkshop\Event\ContainerListenerHelper;
@@ -106,18 +107,10 @@ private function attachListeners(
                     );
                 }
 
-                $dispatcher->listen($eventName, function (...$args) use ($container, $listener) {
-                    /** @var object $service */
-                    $service = $container->get($listener->getService());
-
-                    if (!method_exists($service, $listener->getMethod())) {
-                        throw new InvalidArgumentException(
-                            sprintf('Method "%s" does not exist on "%s"', $listener->getMethod(), get_class($service))
-                        );
-                    }
-
-                    $service->{$listener->getMethod()}(...$args);
-                });
+                $dispatcher->listen(
+                    $eventName,
+                    new LazyContainerListener($container, $listener)
+                );
                 return;
             }
 

src/Listener/LazyContainerListener.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace PhpSchool\PhpWorkshop\Listener;
+
+use PhpSchool\PhpWorkshop\Event\ContainerListenerHelper;
+use PhpSchool\PhpWorkshop\Exception\InvalidArgumentException;
+use Psr\Container\ContainerInterface;
+
+class LazyContainerListener
+{
+    /**
+     * @var ContainerInterface
+     */
+    private $container;
+
+    /**
+     * @var ContainerListenerHelper
+     */
+    private $listener;
+
+    public function __construct(ContainerInterface $container, ContainerListenerHelper $listener)
+    {
+        $this->container = $container;
+        $this->listener = $listener;
+    }
+
+    /**
+     * @param mixed ...$args
+     */
+    public function __invoke(...$args): void
+    {
+        /** @var object $service */
+        $service = $this->container->get($this->listener->getService());
+
+        if (!method_exists($service, $this->listener->getMethod())) {
+            throw new InvalidArgumentException(
+                sprintf('Method "%s" does not exist on "%s"', $this->listener->getMethod(), get_class($service))
+            );
+        }
+
+        $service->{$this->listener->getMethod()}(...$args);
+    }
+
+    /**
+     * @return callable
+     */
+    public function getWrapped(): callable
+    {
+        /** @var callable $listener */
+        $listener =  [
+            $this->container->get($this->listener->getService()),
+            $this->listener->getMethod()
+        ];
+
+        return $listener;
+    }
+}

test/Event/EventDispatcherTest.php

@@ -2,12 +2,14 @@
 
 namespace PhpSchool\PhpWorkshopTest\Event;
 
+use PhpSchool\PhpWorkshop\Event\ContainerListenerHelper;
 use PhpSchool\PhpWorkshop\Event\Event;
 use PhpSchool\PhpWorkshop\Event\EventDispatcher;
-use PhpSchool\PhpWorkshop\Event\EventInterface;
+use PhpSchool\PhpWorkshop\Listener\LazyContainerListener;
 use PhpSchool\PhpWorkshop\Result\ResultInterface;
 use PhpSchool\PhpWorkshop\ResultAggregator;
 use PHPUnit\Framework\TestCase;
+use Psr\Container\ContainerInterface;
 
 class EventDispatcherTest extends TestCase
 {
@@ -161,4 +163,62 @@ public function testRemoveListener(): void
 
         $this->assertEquals([], $this->eventDispatcher->getListeners());
     }
+
+    public function testRemoveLazyListeners(): void
+    {
+        $container = $this->createMock(ContainerInterface::class);
+
+        $myListener = new class {
+            public function __invoke()
+            {
+            }
+        };
+
+        $container->expects($this->any())
+            ->method('get')
+            ->with('my-listener')
+            ->willReturn($myListener);
+
+        $lazy = new LazyContainerListener(
+            $container,
+            new ContainerListenerHelper('my-listener')
+        );
+
+        $this->eventDispatcher->listen('some-event', $lazy);
+
+        $this->assertEquals(['some-event' => [$lazy]], $this->eventDispatcher->getListeners());
+
+        $this->eventDispatcher->removeListener('some-event', [$myListener, '__invoke']);
+
+        $this->assertEquals([], $this->eventDispatcher->getListeners());
+    }
+
+    public function testRemoveLazyListenersWithAlternateMethod(): void
+    {
+        $container = $this->createMock(ContainerInterface::class);
+
+        $myListener = new class {
+            public function myMethod()
+            {
+            }
+        };
+
+        $container->expects($this->any())
+            ->method('get')
+            ->with('my-listener')
+            ->willReturn($myListener);
+
+        $lazy = new LazyContainerListener(
+            $container,
+            new ContainerListenerHelper('my-listener', 'myMethod')
+        );
+
+        $this->eventDispatcher->listen('some-event', $lazy);
+
+        $this->assertEquals(['some-event' => [$lazy]], $this->eventDispatcher->getListeners());
+
+        $this->eventDispatcher->removeListener('some-event', [$myListener, 'myMethod']);
+
+        $this->assertEquals([], $this->eventDispatcher->getListeners());
+    }
 }

test/Listener/LazyContainerListenerTest.php

@@ -0,0 +1,94 @@
+<?php
+
+namespace PhpSchool\PhpWorkshopTest\Listener;
+
+use PhpSchool\PhpWorkshop\Event\ContainerListenerHelper;
+use PhpSchool\PhpWorkshop\Event\Event;
+use PhpSchool\PhpWorkshop\Exception\InvalidArgumentException;
+use PhpSchool\PhpWorkshop\Listener\LazyContainerListener;
+use PHPUnit\Framework\TestCase;
+use Psr\Container\ContainerInterface;
+
+class LazyContainerListenerTest extends TestCase
+{
+    public function testExceptionIsThrownIfServiceMethodDoesNotExist(): void
+    {
+        $myListener = new class {
+            public function __invoke()
+            {
+            }
+        };
+
+        $class = get_class($myListener);
+
+        self::expectException(InvalidArgumentException::class);
+        self::expectExceptionMessage(sprintf('Method "myMethod" does not exist on "%s"', $class));
+
+        $container = $this->createMock(ContainerInterface::class);
+
+        $container->expects($this->any())
+            ->method('get')
+            ->with('my-listener')
+            ->willReturn($myListener);
+
+        $lazy = new LazyContainerListener(
+            $container,
+            new ContainerListenerHelper('my-listener', 'myMethod')
+        );
+
+        $lazy->__invoke(new Event('some-event'));
+    }
+
+    public function testThatUnderlyingListenerIsCalled(): void
+    {
+        $myListener = new class {
+            public $called = false;
+            public function __invoke()
+            {
+                $this->called = true;
+            }
+        };
+
+        $container = $this->createMock(ContainerInterface::class);
+
+        $container->expects($this->any())
+            ->method('get')
+            ->with('my-listener')
+            ->willReturn($myListener);
+
+        $lazy = new LazyContainerListener(
+            $container,
+            new ContainerListenerHelper('my-listener')
+        );
+
+        $lazy->__invoke(new Event('some-event'));
+
+        self::assertTrue($myListener->called);
+    }
+
+    public function testWrappedReturnsUnderlyingListener(): void
+    {
+        $myListener = new class {
+            public function __invoke()
+            {
+            }
+        };
+
+        $container = $this->createMock(ContainerInterface::class);
+
+        $container->expects($this->any())
+            ->method('get')
+            ->with('my-listener')
+            ->willReturn($myListener);
+
+        $lazy = new LazyContainerListener(
+            $container,
+            new ContainerListenerHelper('my-listener', '__invoke')
+        );
+
+        $wrapped = $lazy->getWrapped();
+        self::assertIsArray($wrapped);
+        self::assertEquals($myListener, $wrapped[0]);
+        self::assertEquals('__invoke', $wrapped[1]);
+    }
+}