[Messenger] Add serializer usage to InMemoryTransport

[tyx]

Description

Use $serializer inside the InMemoryTransport.

Currently the in memory transport does not use the serializer compared to the others.

This removes the possibility in tests with messenger to test to the end the chain when a custom serializer is provided (in this case https://github.com/Happyr/message-serializer).

I've created my own transport and I wonder if it could be implemented directly in messenger.

WDYT ?

Example

<?php declare(strict_types=1);

namespace Gogaille\Shared\Messaging;

use Symfony\Component\Messenger\Envelope;
use Symfony\Component\Messenger\Transport\Serialization\PhpSerializer;
use Symfony\Component\Messenger\Transport\Serialization\SerializerInterface;
use Symfony\Component\Messenger\Transport\TransportInterface;
use Symfony\Contracts\Service\ResetInterface;

/**
 * Copy/Paste from InMemoryTransport of symfony  with serialization.
 */
class InMemorySerializableTransport implements TransportInterface, ResetInterface
{
    /**
     * @var mixed[]
     */
    private $sent = [];

    /**
     * @var mixed[]
     */
    private $acknowledged = [];

    /**
     * @var mixed[]
     */
    private $rejected = [];

    /**
     * @var mixed[]
     */
    private $queue = [];

    private $serializer;

    public function __construct(SerializerInterface $serializer = null)
    {
        $this->serializer = $serializer ?? new PhpSerializer();
    }

    /**
     * {@inheritdoc}
     */
    public function get(): iterable
    {
        return array_values($this->decode($this->queue));
    }

    /**
     * {@inheritdoc}
     */
    public function ack(Envelope $envelope): void
    {
        $this->acknowledged[] = $this->serializer->encode($envelope);
        $id = spl_object_hash($envelope->getMessage());
        unset($this->queue[$id]);
    }

    /**
     * {@inheritdoc}
     */
    public function reject(Envelope $envelope): void
    {
        $this->rejected[] = $this->serializer->encode($envelope);
        $id = spl_object_hash($envelope->getMessage());
        unset($this->queue[$id]);
    }

    /**
     * {@inheritdoc}
     */
    public function send(Envelope $envelope): Envelope
    {
        $encodedEnvelope = $this->serializer->encode($envelope);
        $this->sent[] = $encodedEnvelope;
        $id = spl_object_hash($envelope->getMessage());
        $this->queue[$id] = $encodedEnvelope;

        return $envelope;
    }

    public function reset()
    {
        $this->sent = $this->queue = $this->rejected = $this->acknowledged = [];
    }

    /**
     * @return Envelope[]
     */
    public function getAcknowledged(): array
    {
        return $this->decode($this->acknowledged);
    }

    /**
     * @return Envelope[]
     */
    public function getRejected(): array
    {
        return $this->decode($this->rejected);
    }

    /**
     * @return Envelope[]
     */
    public function getSent(): array
    {
        return $this->decode($this->sent);
    }

    /**
     * @param array<mixed> $messagesEncoded
     *
     * @return Envelope[]
     */
    private function decode(array $messagesEncoded): array
    {
        return array_map(
            fn ($message) => $this->serializer->decode($message),
            $messagesEncoded
        );
    }
}

[chalasr]

Looks sensible to me.

[Nyholm]

I agree with this.
Sure it will "just take time", but it makes my development environment a bit more similar to how it works in production.

👍

[Nyholm]

Could we make this configurable with in-memory://?serialse=true?

Just make sure we use the configured (or default) serializer.

[Guikingone]

What about adding a FilesystemTransport ?

This way, the InMemoryTransport can stay as it and we can use a new transport dedicated to test env?

[tyx]

Could we make this configurable with in-memory://?serialse=true?

Just make sure we use the configured (or default) serializer.

Yes indeed ! Love this idea

[tyx]

What about adding a FilesystemTransport ?

This way, the InMemoryTransport can stay as it and we can use a new transport dedicated to test env?

InMemory is not already dedicated to test env ?

[Guikingone]

InMemory is not already dedicated to test env ?

You're right, my bad, I was thinking about a new transport as IMHO it's easier to maintain and improve rather than adding a new option and impacting the existing InMemoryTransport.

[derrabus]

What about adding a FilesystemTransport ?

IIRC think that idea was discarded in the past because you could basically use a Doctrine transport on an SQLite file to achieve a "filesystem transport".