kupshop/bundles/KupShop/MessengerBundle/Tests/MessengerTest.php

<?php

namespace KupShop\MessengerBundle\Tests;

use KupShop\DevelopmentBundle\MailArchive;
use KupShop\KupShopBundle\Email\BaseEmail;
use KupShop\MessengerBundle\Handler\FinalEmailHandler;
use KupShop\MessengerBundle\Message\AsyncMessage;
use KupShop\MessengerBundle\Message\EmailMessage;
use KupShop\MessengerBundle\Message\Envelope\AsyncEnvelope;
use KupShop\MessengerBundle\Message\Envelope\EmailEnvelope;
use KupShop\MessengerBundle\Message\Envelope\EnvelopeInterface;
use KupShop\MessengerBundle\Message\Envelope\PriorityEmailEnvelope;
use Symfony\Component\Messenger\Envelope;
use Symfony\Component\Messenger\MessageBusInterface;
use Symfony\Component\Messenger\Stamp\HandledStamp;

class MessengerTest extends \DatabaseTestCase
{
    /** @var MailArchive */
    private $mailArchive;

    /** @var MessageBusInterface */
    private $bus;

    protected function setUp(): void
    {
        parent::setUp();

        $this->mailArchive = $this->get(MailArchive::class);
        $this->bus = $this->get(MessageBusInterface::class);
    }

    public function testEnvelopeAsyncMessageIsHandled(): void
    {
        $value = 'message handled';

        $message = new TestAsyncMessage2();
        $message->setMessage($value);

        $result = $this->getHandledResult(
            $this->bus->dispatch(
                new AsyncEnvelope(serialize($message))
            )
        );

        $this->assertTrue($result['status']);

        $this->assertEquals($value, getCache('tests_asyncMessageHandle'));
    }

    public function testEnvelopeEmailMessageIsSend(): void
    {
        $result = $this->getHandledResult(
            $this->bus->dispatch(
                new EmailEnvelope(serialize($this->getTestEmailMessage()))
            )
        );

        $this->assertTrue($result['status']);

        $archive = $this->mailArchive->getArchive();

        $this->assertEquals('Šablona emailu', $archive[0]['subject']);
    }

    public function testEnvelopeEmailMessageFailureNotSend(): void
    {
        $this->set(FinalEmailHandler::class, new FailingEmailHandler());

        $result = $this->getHandledResult(
            $this->bus->dispatch(
                new EmailEnvelope(serialize($this->getTestEmailMessage()))
            )
        );

        $this->assertFalse($result['status']);
    }

    /**
     * All messages of EnvelopeInterface should be handled correctly.
     *
     * @dataProvider data_testEnvelopeMessageIsHandled
     */
    public function testEnvelopeMessageIsHandled(EnvelopeInterface $envelope): void
    {
        $result = $this->getHandledResult(
            $this->bus->dispatch($envelope)
        );

        $this->assertTrue($result['status']);
    }

    public function data_testEnvelopeMessageIsHandled(): array
    {
        return [
            [new EmailEnvelope(serialize($this->getTestEmailMessage()))],
            [new PriorityEmailEnvelope(serialize($this->getTestEmailMessage()))],
            [new AsyncEnvelope(serialize($this->getTestAsyncMessage()))],
        ];
    }

    private function getTestEmailMessage(): EmailMessage
    {
        $emailService = $this->get(BaseEmail::class);
        $message = $emailService->testEmail();
        $message['to'] = $message['from'];

        return new EmailMessage($message, $emailService);
    }

    private function getTestAsyncMessage(): AsyncMessage
    {
        $asyncMessage = new TestAsyncMessage();
        $asyncMessage->setMessage(['message' => 'test']);

        return $asyncMessage;
    }

    private function getHandledResult(Envelope $envelope)
    {
        $stamp = $envelope->last(HandledStamp::class);

        return $stamp->getResult();
    }
}

class TestAsyncMessage extends AsyncMessage
{
    private $message;

    public function setMessage($message)
    {
        $this->message = $message;
    }

    public function getMessage()
    {
        return $this->message;
    }

    public function handle()
    {
        $message = $this->getMessage();

        if (empty($message['message'])) {
            throw new \Exception('Empty message!');
        }

        $message['message'] = 'handled';
        $this->setMessage($message);

        return true;
    }
}

class TestAsyncMessage2 extends TestAsyncMessage
{
    public function handle()
    {
        $message = $this->getMessage();

        setCache('tests_asyncMessageHandle', $message);

        return true;
    }
}

class FailingEmailHandler extends FinalEmailHandler
{
    public function __construct()
    {
    }

    public function __invoke(EmailMessage $message)
    {
        return [
            'status' => false,
            'message' => 'error',
        ];
    }
}