Client factory

Author: WyriHaximus

src/Factory.php

@@ -0,0 +1,103 @@
+<?php declare(strict_types=1);
+
+namespace ApiClients\Foundation;
+
+use ApiClients\Foundation\Hydrator\Factory as HydratorFactory;
+use ApiClients\Foundation\Hydrator\Hydrator;
+use ApiClients\Foundation\Hydrator\Options as HydratorOptions;
+use ApiClients\Foundation\Transport\Client as TransportClient;
+use ApiClients\Foundation\Transport\Factory as TransportFactory;
+use ApiClients\Foundation\Transport\Options as TransportOptions;
+use Interop\Container\ContainerInterface;
+use League\Container\Container;
+use League\Container\ReflectionContainer;
+use League\Event\Emitter;
+use League\Event\EmitterInterface;
+use League\Tactician\CommandBus;
+use League\Tactician\Container\ContainerLocator;
+use League\Tactician\Handler\CommandHandlerMiddleware;
+use League\Tactician\Handler\CommandNameExtractor\ClassNameExtractor;
+use League\Tactician\Handler\MethodNameInflector\HandleInflector;
+use React\EventLoop\LoopInterface;
+
+final class Factory
+{
+    public static function create(
+        LoopInterface $loop = null,
+        ContainerInterface $wrappedContainer = null,
+        array $options = []
+    ): Client {
+        $container = self::createContainer($wrappedContainer);
+
+        $container->share(EmitterInterface::class, new Emitter());
+        $container->share(TransportClient::class, self::createTransport($container, $loop, $options));
+        $container->share(Hydrator::class, self::createHydrator($container, $options));
+        $container->share(CommandBus::class, function () use ($container) {
+            return self::createCommandBus($container);
+        });
+
+        return new Client(
+            $container
+        );
+    }
+
+    private static function createContainer(ContainerInterface $wrappedContainer = null): Container
+    {
+        $container = new Container();
+        $container->delegate(new ReflectionContainer());
+
+        if ($wrappedContainer instanceof ContainerInterface) {
+            $container->delegate($wrappedContainer);
+        }
+
+        return $container;
+    }
+
+    private static function createCommandBus(ContainerInterface $container): CommandBus
+    {
+        $commandToHandlerMap = self::mapCommandsToHandlers($container->get(EmitterInterface::class));
+
+        $containerLocator = new ContainerLocator(
+            $container,
+            $commandToHandlerMap
+        );
+
+        $commandHandlerMiddleware = new CommandHandlerMiddleware(
+            new ClassNameExtractor(),
+            $containerLocator,
+            new HandleInflector()
+        );
+
+        return new CommandBus([
+            $commandHandlerMiddleware,
+        ]);
+    }
+
+    private static function mapCommandsToHandlers(Emitter $emitter): array
+    {
+        return $emitter->emit(CommandLocatorEvent::create())->getMap();
+    }
+
+    private static function createTransport(
+        ContainerInterface $container,
+        LoopInterface $loop = null,
+        array $options = []
+    ): TransportClient {
+        $transport = TransportFactory::create($loop, $options);
+        $container->share(LoopInterface::class, $transport->getLoop());
+        return $transport;
+    }
+
+    private static function createHydrator(ContainerInterface $container, array $options = [])
+    {
+        if (isset($options[TransportOptions::HYDRATOR]) && $options[TransportOptions::HYDRATOR] instanceof Hydrator) {
+            return $options[TransportOptions::HYDRATOR];
+        }
+
+        if (!isset($options[TransportOptions::HYDRATOR_OPTIONS])) {
+            throw new \Exception('Missing Hydrator options');
+        }
+
+        return HydratorFactory::create($options[TransportOptions::HYDRATOR_OPTIONS]);
+    }
+}

tests/FactoryTest.php

@@ -0,0 +1,58 @@
+<?php declare(strict_types=1);
+
+namespace ApiClients\Tests\Foundation;
+
+use ApiClients\Foundation\Client;
+use ApiClients\Foundation\CommandLocatorEvent;
+use ApiClients\Foundation\Factory;
+use ApiClients\Foundation\Transport\Options;
+use ApiClients\Tools\TestUtilities\TestCase;
+use League\Container\Container;
+use League\Event\CallbackListener;
+use League\Event\Emitter;
+use League\Event\EmitterInterface;
+use League\Tactician\Exception\MissingHandlerException;
+use React\EventLoop\LoopInterface;
+
+final class FactoryTest extends TestCase
+{
+    public function testCreate()
+    {
+        $loop = $this->prophesize(LoopInterface::class);
+
+        $client = Factory::create(
+            $loop->reveal(),
+            new Container(),
+            [
+                Options::HYDRATOR_OPTIONS => [],
+            ]
+        );
+
+        $this->assertInstanceOf(Client::class, $client);
+
+        $container = $client->getContainer();
+
+        $called = false;
+        $container->get(EmitterInterface::class)->addListener(
+            CommandLocatorEvent::NAME,
+            CallbackListener::fromCallable(
+                function (CommandLocatorEvent $event) use (&$called) {
+                    //$this->assertSame([], $event->getMap());
+                    $called = true;
+                }
+            )
+        );
+
+        $this->assertFalse($called);
+
+        try {
+            $client->handle(new class() {});
+        } catch (\Throwable $exception) {
+
+        }
+
+        $this->assertTrue($called);
+        $this->assertTrue(isset($exception));
+        $this->assertInstanceOf(MissingHandlerException::class, $exception);
+    }
+}