feat(runtime): add dispatch helper and refactor HttpRepository

wilcorrea · wilcorrea · commit f61e00392dea · 2025-11-17T18:27:54.000-03:00
Add new dispatch() runtime helper function to handle event dispatching
through the container's EventDispatcherInterface. This prevents
circular dependency issues when HttpRepository was directly injecting
the dispatcher.

Refactor HttpRepository to use the new dispatch() function instead of
injecting EventDispatcherInterface, resolving application loop issues.

Add comprehensive tests validating that dispatch() correctly uses the
EventDispatcherInterface from the container with proper mock injection
and cleanup.
diff --git a/src/Infrastructure/Repository/HttpRepository.php b/src/Infrastructure/Repository/HttpRepository.php
@@ -9,7 +9,6 @@
 use GuzzleHttp\Exception\ClientException;
 use GuzzleHttp\Exception\GuzzleException;
 use Hyperf\Guzzle\ClientFactory;
-use Psr\EventDispatcher\EventDispatcherInterface;
 use Psr\Http\Message\ResponseInterface;
 use Serendipity\Domain\Contract\Support\ThrownFactory;
 use Serendipity\Domain\Event\RequestExecutedEvent;
@@ -19,26 +18,23 @@
 
 use function Constructo\Json\encode;
 use function Hyperf\Support\make;
+use function Serendipity\Runtime\dispatch;
 
 abstract class HttpRepository
 {
     private readonly Client $client;
 
     private readonly array $options;
 
-    private readonly EventDispatcherInterface $dispatcher;
-
     private readonly ThrownFactory $thrownFactory;
 
     public function __construct(
         ClientFactory $clientFactory,
-        ?EventDispatcherInterface $dispatcher = null,
         ?ThrownFactory $thrownFactory = null,
     ) {
         $this->options = $this->options();
         $this->client = $clientFactory->create($this->options);
 
-        $this->dispatcher = $dispatcher ?? make(EventDispatcherInterface::class);
         $this->thrownFactory = $thrownFactory ?? make(HyperfThrownFactory::class);
     }
 
@@ -106,6 +102,6 @@ private function dispatch(array $options, string $method, string $uri, ?Message
     {
         $options = array_merge($this->options, $options);
         $event = new RequestExecutedEvent($method, $uri, $options, $message);
-        $this->dispatcher->dispatch($event);
+        dispatch($event);
     }
 }
diff --git a/src/_/runtime.php b/src/_/runtime.php
@@ -5,6 +5,9 @@
 namespace Serendipity\Runtime;
 
 use Hyperf\Coroutine\Coroutine;
+use Psr\EventDispatcher\EventDispatcherInterface;
+
+use function Hyperf\Support\make;
 
 if (! function_exists(__NAMESPACE__ . '\invoke')) {
     function invoke(callable $callback, mixed ...$args): mixed
@@ -20,3 +23,11 @@ function coroutine(callable $callback): int
         return Coroutine::create($callback);
     }
 }
+
+if (! function_exists(__NAMESPACE__ . '\dispatch')) {
+    function dispatch(object $event): void
+    {
+        $dispatcher = make(EventDispatcherInterface::class);
+        $dispatcher->dispatch($event);
+    }
+}
diff --git a/tests/Infrastructure/Repository/HttpRepositoryTest.php b/tests/Infrastructure/Repository/HttpRepositoryTest.php
@@ -10,15 +10,12 @@
 use GuzzleHttp\Exception\ConnectException;
 use Hyperf\Guzzle\ClientFactory;
 use PHPUnit\Framework\TestCase;
-use Psr\EventDispatcher\EventDispatcherInterface;
 use Psr\Http\Message\RequestInterface;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\StreamInterface;
 use Serendipity\Domain\Contract\Support\ThrownFactory;
-use Serendipity\Domain\Event\RequestExecutedEvent;
 use Serendipity\Domain\Exception\Parser\Thrown;
 use Serendipity\Domain\Exception\RepositoryException;
