Query bus

config/container.config.php

@@ -2,16 +2,21 @@
 
 use ZfrCommandBus\CommandBusInterface;
 use ZfrCommandBus\Container\SimpleCommandBusFactory;
+use ZfrCommandBus\Container\SimpleQueryBusFactory;
+use ZfrCommandBus\QueryBusInterface;
 use ZfrCommandBus\SimpleCommandBus;
+use ZfrCommandBus\SimpleQueryBus;
 
 return [
     'dependencies' => [
         'aliases' => [
             CommandBusInterface::class => SimpleCommandBus::class,
+            QueryBusInterface::class   => SimpleQueryBus::class,
         ],
 
         'factories' => [
             SimpleCommandBus::class => SimpleCommandBusFactory::class,
+            SimpleQueryBus::class   => SimpleQueryBusFactory::class,
         ],
     ]
 ];

src/CommandBusInterface.php

@@ -2,7 +2,7 @@
 
 namespace ZfrCommandBus;
 
-interface CommandBusInterface
+interface CommandBusInterface extends MessageBusInterface
 {
     /**
      * @param object $command

src/Container/SimpleQueryBusFactory.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace ZfrCommandBus\Container;
+
+use Psr\Container\ContainerInterface;
+use ZfrCommandBus\QueryBusInterface;
+use ZfrCommandBus\SimpleQueryBus;
+
+/**
+ * @author Daniel Gimenes
+ */
+final class SimpleQueryBusFactory
+{
+    /**
+     * @param ContainerInterface $container
+     *
+     * @return QueryBusInterface
+     */
+    public function __invoke(ContainerInterface $container): QueryBusInterface
+    {
+        /** @var array $config */
+        $config = $container->get('config');
+
+        return new SimpleQueryBus($container, $config['zfr_command_bus']['query_handlers'] ?? []);
+    }
+}

src/MessageBusInterface.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace ZfrCommandBus;
+
+/**
+ * @author Daniel Gimenes
+ */
+interface MessageBusInterface
+{
+    /**
+     * @param object $message
+     *
+     * @return array|void
+     */
+    public function dispatch($message);
+}

src/QueryBusInterface.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace ZfrCommandBus;
+
+/**
+ * @author Daniel Gimenes
+ */
+interface QueryBusInterface extends MessageBusInterface
+{
+    /**
+     * @param object $query
+     *
+     * @return array
+     */
+    public function dispatch($query): array;
+}

src/SimpleQueryBus.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace ZfrCommandBus;
+
+use Psr\Container\ContainerInterface;
+use ZfrCommandBus\Exception\InvalidArgumentException;
+use ZfrCommandBus\Exception\RuntimeException;
+
+/**
+ * @author Daniel Gimenes
+ */
+final class SimpleQueryBus implements QueryBusInterface
+{
+    /**
+     * @var ContainerInterface
+     */
+    private $container;
+
+    /**
+     * @var array
+     */
+    private $queryMap;
+
+    /**
+     * @param ContainerInterface $container
+     * @param array              $queryMap
+     */
+    public function __construct(ContainerInterface $container, array $queryMap = [])
+    {
+        $this->container = $container;
+        $this->queryMap  = $queryMap;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @throws RuntimeException
+     */
+    public function dispatch($query): array
+    {
+        if (!is_object($query)) {
+            throw new InvalidArgumentException(sprintf(
+                '$query must be an object, %s given',
+                gettype($query)
+            ));
+        }
+
+        $queryClass       = get_class($query);
+        $queryHandlerName = $this->queryMap[$queryClass] ?? "{$queryClass}Handler";
+        $queryHandler     = $this->container->get($queryHandlerName);
+
+        assert(is_callable($queryHandler), 'Make sure your query handler is callable');
+
+        return $queryHandler($query);
+    }
+}

test/Asset/TestQuery.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace ZfrCommandBusTest\Asset;
+
+/**
+ * @author Daniel Gimenes
+ */
+final class TestQuery
+{
+}

test/Asset/TestQueryHandler.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace ZfrCommandBusTest\Asset;
+
+/**
+ * @author Daniel Gimenes
+ */
+final class TestQueryHandler
+{
+    public function __invoke(TestQuery $query): array
+    {
+        return ['foo' => 'bar'];
+    }
+}

test/Container/SimpleQueryBusFactoryTest.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace ZfrCommandBusTest\Container;
+
+use Psr\Container\ContainerInterface;
+use ZfrCommandBus\Container\SimpleQueryBusFactory;
+
+/**
+ * @author Daniel Gimenes
+ */
+final class SimpleQueryBusFactoryTest extends \PHPUnit_Framework_TestCase
+{
+    public function testUsesEmptyHandlerMapByDefault()
+    {
+        $container = $this->prophesize(ContainerInterface::class);
+        $factory   = new SimpleQueryBusFactory();
+
+        $container->get('config')->shouldBeCalled()->willReturn([]);
+
+        $factory($container->reveal());
+    }
+
+    public function testCreatesInstanceOfSimpleQueryBus()
+    {
+        $container = $this->prophesize(ContainerInterface::class);
+        $factory   = new SimpleQueryBusFactory();
+
+        $container->get('config')->shouldBeCalled()->willReturn([
+            'zfr_command_bus' => [
+                'query_handlers' => [],
+            ],
+        ]);
+
+        $factory($container->reveal());
+    }
+}

test/SimpleQueryBusTest.php

@@ -0,0 +1,66 @@
+<?php
+
+namespace ZfrCommandBusTest;
+
+use Prophecy\Prophecy\ObjectProphecy;
+use Psr\Container\ContainerInterface;
+use stdClass;
+use ZfrCommandBus\Exception\InvalidArgumentException;
+use ZfrCommandBus\SimpleQueryBus;
+use ZfrCommandBusTest\Asset\TestQuery;
+use ZfrCommandBusTest\Asset\TestQueryHandler;
+
+/**
+ * @author Daniel Gimenes
+ */
+final class SimpleQueryBusTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var ObjectProphecy|ContainerInterface
+     */
+    private $container;
+
+    /**
+     * @var callable
+     */
+    private $queryHandler;
+
+    protected function setUp()
+    {
+        $this->container    = $this->prophesize(ContainerInterface::class);
+        $this->queryHandler = function (stdClass $query) {
+            return ['foo' => 'bar'];
+        };
+    }
+
+    public function testThrowsExceptionIfInvalidQueryType()
+    {
+        $queryBus = new SimpleQueryBus($this->container->reveal());
+
+        $this->setExpectedException(InvalidArgumentException::class);
+
+        $queryBus->dispatch('string');
+    }
+
+    public function testDispatchesQueryToMappedQueryHandler()
+    {
+        $queryBus = new SimpleQueryBus($this->container->reveal(), [stdClass::class => 'My\TestQueryHandler']);
+
+        $this->container->get('My\TestQueryHandler')->shouldBeCalled()->willReturn($this->queryHandler);
+
+        $result = $queryBus->dispatch(new stdClass());
+
+        $this->assertSame(['foo' => 'bar'], $result);
+    }
+
+    public function testTriesToGuessQueryHandlerNameWithSuffix()
+    {
+        $queryBus = new SimpleQueryBus($this->container->reveal());
+
+        $this->container->get(TestQueryHandler::class)->shouldBeCalled()->willReturn(new TestQueryHandler());
+
+        $result = $queryBus->dispatch(new TestQuery());
+
+        $this->assertSame(['foo' => 'bar'], $result);
+    }
+}