Removes client container connection

Client was leaking the applications container. When needed the
container can inject itself into handlers. There is no need to have this
in the client.

Author: jaapio

src/Client.php

@@ -8,39 +8,17 @@
 
 final class Client implements ClientInterface
 {
-    /**
-     * @var ContainerInterface
-     */
-    private $container;
-
     /**
      * @var CommandBusInterface
      */
     private $commandBus;
 
     /**
-     * @param ContainerInterface $container
-     */
-    public function __construct(ContainerInterface $container)
-    {
-        $this->container = $container;
-        $this->commandBus = $this->container->get(CommandBusInterface::class);
-    }
-
-    /**
-     * @return ContainerInterface
-     */
-    public function getContainer(): ContainerInterface
-    {
-        return $this->container;
-    }
-
-    /**
-     * @return mixed
+     * @param CommandBusInterface $commandBus
      */
-    public function getFromContainer(string $id)
+    public function __construct(CommandBusInterface $commandBus)
     {
-        return $this->container->get($id);
+        $this->commandBus = $commandBus;
     }
 
     /**

src/ClientInterface.php

@@ -7,16 +7,6 @@
 
 interface ClientInterface
 {
-    /**
-     * @return ContainerInterface
-     */
-    public function getContainer(): ContainerInterface;
-
-    /**
-     * @return mixed
-     */
-    public function getFromContainer(string $id);
-
     /**
      * @param $command
      * @return CancellablePromiseInterface

src/Factory.php

@@ -19,12 +19,13 @@ public static function create(
         LoopInterface $loop,
         array $options = []
     ): Client {
+        $container = self::createContainer($loop, $options);
         return new Client(
-            self::createContainer($loop, $options)
+            $container->get(CommandBusInterface::class)
         );
     }
 
-    private static function createContainer(LoopInterface $loop, array $options): ContainerInterface
+    public static function createContainer(LoopInterface $loop, array $options): ContainerInterface
     {
         $container = new ContainerBuilder();
 

tests/ClientTest.php

@@ -40,21 +40,8 @@ public function handle($command)
         );
 
         $commandBus = new CommandBus($loop, $handlerMiddleware);
+        $client = new Client($commandBus);
 
-        $container = ContainerBuilder::buildDevContainer();
-        $container->set(CommandBusInterface::class, $commandBus);
-        $client = new Client($container);
-
-        $this->assertSame($container, $client->getContainer());
-        $this->assertSame($commandBus, $client->getFromContainer(CommandBusInterface::class));
         $this->assertSame($command, await($client->handle($command), $loop));
     }
-
-    /**
-     * @expectedException \DI\Definition\Exception\DefinitionException
-     */
-    public function testCommandBusMissing()
-    {
-        new Client(ContainerBuilder::buildDevContainer());
-    }
 }

tests/FactoryTest.php

@@ -19,14 +19,14 @@
 
 final class FactoryTest extends TestCase
 {
-    public function testCreate()
+    public function testcreateContainer()
     {
         $loop = LoopFactory::create();
 
         $stdClass = new \stdClass();
         $stdClass->foo = 'bar';
 
-        $client = Factory::create(
+        $container = Factory::createContainer(
             $loop,
             [
                 Options::HYDRATOR_OPTIONS => [],
@@ -42,16 +42,37 @@ public function testCreate()
             ]
         );
 
-        $this->assertInstanceOf(Client::class, $client);
-
-        $container = $client->getContainer();
         $this->assertInstanceOf(LoopInterface::class, $container->get(LoopInterface::class));
         $this->assertSame($loop, $container->get(LoopInterface::class));
         $this->assertInstanceOf(Hydrator::class, $container->get(Hydrator::class));
         $this->assertInstanceOf(TransportClient::class, $container->get(ClientInterface::class));
         $this->assertInstanceOf(\stdClass::class, $container->get(\stdClass::class));
         $this->assertSame($stdClass, $container->get(\stdClass::class));
         $this->assertSame('bar', $container->get(\stdClass::class)->foo);
+    }
+
+    public function testCreate()
+    {
+        $loop = LoopFactory::create();
+
+        $stdClass = new \stdClass();
+        $stdClass->foo = 'bar';
+
+        $client = Factory::create(
+            $loop,
+            [
+                Options::HYDRATOR_OPTIONS => [],
+                Options::TRANSPORT_OPTIONS => [
+                    TransportOptions::USER_AGENT => 'User Agent',
+                ],
+                Options::TRANSPORT_OPTIONS => [
+                    TransportOptions::USER_AGENT => '',
+                ],
+                Options::CONTAINER_DEFINITIONS => [
+                    \stdClass::class => $stdClass,
+                ],
+            ]
+        );
 
         try {
             await($client->handle(new class() {}), $loop);
@@ -69,12 +90,12 @@ public function testCreate()
      */
     public function testCreateMissingHydratorOptions()
     {
-        Factory::create(
+        Factory::createContainer(
             LoopFactory::create(),
             [
                 Options::TRANSPORT_OPTIONS => [],
             ]
-        )->getContainer()->get(Hydrator::class);
+        )->get(Hydrator::class);
     }
 
     /**
@@ -83,11 +104,11 @@ public function testCreateMissingHydratorOptions()
      */
     public function testCreateMissingTransportOptions()
     {
-        Factory::create(
+        Factory::createContainer(
             LoopFactory::create(),
             [
                 Options::HYDRATOR_OPTIONS => [],
             ]
-        )->getContainer()->get(ClientInterface::class);
+        )->get(ClientInterface::class);
     }
 }