-use Serendipity\Domain\Exception\ThrowableType;
 
 class HttpRepositoryTest extends TestCase
 {
@@ -156,12 +153,8 @@ public function testShouldHandleClientExceptionWithResponse(): void
             ->with($exception)
             ->willReturn(Thrown::createFrom($exception));
 
-        $dispatcher = $this->createMock(EventDispatcherInterface::class);
-        $dispatcher->expects($this->once())
-            ->method('dispatch');
-
         try {
-            $repository = new HttpRepositoryTestMock($clientFactory, $dispatcher, $thrownFactory);
+            $repository = new HttpRepositoryTestMock($clientFactory, $thrownFactory);
             $repository->exposeRequest();
             $this->fail('Expected RepositoryException to be thrown');
         } catch (RepositoryException $e) {
@@ -195,86 +188,7 @@ public function testShouldHandleNonClientException(): void
             ->with($exception)
             ->willReturn(Thrown::createFrom($exception));
 
-        $repository = new HttpRepositoryTestMock($clientFactory, null, $thrownFactory);
+        $repository = new HttpRepositoryTestMock($clientFactory, $thrownFactory);
         $repository->exposeRequest();
     }
-
-    public function testShouldDispatchEventOnSuccess(): void
-    {
-        $stream = $this->createMock(StreamInterface::class);
-        $stream->expects($this->once())
-            ->method('getContents')
-            ->willReturn('{"message": "Success"}');
-
-        $response = $this->createMock(ResponseInterface::class);
-        $response->expects($this->once())
-            ->method('getHeaders')
-            ->willReturn([]);
-        $response->expects($this->once())
-            ->method('getBody')
-            ->willReturn($stream);
-
-        $client = $this->createMock(Client::class);
-        $client->expects($this->once())
-            ->method('request')
-            ->with('POST', '/api', ['json' => ['key' => 'value']])
-            ->willReturn($response);
-
-        $clientFactory = $this->createMock(ClientFactory::class);
-        $clientFactory->expects($this->once())
-            ->method('create')
-            ->willReturn($client);
-
-        $dispatcher = $this->createMock(EventDispatcherInterface::class);
-        $dispatcher->expects($this->once())
-            ->method('dispatch')
-            ->with($this->callback(fn($event) => $event instanceof RequestExecutedEvent
-                && $event->method === 'POST'
-                && $event->uri === '/api'
-                && isset($event->options['json'])
-                && $event->message !== null));
-
-        $repository = new HttpRepositoryTestMock($clientFactory, $dispatcher);
-        $repository->exposeRequest('POST', '/api', ['json' => ['key' => 'value']]);
-    }
-
-    public function testShouldDispatchEventOnFailure(): void
-    {
-        $exception = new ConnectException(
-            'Connection refused',
-            $this->createMock(RequestInterface::class)
-        );
-
-        $client = $this->createMock(Client::class);
-        $client->expects($this->once())
-            ->method('request')
-            ->with('POST', '/api', [])
-            ->willThrowException($exception);
-
-        $clientFactory = $this->createMock(ClientFactory::class);
-        $clientFactory->expects($this->once())
-            ->method('create')
-            ->willReturn($client);
-
-        $dispatcher = $this->createMock(EventDispatcherInterface::class);
-        $dispatcher->expects($this->once())
-            ->method('dispatch')
-            ->with($this->callback(fn($event) => $event instanceof RequestExecutedEvent
-                && $event->method === 'POST'
-                && $event->uri === '/api'
-                && $event->message !== null));
-
-        $thrownFactory = $this->createMock(ThrownFactory::class);
-        $thrownFactory->expects($this->once())
-            ->method('make')
-            ->with($exception)
-            ->willReturn(Thrown::createFrom($exception));
-
-        try {
-            $repository = new HttpRepositoryTestMock($clientFactory, $dispatcher, $thrownFactory);
-            $repository->exposeRequest('POST', '/api');
-        } catch (RepositoryException) {
-            // Expected exception
-        }
-    }
 }
diff --git a/tests/_/FunctionsRuntimeTest.php b/tests/_/FunctionsRuntimeTest.php
@@ -4,9 +4,14 @@
 
 namespace Serendipity\Test\_;
 
