ComplexTypeStrategyTest.php

Go to the documentation of this file.

<?php
namespace Magento\Webapi\Test\Unit\Model\Soap\Wsdl;

use \Magento\Webapi\Model\Soap\Wsdl\ComplexTypeStrategy;

use Zend\Soap\Wsdl;

class ComplexTypeStrategyTest extends \PHPUnit\Framework\TestCase
{
    protected $_typeProcessor;

    protected $_wsdl;

    protected $_strategy;

    protected function setUp()
    {
        $this->_typeProcessor = $this->getMockBuilder(
            \Magento\Framework\Reflection\TypeProcessor::class
        )->setMethods(
            ['getTypeData']
        )->disableOriginalConstructor()->getMock();
        $this->_wsdl = $this->getMockBuilder(
            \Magento\Webapi\Model\Soap\Wsdl::class
        )->setMethods(
            ['toDomDocument', 'getTypes', 'getSchema']
        )->disableOriginalConstructor()->getMock();
        $this->_strategy = new ComplexTypeStrategy($this->_typeProcessor);
        $this->_strategy->setContext($this->_wsdl);
        parent::setUp();
    }

    protected function tearDown()
    {
        unset($this->_typeProcessor);
        unset($this->_strategy);
        unset($this->_wsdl);

        parent::tearDown();
    }

    public function testCheckTypeName()
    {
        $testType = 'testComplexTypeName';
        $testTypeWsdlName = 'tns:' . $testType;
        $includedTypes = [$testType => $testTypeWsdlName];
        $this->_wsdl->expects($this->exactly(2))->method('getTypes')->will($this->returnValue($includedTypes));

        $this->assertEquals($testTypeWsdlName, $this->_strategy->addComplexType($testType));
    }

    public function testAddComplexTypeSimpleParameters($type, $data)
    {
        $this->_wsdl->expects($this->any())->method('getTypes')->will($this->returnValue([]));

        $this->_wsdl->expects($this->any())->method('toDomDocument')->will($this->returnValue(new \DOMDocument()));

        $schemaMock = $this->getMockBuilder(\DOMElement::class)
            ->setConstructorArgs(['a'])
            ->getMock();
        $schemaMock->expects($this->any())->method('appendChild');
        $this->_wsdl->expects($this->any())->method('getSchema')->will($this->returnValue($schemaMock));

        $this->_typeProcessor->expects(
            $this->at(0)
        )->method(
            'getTypeData'
        )->with(
            $type
        )->will(
            $this->returnValue($data)
        );

        $this->assertEquals(Wsdl::TYPES_NS . ':' . $type, $this->_strategy->addComplexType($type));
    }

    public static function addComplexTypeDataProvider()
    {
        return [
            'simple parameters' => [
                'VendorModuleADataStructure',
                [
                    'documentation' => 'test',
                    'parameters' => [
                        'string_param' => [
                            'type' => 'string',
                            'required' => true,
                            'documentation' => 'Required string param.',
                        ],
                        'int_param' => [
                            'type' => 'int',
                            'required' => true,
                            'documentation' => 'Required int param.',
                        ],
                        'bool_param' => [
                            'type' => 'boolean',
                            'required' => false,
                            'documentation' => 'Optional complex type param.{annotation:test}',
                        ],
                    ]
                ],
            ],
            'type with call info' => [
                'VendorModuleADataStructure',
                [
                    'documentation' => 'test',
                    'parameters' => [
                        'string_param' => [
                            'type' => 'string',
                            'required' => false,
                            'documentation' => '{callInfo:VendorModuleACreate:requiredInput:conditionally}',
                        ],
                    ],
                    'callInfo' => [
                        'requiredInput' => ['yes' => ['calls' => ['VendorModuleACreate']]],
                        'returned' => ['always' => ['calls' => ['VendorModuleAGet']]],
                    ]
                ],
            ],
            'parameter with call info' => [
                'VendorModuleADataStructure',
                [
                    'documentation' => 'test',
                    'parameters' => [
                        'string_param' => [
                            'type' => 'string',
                            'required' => false,
                            'documentation' => '{callInfo:VendorModuleACreate:requiredInput:conditionally}' .
                            '{callInfo:allCallsExcept(VendorModuleAGet):returned:always}',
                        ],
                    ]
                ],
            ],
            'parameter with see link' => [
                'VendorModuleADataStructure',
                [
                    'documentation' => 'test',
                    'parameters' => [
                        'string_param' => [
                            'type' => 'string',
                            'required' => false,
                            'documentation' => '{seeLink:http://google.com/:title:for}',
                        ],
                    ]
                ],
            ],
            'parameter with doc instructions' => [
                'VendorModuleADataStructure',
                [
                    'documentation' => 'test',
                    'parameters' => [
                        'string_param' => [
                            'type' => 'string',
                            'required' => false,
                            'documentation' => '{docInstructions:output:noDoc}',
                        ],
                    ]
                ],
            ]
        ];
    }

    public function testAddComplexTypeComplexParameters()
    {
        $type = 'VendorModuleADataStructure';
        $parameterType = 'ComplexType';
        $typeData = [
            'documentation' => 'test',
            'parameters' => [
                'complex_param' => [
                    'type' => $parameterType,
                    'required' => true,
                    'documentation' => 'complex type param.',
                ],
            ],
        ];
        $parameterData = [
            'documentation' => 'test',
            'parameters' => [
                'string_param' => [
                    'type' => 'ComplexTypeB[]',
                    'required' => true,
                    'documentation' => 'string param.',
                ],
            ],
        ];

        $this->_wsdl->expects($this->at(0))->method('getTypes')->will($this->returnValue([]));
        $this->_wsdl->expects(
            $this->any()
        )->method(
            'getTypes'
        )->will(
            $this->returnValue([$type => Wsdl::TYPES_NS . ':' . $type])
        );

        $this->_wsdl->expects($this->any())->method('toDomDocument')->will($this->returnValue(new \DOMDocument()));
        $schemaMock = $this->getMockBuilder(\DOMElement::class)
            ->setConstructorArgs(['a'])
            ->getMock();
        $schemaMock->expects($this->any())->method('appendChild');
        $this->_wsdl->expects($this->any())->method('getSchema')->will($this->returnValue($schemaMock));
        $this->_typeProcessor->expects(
            $this->at(0)
        )->method(
            'getTypeData'
        )->with(
            $type
        )->will(
            $this->returnValue($typeData)
        );
        $this->_typeProcessor->expects(
            $this->at(1)
        )->method(
            'getTypeData'
        )->with(
            $parameterType
        )->will(
            $this->returnValue($parameterData)
        );

        $this->assertEquals(Wsdl::TYPES_NS . ':' . $type, $this->_strategy->addComplexType($type));
    }

    public function testAddAnnotationToComplexType()
    {
        $dom = new \DOMDocument();
        $this->_wsdl->expects($this->any())->method('toDomDocument')->will($this->returnValue($dom));
        $annotationDoc = "test doc";
        $complexType = $dom->createElement(Wsdl::XSD_NS . ':complexType');
        $complexType->setAttribute('name', 'testRequest');
        $this->_strategy->addAnnotation($complexType, $annotationDoc);
        $this->assertEquals(
            $annotationDoc,
            $complexType->getElementsByTagName("xsd:documentation")->item(0)->nodeValue
        );
    }
}