RemoteServiceGeneratorTest.php

Go to the documentation of this file.

<?php
namespace Magento\Framework\MessageQueue\Test\Unit\Code\Generator;

use Composer\Autoload\ClassLoader;
use Magento\Framework\Cache\FrontendInterface;
use Magento\Framework\Communication\Config\ReflectionGenerator;
use Magento\Framework\Communication\ConfigInterface as CommunicationConfigInterface;
use Magento\Framework\MessageQueue\Code\Generator\RemoteServiceGenerator;
use Magento\Framework\Reflection\MethodsMap;
use Magento\Framework\Reflection\TypeProcessor;
use Magento\Framework\Serialize\SerializerInterface;
use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use PHPUnit\Framework\MockObject_MockObject as MockObject;

class RemoteServiceGeneratorTest extends \PHPUnit\Framework\TestCase
{
    private $communicationConfig;

    private $generator;

    private $objectManager;

    protected function setUp()
    {
        $this->objectManager = new ObjectManager($this);

        $this->communicationConfig = $this->getMockBuilder(CommunicationConfigInterface::class)
            ->disableOriginalConstructor()
            ->getMock();

        $loader = new ClassLoader();
        $loader->addPsr4(
            'Magento\\Framework\\MessageQueue\\Code\\Generator\\',
            __DIR__ . '/_files'
        );
        $loader->register();
    }

    public function testGenerate($sourceClassName, $resultClassName, $topicName, $fileName)
    {
        $this->createGenerator($sourceClassName, $resultClassName);

        $this->communicationConfig->method('getTopic')
            ->willReturnMap(
                [
                    [$topicName . '.save', [CommunicationConfigInterface::TOPIC_IS_SYNCHRONOUS => true]],
                    [$topicName . '.get', [CommunicationConfigInterface::TOPIC_IS_SYNCHRONOUS => true]],
                    [$topicName . '.getById', [CommunicationConfigInterface::TOPIC_IS_SYNCHRONOUS => true]],
                    [$topicName . '.getList', [CommunicationConfigInterface::TOPIC_IS_SYNCHRONOUS => true]],
                    [$topicName . '.delete', [CommunicationConfigInterface::TOPIC_IS_SYNCHRONOUS => true]],
                    [$topicName . '.deleteById', [CommunicationConfigInterface::TOPIC_IS_SYNCHRONOUS => true]],
                ]
            );
        $expectedResult = file_get_contents(__DIR__ . '/_files/' . $fileName);
        $this->validateGeneratedCode($expectedResult);
    }

    public function interfaceDataProvider()
    {
        return [
            [
                '\\' . \Magento\Customer\Api\CustomerRepositoryInterface::class,
                '\\' . \Magento\Customer\Api\CustomerRepositoryInterfaceRemote::class,
                'magento.customer.api.customerRepositoryInterface',
                'RemoteService.txt'
            ],
            [
                '\\' . \Magento\Framework\MessageQueue\Code\Generator\TRepositoryInterface::class,
                '\\' . \Magento\Framework\MessageQueue\Code\Generator\TRepositoryInterfaceRemote::class,
                'magento.framework.messageQueue.code.generator.tRepositoryInterface',
                'TRemoteService.txt'
            ]
        ];
    }

    private function validateGeneratedCode($expectedResult)
    {
        $reflectionObject = new \ReflectionObject($this->generator);
        $reflectionMethod = $reflectionObject->getMethod('_generateCode');
        $reflectionMethod->setAccessible(true);
        $generatedCode = $reflectionMethod->invoke($this->generator);
        self::assertEquals($expectedResult, $generatedCode);
    }

    private function createGenerator($sourceClassName, $resultClassName)
    {
        $methodMap = $this->createMethodMap();
        $this->generator = $this->objectManager->getObject(
            RemoteServiceGenerator::class,
            [
                'communicationConfig' => $this->communicationConfig,
                'serviceMethodsMap' => $methodMap,
                'sourceClassName' => $sourceClassName,
                'resultClassName' => $resultClassName,
                'classGenerator' => null
            ]
        );

        $reflectionGenerator = $this->objectManager->getObject(ReflectionGenerator::class);
        $this->objectManager->setBackwardCompatibleProperty(
            $this->generator,
            'reflectionGenerator',
            $reflectionGenerator
        );
    }

    private function createMethodMap()
    {
        $cache = $this->getMockBuilder(FrontendInterface::class)
            ->disableOriginalConstructor()
            ->getMock();
        $cache->method('load')
            ->willReturn(false);

        $serializer = $this->getMockBuilder(SerializerInterface::class)
            ->disableOriginalConstructor()
            ->getMock();
        $typeProcessor = $this->objectManager->getObject(TypeProcessor::class);

        $serviceMethodMap = $this->objectManager->getObject(MethodsMap::class, [
            'cache' => $cache,
            'typeProcessor' => $typeProcessor
        ]);
        $this->objectManager->setBackwardCompatibleProperty(
            $serviceMethodMap,
            'serializer',
            $serializer
        );

        return $serviceMethodMap;
    }
}