TomCizek\SymfonyProoph\Tests\AsynchronousMessages\AsynchronousMessageProducerTest

Complexity

Total Complexity

11

Size/Duplication

Total Lines	91
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	6	1
A	testInvoke_WithDeferredParam_ShouldThrowRuntimeException()	0	9	1
A	testInvoke_WithoutRoutes_ShouldThrowRuntimeException()	0	8	1
A	testInvoke_WithProperRoute_ShouldPublishExpectedMessageToExpectedProducerRouteKey()	0	10	1
A	givenTestProducerBridge()	0	4	1
A	givenAsynchronousMessageProducer()	0	5	1
A	givenMockedDeffered()	0	7	1
A	givenTestProducerHasInjectedTestRoute()	0	8	1
A	givenTestMessage()	0	4	1
A	whenInvokeProducerWith()	0	5	1
A	getPublishedEventsFromTestBridge()	0	4	1

<?php declare(strict_types = 1);

namespace TomCizek\SymfonyProoph\Tests\AsynchronousMessages;

use Mockery;
use Prooph\Common\Messaging\Message;
use Prooph\Common\Messaging\NoOpMessageConverter;
use Prooph\ServiceBus\Exception\RuntimeException;
use Ramsey\Uuid\Uuid;
use React\Promise\Deferred;
use TomCizek\SymfonyProoph\AsynchronousMessages\AsynchronousMessageProducer;
use TomCizek\SymfonyProoph\Tests\AsynchronousMessages\FakeImplementations\TestAsynchronousMessageProducerBridge;
use TomCizek\SymfonyProoph\Tests\EventSourcing\FakeImplementations\TestAggregateCreated;

class AsynchronousMessageProducerTest extends AbstractAsynchronousMessagesTestCase
{
	const TEST_PRODUCER_ROUTE_KEY = 'producerRouteKey';

	/** @var TestAsynchronousMessageProducerBridge */
	private $testProducerBridge;

	/** @var AsynchronousMessageProducer */
	private $testProducer;

	public function setUp()
	{
		parent::setUp();
		$this->givenTestProducerBridge();
		$this->givenAsynchronousMessageProducer();
	}

	public function testInvoke_WithDeferredParam_ShouldThrowRuntimeException()
	{
		$testMessage = $this->givenTestMessage();
		$deffered = $this->givenMockedDeffered();

		$this->willThrowException(RuntimeException::class);

		$this->whenInvokeProducerWith($testMessage, $deffered);
	}

	public function testInvoke_WithoutRoutes_ShouldThrowRuntimeException()
	{
		$testMessage = $this->givenTestMessage();

		$this->willThrowException(RuntimeException::class);

		$this->whenInvokeProducerWith($testMessage);
	}

	public function testInvoke_WithProperRoute_ShouldPublishExpectedMessageToExpectedProducerRouteKey()
	{
		$this->givenTestProducerHasInjectedTestRoute();

		$testMessage = $this->givenTestMessage();

		$this->whenInvokeProducerWith($testMessage);

		$this->thenShouldPublishExpectedMessageToExpectedProducerRouteKey(self::TEST_PRODUCER_ROUTE_KEY);
	}

	private function givenTestProducerBridge(): void
	{
		$this->testProducerBridge = new TestAsynchronousMessageProducerBridge();
	}

	private function givenAsynchronousMessageProducer(): void
	{
		$messageConverter = new NoOpMessageConverter();
		$this->testProducer = new AsynchronousMessageProducer($this->testProducerBridge, $messageConverter);
	}

	private function givenMockedDeffered(): Deferred
	{
		$deffered = Mockery::mock('React\Promise\Deferred');
		assert($deffered instanceof Deferred);

		return $deffered;
	}

	private function givenTestProducerHasInjectedTestRoute()
	{
		$this->testProducer->injectRoutes(
			[
				TestAggregateCreated::class => self::TEST_PRODUCER_ROUTE_KEY,
			]
		);
	}

	private function givenTestMessage(): Message
	{
		return TestAggregateCreated::create(Uuid::uuid4());
	}

	private function whenInvokeProducerWith(Message $message, Deferred $deferred = null): void
	{
		$producer = $this->testProducer;
		$producer($message, $deferred);
	}

	protected function getPublishedEventsFromTestBridge(): array
	{
		return $this->testProducerBridge->getPublished();
	}
}