+use Hyperf\Context\ApplicationContext;
 use PHPUnit\Framework\TestCase;
+use Psr\Container\ContainerInterface;
+use Psr\EventDispatcher\EventDispatcherInterface;
+use stdClass;
 
 use function Serendipity\Runtime\coroutine;
+use function Serendipity\Runtime\dispatch;
 use function Serendipity\Runtime\invoke;
 
 final class FunctionsRuntimeTest extends TestCase
@@ -27,4 +32,122 @@ public function testCoroutineShouldReturnId(): void
     {
         $this->assertIsInt(coroutine(fn () => null));
     }
+
+    public function testDispatchShouldCallEventDispatcher(): void
+    {
+        $event = new class {
+            public string $type = 'test-event';
+        };
+
+        $tracker = new class {
+            public bool $dispatchCalled = false;
+
+            public ?object $receivedEvent = null;
+        };
+
+        $mockDispatcher = new readonly class ($tracker) implements EventDispatcherInterface {
+            public function __construct(
+                private object $tracker,
+            ) {
+            }
+
+            public function dispatch(object $event): object
+            {
+                $this->tracker->dispatchCalled = true;
+                $this->tracker->receivedEvent = $event;
+                return $event;
+            }
+        };
+
+        $originalContainer = $this->swapContainerDispatcher($mockDispatcher);
+
+        try {
+            dispatch($event);
+            $this->assertTrue($tracker->dispatchCalled, 'EventDispatcher::dispatch() should be called');
+            $this->assertSame($event, $tracker->receivedEvent, 'Event should be passed to the dispatcher');
+        } finally {
+            $this->restoreContainer($originalContainer);
+        }
+    }
+
+    public function testDispatchShouldAcceptAnyObject(): void
+    {
+        $event1 = new class {
+            public string $type = 'event1';
+        };
+        $event2 = new stdClass();
+
+        $tracker = new class {
+            public int $dispatchCount = 0;
+
+            public array $receivedEvents = [];
+        };
+
+        $mockDispatcher = new readonly class ($tracker) implements EventDispatcherInterface {
+            public function __construct(
+                private object $tracker,
+            ) {
+            }
+
+            public function dispatch(object $event): object
+            {
+                ++$this->tracker->dispatchCount;
+                $this->tracker->receivedEvents[] = $event;
+                return $event;
+            }
+        };
+
+        $originalContainer = $this->swapContainerDispatcher($mockDispatcher);
+
+        try {
+            dispatch($event1);
+            dispatch($event2);
+            $this->assertEquals(2, $tracker->dispatchCount, 'EventDispatcher::dispatch() should be called twice');
+            $this->assertCount(2, $tracker->receivedEvents, 'Should receive both events');
+            $this->assertSame($event1, $tracker->receivedEvents[0], 'The first event should match');
+            $this->assertSame($event2, $tracker->receivedEvents[1], 'The second event should match');
+        } finally {
+            $this->restoreContainer($originalContainer);
+        }
+    }
+
+    private function swapContainerDispatcher(EventDispatcherInterface $dispatcher): ?ContainerInterface
+    {
+        $originalContainer = null;
+        if (ApplicationContext::hasContainer()) {
+            $originalContainer = ApplicationContext::getContainer();
+        }
+
+        $container = new readonly class ($dispatcher) implements ContainerInterface {
+            public function __construct(private EventDispatcherInterface $dispatcher)
+            {
+            }
+
+            public function get(string $id): EventDispatcherInterface
+            {
+                return $this->dispatcher;
+            }
+
+            public function has(string $id): bool
+            {
+                return $id === EventDispatcherInterface::class;
+            }
+
+            public function make(string $name, array $parameters = []): EventDispatcherInterface
+            {
+                return $this->dispatcher;
+            }
+        };
+
+        ApplicationContext::setContainer($container);
+
+        return $originalContainer;
+    }
+
+    private function restoreContainer(?ContainerInterface $container): void
+    {
+        if ($container !== null) {
+            ApplicationContext::setContainer($container);
+        }
+    }
 }
