/**
  * Parse the message
  *
  * @param  mixed $message
  * @return NamedCommand
  */
 private function parseMessage($message)
 {
     try {
         return $this->messageParser->parse($message);
     } catch (MessageParserException $e) {
         $this->logger->error('Error parsing or executing command', ['exception' => $e->getMessage()]);
         $errorMessage = $this->messageFactory->buildMessage([$this->getMessageUser($e)], $e);
         if (!$errorMessage) {
             $this->logger->warning('Message could not be generated');
             return null;
         }
         $this->messageSender->send($errorMessage, $message);
         return null;
     }
 }
 /**
  * @test
  */
 public function testHandleWithParsingErrorWithoutMessage()
 {
     $userId = $this->getApplicationUserId(42);
     $userName = '******';
     $user = \Mockery::mock(ParsingUser::class, function ($user) use($userId, $userName) {
         $user->shouldReceive('getId')->andReturn($userId);
         $user->shouldReceive('getName')->andReturn($userName);
         $user->shouldReceive('getAccount')->andReturn(\Mockery::mock(Account::class));
     });
     $message = new \stdClass();
     $exception = \Mockery::mock('\\MessageApp\\Parser\\Exception\\MessageParserException');
     $exception->shouldReceive('getUser')->andReturn($user);
     $parser = \Mockery::mock('\\MessageApp\\Parser\\MessageParser');
     $parser->shouldReceive('parse')->andThrow($exception);
     $this->logger->shouldReceive('info')->twice();
     $this->logger->shouldReceive('error')->once();
     $this->logger->shouldReceive('warning')->once();
     $this->messageSender->shouldReceive('send')->never();
     $this->factory->shouldReceive('buildMessage')->with(\Mockery::on(function ($users) {
         $this->assertCount(1, $users);
         $this->assertInstanceOf(UndefinedApplicationUser::class, $users[0]);
         return true;
     }), $exception)->andReturn(null);
     $hangmanApp = new MessageApplication($this->messageSender, $parser, $this->factory, $this->getCommandBus());
     $hangmanApp->setLogger($this->logger);
     $hangmanApp->handle($message);
 }
 /**
  * Handle an event.
  *
  * @param EventInterface $event
  * @param Context        $context
  *
  * @return void
  */
 public function handle(EventInterface $event, Context $context = null)
 {
     if (!$event instanceof UnableToCreateUserEvent) {
         return;
     }
     $this->logger->info('Send message', ['user' => $event->getUser()->getName(), 'type' => $event->getName()]);
     $messageContext = null;
     if ($context) {
         $messageContext = $this->messageFinder->findByReference($context->getValue());
     }
     $message = $this->messageFactory->buildMessage([$event->getUser()], $event);
     if (!$message) {
         $this->logger->warning('Message could not be generated');
         return;
     }
     $this->messageSender->send($message, $messageContext ? $messageContext->getSource() : null);
 }
 /**
  * @param  GameResult        $gameResult
  * @param  ApplicationUser[] $users
  * @param  mixed             $messageContext
  * @return void
  */
 private function sendMessage(GameResult $gameResult, array $users = [], $messageContext = null)
 {
     $message = $this->messageFactory->buildMessage($users, $gameResult);
     if (!$message) {
         $this->logger->warning('Message could not be generated');
         return;
     }
     $this->messageSender->send($message, $messageContext);
 }
 /**
  * @test
  */
 public function itShouldBuildMessageInUserLanguageIfLanguageIsNotPassed()
 {
     $this->givenUserAsAPreferredLanguage();
     $this->givenItCanExtractMessage();
     $this->givenTranslatorWillTranslate();
     $message = $this->serviceUnderTest->buildMessage([null, $this->user], $this->object);
     $this->assertEquals([$this->user], $message->getUsers());
     $this->assertEquals($this->translatedString, $message->getMessage());
 }
 private function givenTheMessageCanNotBeBuilt()
 {
     $this->factory->shouldReceive('buildMessage')->with([$this->user], $this->event)->andReturn(null);
 }