public function registerCommandHandler($commandName, CommandHandlerInterface $commandHandler)
 {
     $this->registerAggregateCommandHandlers();
     $this->explicitCommandHandlersSet = true;
     $this->commandBus->subscribe($commandName, $commandHandler);
     return $this;
 }
 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()));
 }
 /**
  * @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()));
 }
$logger->pushHandler(new StreamHandler('php://stdout', Logger::DEBUG));
// 1. create a command bus and command gateway
$commandBus = new SimpleCommandBus();
$commandBus->setLogger($logger);
$commandGateway = new DefaultCommandGateway($commandBus);
$rootDirectory = sys_get_temp_dir() . DIRECTORY_SEPARATOR . 'CommandHandlerExample';
@mkdir($rootDirectory);
echo sprintf("Initializing FileSystemEventStore in %s\n", $rootDirectory);
// 2. initialize the event store
$eventStore = new FilesystemEventStore(new SimpleEventFileResolver($rootDirectory), new JMSSerializer());
// 3. create the event bus
$eventBus = new SimpleEventBus();
$eventBus->setLogger($logger);
// 4. create an event sourcing repository
$repository = new EventSourcingRepository(User::class, $eventBus, new NullLockManager(), $eventStore, new GenericAggregateFactory(User::class));
//5. create and register our commands
$commandHandler = new UserCommandHandler($repository);
$commandBus->subscribe('CommandHandlerExample\\CreateUserCommand', $commandHandler);
$commandBus->subscribe('CommandHandlerExample\\ChangeUserEmailCommand', $commandHandler);
//6. create and register the eventlistener
$eventListener = new UserEventListener();
$eventBus->subscribe($eventListener);
//7. send commands
$aggregateIdentifier = Uuid::uuid1()->toString();
$commandGateway->send(new CreateUserCommand($aggregateIdentifier, '*****@*****.**'));
$commandGateway->send(new ChangeUserEmailCommand($aggregateIdentifier, '*****@*****.**'));
//8. read back aggregate from store
$uow = DefaultUnitOfWork::startAndGet($logger);
$aggregate = $repository->load($aggregateIdentifier);
echo sprintf("\n\nUser identifier:%s, email:%s, version:%s\n\n", $aggregate->getIdentifier(), $aggregate->getEmail(), $aggregate->getVersion());
$uow->rollback();