public function testAndMetaData()
{
$payload = new \stdClass();
$metaDataMap = array("key" => "value");
$metaData = new MetaData($metaDataMap);
$message = new GenericCommandMessage($payload, $metaData);
$message1 = $message->andMetaData();
$message2 = $message->andMetaData(array("key" => "otherValue"));
$this->assertEquals(1, count($message1->getMetaData()));
$this->assertEquals("value", $message1->getMetaData()->get("key"));
$this->assertEquals(1, count($message2->getMetaData()));
$this->assertEquals("otherValue", $message2->getMetaData()->get("key"));
}
public function testSubscribe()
{
$commandHandler = $this->getMock(CommandHandlerInterface::class);
$this->subject->subscribe(get_class(new TestCommand('hi')), $commandHandler);
$handler = $this->subject->findCommandHandlerFor(GenericCommandMessage::asCommandMessage(new TestCommand('hi')));
$this->assertInstanceOf(CommandHandlerInterface::class, $handler);
}
public function testResolveTarget_WithAnnotatedFields()
{
$aggregateIdentifier = Uuid::uuid1();
$version = 1;
$actual = $this->testSubject->resolveTarget(GenericCommandMessage::asCommandMessage(new FieldAnnotatedCommand($aggregateIdentifier, $version)));
$this->assertEquals($aggregateIdentifier, $actual->getIdentifier());
$this->assertEquals($version, $actual->getVersion());
}
public function testFromAndToBytes()
{
$serializer = new JMSSerializer();
$commandMessage = GenericCommandMessage::asCommandMessage(new ResultPayload("string", 10, 5.1));
$dispatchMessage1 = new DispatchMessage($commandMessage, $serializer, false);
$bytes = $dispatchMessage1->toBytes();
$dispatchMessage2 = DispatchMessage::fromBytes($serializer, $bytes);
$this->assertEquals($dispatchMessage1->getCommandIdentifier(), $dispatchMessage2->getCommandIdentifier());
$this->assertEquals($dispatchMessage1->isExpectReply(), $dispatchMessage2->isExpectReply());
$this->assertEquals($dispatchMessage1->getCommandMessage(), $dispatchMessage2->getCommandMessage());
$this->assertFalse($dispatchMessage1->isExpectReply());
$this->assertFalse($dispatchMessage2->isExpectReply());
}
public function handle(CommandMessageInterface $commandMessage, UnitOfWorkInterface $unitOfWork, InterceptorChainInterface $interceptorChain)
{
return $interceptorChain->proceed(GenericCommandMessage::asCommandMessage(new Payload("testing")));
}
public function testRemoteDispatchReplyTimeout()
{
$this->localSegment->subscribe(TestCommand::class, new TestCommandHandler());
$remoteTemplate = new RedisTemplate('tcp://127.0.0.1:6379?read_write_timeout=-1', 'test-node2', []);
$remoteTemplate->subscribe(TestCommand::class);
$this->template->setTimeout(1);
$interceptor = new DispatchInterceptor();
$this->localSegment->setDispatchInterceptors([$interceptor]);
$callback = new ClosureCommandCallback(function ($result) {
$this->fail('Exception expected');
}, function ($error) {
$this->assertInstanceOf(CommandTimeoutException::class, $error);
});
$this->testSubject->send('key', GenericCommandMessage::asCommandMessage(new TestCommand('key')), $callback);
$this->assertEmpty($interceptor->commands);
$this->assertEmpty($this->template->getClient()->keys('governor:response:*'));
$this->assertCount(1, $this->template->getPendingCommands($remoteTemplate->getNodeName()));
}
public function testDispatchCommand_ImplicitUnitOfWorkIsRolledBackOnException()
{
$command = new TestCommand("Say hi!");
$test = $this;
$this->handlerRegistry->subscribe(TestCommand::class, new CallbackCommandHandler(function (CommandMessageInterface $commandMessage, UnitOfWorkInterface $unitOfWork) use($test) {
$test->assertTrue(CurrentUnitOfWork::isStarted());
$test->assertNotNull(CurrentUnitOfWork::get());
throw new \RuntimeException("exception");
}));
$callback = new ClosureCommandCallback(function ($result) use($command) {
$this->fail("Did not expect exception");
}, function ($exception) {
$this->assertEquals(\RuntimeException::class, get_class($exception));
});
$this->commandBus->dispatch(GenericCommandMessage::asCommandMessage($command), $callback);
$this->assertFalse(CurrentUnitOfWork::isStarted());
}
/**
* @Test
* public void testDispatchCommand_UnitOfWorkIsCommittedOnCheckedException() {
* UnitOfWorkFactory mockUnitOfWorkFactory = mock(DefaultUnitOfWorkFactory.class);
* UnitOfWork mockUnitOfWork = mock(UnitOfWork.class);
* when(mockUnitOfWorkFactory.createUnitOfWork()).thenReturn(mockUnitOfWork);
*
* testSubject.setUnitOfWorkFactory(mockUnitOfWorkFactory);
* testSubject.subscribe(String.class.getName(), new CommandHandler<String>() {
* @Override
* public Object handle(CommandMessage<String> command, UnitOfWork unitOfWork) throws Throwable {
* throw new Exception();
* }
* });
* testSubject.setRollbackConfiguration(new RollbackOnUncheckedExceptionConfiguration());
*
* testSubject.dispatch(GenericCommandMessage.asCommandMessage("Say hi!"), new CommandCallback<Object>() {
* @Override
* public void onSuccess(Object result) {
* fail("Expected exception");
* }
*
* @Override
* public void onFailure(Throwable cause) {
* assertThat(cause, is(Exception.class));
* }
* });
*
* verify(mockUnitOfWork).commit();
* }*/
public function testInterceptorChain_CommandHandledSuccessfully()
{
$mockInterceptor1 = \Phake::mock(CommandHandlerInterceptorInterface::class);
$mockInterceptor2 = \Phake::mock(CommandHandlerInterceptorInterface::class);
$commandHandler = \Phake::mock(CommandHandlerInterface::class);
\Phake::when($mockInterceptor1)->handle(\Phake::anyParameters())->thenGetReturnByLambda(function (CommandMessageInterface $commandMessage, UnitOfWorkInterface $unitOfWork, InterceptorChainInterface $interceptorChain) use($mockInterceptor2) {
return $mockInterceptor2->handle($commandMessage, $unitOfWork, $interceptorChain);
});
\Phake::when($mockInterceptor2)->handle(\Phake::anyParameters())->thenGetReturnByLambda(function (CommandMessageInterface $commandMessage, UnitOfWorkInterface $unitOfWork, InterceptorChainInterface $interceptorChain) use($commandHandler) {
return $commandHandler->handle($commandMessage, $unitOfWork);
});
\Phake::when($commandHandler)->handle(\Phake::anyParameters())->thenReturn(new TestCommand("Hi there!"));
$subject = new SimpleCommandBus(new DefaultUnitOfWorkFactory());
$subject->setHandlerInterceptors([$mockInterceptor1, $mockInterceptor2]);
$subject->subscribe(TestCommand::class, $commandHandler);
$command = GenericCommandMessage::asCommandMessage(new TestCommand("Hi there!"));
$callback = new ClosureCommandCallback(function ($result) {
$this->assertEquals("Hi there!", $result->getText());
}, function ($exception) {
$this->fail("Did not expect exception");
});
$subject->dispatch($command, $callback);
\Phake::inOrder(\Phake::verify($mockInterceptor1)->handle(\Phake::anyParameters()), \Phake::verify($mockInterceptor2)->handle(\Phake::anyParameters()), \Phake::verify($commandHandler)->handle(\Phake::anyParameters()));
}
public function when($command, array $metaData = array())
{
try {
$this->finalizeConfiguration();
$resultValidator = new ResultValidatorImpl($this->storedEvents, $this->publishedEvents);
$this->commandBus->setHandlerInterceptors(array(new AggregateRegisteringInterceptor($this->workingAggregate)));
$this->commandBus->dispatch(GenericCommandMessage::asCommandMessage($command)->andMetaData($metaData), $resultValidator);
$this->detectIllegalStateChanges();
$resultValidator->assertValidRecording();
return $resultValidator;
} finally {
//FixtureResourceParameterResolverFactory.clear();
}
}
private function listOfOneCommandMessage($msg)
{
return array(GenericCommandMessage::asCommandMessage($msg));
}
/**
* @param $command
* @return GenericCommandMessage
*/
protected function createCommandMessage($command)
{
$message = GenericCommandMessage::asCommandMessage($command);
return $message->withMetaData(CorrelationDataHolder::getCorrelationData())->andMetaData($message->getMetaData()->all());
}