XMLRpcStyleTest::shouldGenerateDOMElementForBinding() - Code Metrics - piotrooo/wsdl-creator - Measure and Improve Code Quality continuously with Scrutinizer

shouldGenerateDOMElementForBinding() A
last analyzed 2020-03-15 19:17 UTC

↳ Parent: XMLRpcStyleTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	10
Ratio	100 %

Importance

Changes

Metric	Value
dl	10
loc	10
rs	9.9332
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php
/**
 * Copyright (C) 2013-2020
 * Piotr Olaszewski <[email protected]>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
namespace Tests\WSDL\XML\XMLStyle;

use DOMDocument;
use Ouzo\Tests\Assert;
use PHPUnit\Framework\TestCase;
use WSDL\Builder\Parameter;
use WSDL\Parser\Node;
use WSDL\XML\XMLStyle\XMLRpcStyle;

/**
 * XMLRpcStyleTest
 *
 * @author Piotr Olaszewski <[email protected]>
 */
class XMLRpcStyleTest extends TestCase
{
    /**
     * @var DOMDocument
     */
    private $DOMDocument;
    /**
     * @var XMLRpcStyle
     */
    private $XMLRpcStyle;

    protected function setUp(): void
    {
        parent::setUp();
        $this->DOMDocument = new DOMDocument();
        $this->XMLRpcStyle = new XMLRpcStyle();
    }

    /**
     * @test
     */
    public function shouldGenerateDOMElementForBinding()

    {
        //when
        $DOMElement = $this->XMLRpcStyle->generateBinding($this->DOMDocument, 'soap');

        //then
        $this->assertEquals('soap:binding', $DOMElement->tagName);
        $this->assertEquals('rpc', $DOMElement->getAttribute('style'));
        $this->assertEquals('http://schemas.xmlsoap.org/soap/http', $DOMElement->getAttribute('transport'));
    }

    /**
     * @test
     */
    public function shouldGenerateDOMElementsForMessage()

    {
        //given
        $nodes = [
            new Node('int', '$age', false),
            new Node('object', '$user', false, [new Node('string', '$name', false)]),
            new Node('string', '$numbers', true)
        ];

        //when
        $DOMElements = $this->XMLRpcStyle->generateMessagePart($this->DOMDocument, $nodes);

        //then
        Assert::thatArray($DOMElements)->extracting('tagName')->containsExactly('part', 'part', 'part');

        $this->assertEquals('age', $DOMElements[0]->getAttribute('name'));
        $this->assertEquals('xsd:int', $DOMElements[0]->getAttribute('type'));

        $this->assertEquals('user', $DOMElements[1]->getAttribute('name'));
        $this->assertEquals('ns:User', $DOMElements[1]->getAttribute('element'));

        $this->assertEquals('numbers', $DOMElements[2]->getAttribute('name'));
        $this->assertEquals('ns:ArrayOfNumbers', $DOMElements[2]->getAttribute('type'));
    }

    /**
     * @test
     */
    public function shouldGenerateDOMElementsForTypesObject()
    {
        //given
        $parameters = [
            new Parameter(new Node('object', '$user', false, [new Node('string', '$name', false)]), false)
        ];

        //when
        $DOMElements = $this->XMLRpcStyle->generateTypes($this->DOMDocument, $parameters, 'soap');

        //then
        Assert::thatArray($DOMElements)
            ->extracting('tagName')
            ->containsExactly('xsd:element', 'xsd:complexType');

        //<xsd:element name="User" nillable="true" type="ns:User"/>
        $this->assertEquals('User', $DOMElements[0]->getAttribute('name'));
        $this->assertEquals('true', $DOMElements[0]->getAttribute('nillable'));
        $this->assertEquals('ns:User', $DOMElements[0]->getAttribute('type'));

        //<xsd:complexType name="User">
        //    <xsd:sequence>
        //        <xsd:element name="name" type="xsd:string"/>
        //    </xsd:sequence>
        //</xsd:complexType>
        $this->assertEquals('User', $DOMElements[1]->getAttribute('name'));
        $sequenceActual = $DOMElements[1]->getElementsByTagName('xsd:sequence');
        $sequenceActual = $sequenceActual->item(0);
        $this->assertEquals('xsd:sequence', $sequenceActual->tagName);
        $DOMElements1Nodes = $sequenceActual->getElementsByTagName('xsd:element');
        foreach ($DOMElements1Nodes as $DOMElements1Node) {

            $this->assertEquals('xsd:element', $DOMElements1Node->tagName);
            $this->assertEquals('name', $DOMElements1Node->getAttribute('name'));
            $this->assertEquals('xsd:string', $DOMElements1Node->getAttribute('type'));
        }
    }

    /**
     * @test
     */
    public function shouldGenerateDOMElementsForTypesArrayOfSimpleType()
    {
        //given
        $parameters = [
            new Parameter(new Node('string', '$numbers', true), true)
        ];

        //when
        $DOMElements = $this->XMLRpcStyle->generateTypes($this->DOMDocument, $parameters, 'soap');

        //then
        Assert::thatArray($DOMElements)
            ->extracting('tagName')
            ->containsExactly('xsd:complexType');

        //<xsd:complexType name="ArrayOfNumbers">
        //    <xsd:complexContent>
        //        <xsd:restriction base="soapenc:Array">
        //            <xsd:attribute ref="soapenc:arrayType" soap:arrayType="xsd:string[]"/>
        //        </xsd:restriction>
        //    </xsd:complexContent>
        //</xsd:complexType>
        $this->assertEquals('ArrayOfNumbers', $DOMElements[0]->getAttribute('name'));
        $complexContentActual = $DOMElements[0]->getElementsByTagName('xsd:complexContent');
        $complexContentActual = $complexContentActual->item(0);
        $this->assertEquals('xsd:complexContent', $complexContentActual->tagName);
        $restrictionActual = $complexContentActual->getElementsByTagName('xsd:restriction');
        $restrictionActual = $restrictionActual->item(0);
        $this->assertEquals('xsd:restriction', $restrictionActual->tagName);
        $this->assertEquals('soapenc:Array', $restrictionActual->getAttribute('base'));
        $attributeActual = $restrictionActual->getElementsByTagName('xsd:attribute');
        $attributeActual = $attributeActual->item(0);
        $this->assertEquals('xsd:attribute', $attributeActual->tagName);
        $this->assertEquals('soapenc:arrayType', $attributeActual->getAttribute('ref'));
        $this->assertEquals('xsd:string[]', $attributeActual->getAttribute('soap:arrayType'));
    }

    /**
     * @test
     */
    public function shouldGenerateDOMElementsForTypesArrayOfObjectType()
    {
        //given
        $parameters = [
            new Parameter(new Node('object', '$users', true, [new Node('string', '$name', false)]), true)
        ];

        //when
        $DOMElements = $this->XMLRpcStyle->generateTypes($this->DOMDocument, $parameters, 'soap');

        //then
        Assert::thatArray($DOMElements)
            ->extracting('tagName')
            ->containsExactly('xsd:complexType', 'xsd:element', 'xsd:complexType');

        //<xsd:complexType name="ArrayOfUsers">
        //    <xsd:complexContent>
        //        <xsd:restriction base="soapenc:Array">
        //            <xsd:attribute ref="soapenc:arrayType" soap:arrayType="ns:User[]"/>
        //        </xsd:restriction>
        //    </xsd:complexContent>
        //</xsd:complexType>
        $this->assertEquals('ArrayOfUsers', $DOMElements[0]->getAttribute('name'));
        $complexContentActual = $DOMElements[0]->getElementsByTagName('xsd:complexContent');
        $complexContentActual = $complexContentActual->item(0);
        $this->assertEquals('xsd:complexContent', $complexContentActual->tagName);
        $restrictionActual = $complexContentActual->getElementsByTagName('xsd:restriction');
        $restrictionActual = $restrictionActual->item(0);
        $this->assertEquals('xsd:restriction', $restrictionActual->tagName);
        $this->assertEquals('soapenc:Array', $restrictionActual->getAttribute('base'));
        $attributeActual = $restrictionActual->getElementsByTagName('xsd:attribute');
        $attributeActual = $attributeActual->item(0);
        $this->assertEquals('xsd:attribute', $attributeActual->tagName);
        $this->assertEquals('soapenc:arrayType', $attributeActual->getAttribute('ref'));
        $this->assertEquals('ns:User[]', $attributeActual->getAttribute('soap:arrayType'));

        //<xsd:element name="User" nillable="true" type="ns:User"/>
        $this->assertEquals('User', $DOMElements[1]->getAttribute('name'));
        $this->assertEquals('true', $DOMElements[1]->getAttribute('nillable'));
        $this->assertEquals('ns:User', $DOMElements[1]->getAttribute('type'));

        //<xsd:complexType name="User">
        //    <xsd:sequence>
        //        <xsd:element name="name" type="xsd:string"/>
        //    </xsd:sequence>
        //</xsd:complexType>
        $this->assertEquals('User', $DOMElements[2]->getAttribute('name'));
        $sequenceActual = $DOMElements[2]->getElementsByTagName('xsd:sequence');
        $sequenceActual = $sequenceActual->item(0);
        $this->assertEquals('xsd:sequence', $sequenceActual->tagName);

        $DOMElements1Nodes = $sequenceActual->getElementsByTagName('xsd:element');
        foreach ($DOMElements1Nodes as $DOMElements1Node) {

            $this->assertEquals('xsd:element', $DOMElements1Node->tagName);
            $this->assertEquals('name', $DOMElements1Node->getAttribute('name'));
            $this->assertEquals('xsd:string', $DOMElements1Node->getAttribute('type'));
        }
    }

    /**
     * @test
     */
    public function shouldGenerateDOMElementsForTypesObjectWithSimpleTypeAndObjectInside()
    {
        //given
        $elements = [
            new Node('string', '$name', false),
            new Node('object', '$agent', false, [new Node('int', '$number', false)])
        ];
        $parameters = [
            new Parameter(new Node('object', '$user', false, $elements), true)
        ];

        //when
        $DOMElements = $this->XMLRpcStyle->generateTypes($this->DOMDocument, $parameters, 'soap');

        //then
        Assert::thatArray($DOMElements)
            ->extracting('tagName')
            ->containsExactly('xsd:element', 'xsd:complexType', 'xsd:element', 'xsd:complexType');

        //<xsd:element name="User" nillable="true" type="ns:User"/>
        $this->assertEquals('User', $DOMElements[0]->getAttribute('name'));
        $this->assertEquals('true', $DOMElements[0]->getAttribute('nillable'));
        $this->assertEquals('ns:User', $DOMElements[0]->getAttribute('type'));

        //<xsd:complexType name="User">
        //    <xsd:sequence>
        //        <xsd:element name="name" type="xsd:string"/>
        //        <xsd:element name="name" element="ns:Agent"/>
        //    </xsd:sequence>
        //</xsd:complexType>
        $this->assertEquals('User', $DOMElements[1]->getAttribute('name'));
        $sequenceActual = $DOMElements[1]->getElementsByTagName('xsd:sequence');
        $sequenceActual = $sequenceActual->item(0);
        $this->assertEquals('xsd:sequence', $sequenceActual->tagName);

        $DOMElementsNodes = $sequenceActual->getElementsByTagName('xsd:element');
        $DOMElements1Nodes = $DOMElementsNodes->item(0);
        $this->assertEquals('xsd:element', $DOMElements1Nodes->tagName);
        $this->assertEquals('name', $DOMElements1Nodes->getAttribute('name'));
        $this->assertEquals('xsd:string', $DOMElements1Nodes->getAttribute('type'));
        $DOMElements2Nodes = $DOMElementsNodes->item(1);
        $this->assertEquals('xsd:element', $DOMElements2Nodes->tagName);
        $this->assertEquals('agent', $DOMElements2Nodes->getAttribute('name'));
        $this->assertEquals('ns:Agent', $DOMElements2Nodes->getAttribute('element'));

        //<xsd:element name="Agent" nillable="true" type="ns:Agent"/>
        $this->assertEquals('Agent', $DOMElements[2]->getAttribute('name'));
        $this->assertEquals('true', $DOMElements[2]->getAttribute('nillable'));
        $this->assertEquals('ns:Agent', $DOMElements[2]->getAttribute('type'));

        //<xsd:complexType name="Agent">
        //    <xsd:sequence>
        //        <xsd:element name="number" type="xsd:int"/>
        //    </xsd:sequence>
        //</xsd:complexType>
        $this->assertEquals('Agent', $DOMElements[3]->getAttribute('name'));
        $sequenceActual = $DOMElements[3]->getElementsByTagName('xsd:sequence');
        $sequenceActual = $sequenceActual->item(0);
        $this->assertEquals('xsd:sequence', $sequenceActual->tagName);

        $DOMElementsNodes = $sequenceActual->getElementsByTagName('xsd:element');
        $DOMElements1Nodes = $DOMElementsNodes->item(0);
        $this->assertEquals('xsd:element', $DOMElements1Nodes->tagName);
        $this->assertEquals('number', $DOMElements1Nodes->getAttribute('name'));
        $this->assertEquals('xsd:int', $DOMElements1Nodes->getAttribute('type'));
    }

    /**
     * @test
     */
    public function shouldGenerateDOMElementsForTypesObjectWithArrayOfSimpleInside()
    {
        //given
        $elements = [
            new Node('string', '$names', true)
        ];
        $parameters = [
            new Parameter(new Node('object', '$user', false, $elements), true)
        ];

        //when
        $DOMElements = $this->XMLRpcStyle->generateTypes($this->DOMDocument, $parameters, 'soap');

        //then
        Assert::thatArray($DOMElements)
            ->extracting('tagName')
            ->containsExactly('xsd:element', 'xsd:complexType', 'xsd:complexType');

        //<xsd:element name="User" nillable="true" type="ns:User"/>
        $this->assertEquals('User', $DOMElements[0]->getAttribute('name'));
        $this->assertEquals('true', $DOMElements[0]->getAttribute('nillable'));
        $this->assertEquals('ns:User', $DOMElements[0]->getAttribute('type'));

        //<xsd:complexType name="User">
        //    <xsd:sequence>
        //        <xsd:element name="names" type="ns:ArrayOdNames"/>
        //    </xsd:sequence>
        //</xsd:complexType>
        $this->assertEquals('User', $DOMElements[1]->getAttribute('name'));
        $sequenceActual = $DOMElements[1]->getElementsByTagName('xsd:sequence');
        $sequenceActual = $sequenceActual->item(0);
        $this->assertEquals('xsd:sequence', $sequenceActual->tagName);

        $DOMElementsNodes = $sequenceActual->getElementsByTagName('xsd:element');
        $DOMElements1Nodes = $DOMElementsNodes->item(0);
        $this->assertEquals('xsd:element', $DOMElements1Nodes->tagName);
        $this->assertEquals('names', $DOMElements1Nodes->getAttribute('name'));
        $this->assertEquals('ns:ArrayOfNames', $DOMElements1Nodes->getAttribute('type'));

        //<xsd:complexType name="ArrayOfNames">
        //    <xsd:complexContent>
        //        <xsd:restriction base="soapenc:Array">
        //            <xsd:attribute ref="soapenc:arrayType" soap:arrayType="ns:User[]"/>
        //        </xsd:restriction>
        //    </xsd:complexContent>
        //</xsd:complexType>
        $this->assertEquals('ArrayOfNames', $DOMElements[2]->getAttribute('name'));
        $complexContentActual = $DOMElements[2]->getElementsByTagName('xsd:complexContent');
        $complexContentActual = $complexContentActual->item(0);
        $this->assertEquals('xsd:complexContent', $complexContentActual->tagName);
        $restrictionActual = $complexContentActual->getElementsByTagName('xsd:restriction');
        $restrictionActual = $restrictionActual->item(0);
        $this->assertEquals('xsd:restriction', $restrictionActual->tagName);
        $this->assertEquals('soapenc:Array', $restrictionActual->getAttribute('base'));
        $attributeActual = $restrictionActual->getElementsByTagName('xsd:attribute');
        $attributeActual = $attributeActual->item(0);
        $this->assertEquals('xsd:attribute', $attributeActual->tagName);
        $this->assertEquals('soapenc:arrayType', $attributeActual->getAttribute('ref'));
        $this->assertEquals('xsd:string[]', $attributeActual->getAttribute('soap:arrayType'));
    }
}


1		<?php
2		/**
3		* Copyright (C) 2013-2020
4		* Piotr Olaszewski <[email protected]>
5		*
6		* Permission is hereby granted, free of charge, to any person obtaining a copy
7		* of this software and associated documentation files (the "Software"), to deal
8		* in the Software without restriction, including without limitation the rights
9		* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10		* copies of the Software, and to permit persons to whom the Software is
11		* furnished to do so, subject to the following conditions:
12		*
13		* The above copyright notice and this permission notice shall be included in
14		* all copies or substantial portions of the Software.
15		*
16		* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17		* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18		* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19		* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20		* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21		* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22		* SOFTWARE.
23		*/
24		namespace Tests\WSDL\XML\XMLStyle;
25
26		use DOMDocument;
27		use Ouzo\Tests\Assert;
28		use PHPUnit\Framework\TestCase;
29		use WSDL\Builder\Parameter;
30		use WSDL\Parser\Node;
31		use WSDL\XML\XMLStyle\XMLRpcStyle;
32
33		/**
34		* XMLRpcStyleTest
35		*
36		* @author Piotr Olaszewski <[email protected]>
37		*/
38		class XMLRpcStyleTest extends TestCase
39		{
40		/**
41		* @var DOMDocument
42		*/
43		private $DOMDocument;
44		/**
45		* @var XMLRpcStyle
46		*/
47		private $XMLRpcStyle;
48
49		protected function setUp(): void
50		{
51		parent::setUp();
52		$this->DOMDocument = new DOMDocument();
53		$this->XMLRpcStyle = new XMLRpcStyle();
54		}
55
56		/**
57		* @test
58		*/
59	View Code Duplication	public function shouldGenerateDOMElementForBinding()
		0 ignored issues – show Duplication introduced 2018-04-06 17:48 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
60		{
61		//when
62		$DOMElement = $this->XMLRpcStyle->generateBinding($this->DOMDocument, 'soap');
63
64		//then
65		$this->assertEquals('soap:binding', $DOMElement->tagName);
66		$this->assertEquals('rpc', $DOMElement->getAttribute('style'));
67		$this->assertEquals('http://schemas.xmlsoap.org/soap/http', $DOMElement->getAttribute('transport'));
68		}
69
70		/**
71		* @test
72		*/
73	View Code Duplication	public function shouldGenerateDOMElementsForMessage()
		0 ignored issues – show Duplication introduced 2018-04-06 17:48 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
74		{
75		//given
76		$nodes = [
77		new Node('int', '$age', false),
78		new Node('object', '$user', false, [new Node('string', '$name', false)]),
79		new Node('string', '$numbers', true)
80		];
81
82		//when
83		$DOMElements = $this->XMLRpcStyle->generateMessagePart($this->DOMDocument, $nodes);
84
85		//then
86		Assert::thatArray($DOMElements)->extracting('tagName')->containsExactly('part', 'part', 'part');
87
88		$this->assertEquals('age', $DOMElements[0]->getAttribute('name'));
89		$this->assertEquals('xsd:int', $DOMElements[0]->getAttribute('type'));
90
91		$this->assertEquals('user', $DOMElements[1]->getAttribute('name'));
92		$this->assertEquals('ns:User', $DOMElements[1]->getAttribute('element'));
93
94		$this->assertEquals('numbers', $DOMElements[2]->getAttribute('name'));
95		$this->assertEquals('ns:ArrayOfNumbers', $DOMElements[2]->getAttribute('type'));
96		}
97
98		/**
99		* @test
100		*/
101		public function shouldGenerateDOMElementsForTypesObject()
102		{
103		//given
104		$parameters = [
105		new Parameter(new Node('object', '$user', false, [new Node('string', '$name', false)]), false)
106		];
107
108		//when
109		$DOMElements = $this->XMLRpcStyle->generateTypes($this->DOMDocument, $parameters, 'soap');
110
111		//then
112		Assert::thatArray($DOMElements)
113		->extracting('tagName')
114		->containsExactly('xsd:element', 'xsd:complexType');
115
116		//<xsd:element name="User" nillable="true" type="ns:User"/>
117		$this->assertEquals('User', $DOMElements[0]->getAttribute('name'));
118		$this->assertEquals('true', $DOMElements[0]->getAttribute('nillable'));
119		$this->assertEquals('ns:User', $DOMElements[0]->getAttribute('type'));
120
121		//<xsd:complexType name="User">
122		// <xsd:sequence>
123		// <xsd:element name="name" type="xsd:string"/>
124		// </xsd:sequence>
125		//</xsd:complexType>
126		$this->assertEquals('User', $DOMElements[1]->getAttribute('name'));
127		$sequenceActual = $DOMElements[1]->getElementsByTagName('xsd:sequence');
128		$sequenceActual = $sequenceActual->item(0);
129		$this->assertEquals('xsd:sequence', $sequenceActual->tagName);
130		$DOMElements1Nodes = $sequenceActual->getElementsByTagName('xsd:element');
131	View Code Duplication	foreach ($DOMElements1Nodes as $DOMElements1Node) {
		0 ignored issues – show Duplication introduced 2016-07-27 05:23 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
132		$this->assertEquals('xsd:element', $DOMElements1Node->tagName);
133		$this->assertEquals('name', $DOMElements1Node->getAttribute('name'));
134		$this->assertEquals('xsd:string', $DOMElements1Node->getAttribute('type'));
135		}
136		}
137
138		/**
139		* @test
140		*/
141		public function shouldGenerateDOMElementsForTypesArrayOfSimpleType()
142		{
143		//given
144		$parameters = [
145		new Parameter(new Node('string', '$numbers', true), true)
146		];
147
148		//when
149		$DOMElements = $this->XMLRpcStyle->generateTypes($this->DOMDocument, $parameters, 'soap');
150
151		//then
152		Assert::thatArray($DOMElements)
153		->extracting('tagName')
154		->containsExactly('xsd:complexType');
155
156		//<xsd:complexType name="ArrayOfNumbers">
157		// <xsd:complexContent>
158		// <xsd:restriction base="soapenc:Array">
159		// <xsd:attribute ref="soapenc:arrayType" soap:arrayType="xsd:string[]"/>
160		// </xsd:restriction>
161		// </xsd:complexContent>
162		//</xsd:complexType>
163		$this->assertEquals('ArrayOfNumbers', $DOMElements[0]->getAttribute('name'));
164		$complexContentActual = $DOMElements[0]->getElementsByTagName('xsd:complexContent');
165		$complexContentActual = $complexContentActual->item(0);
166		$this->assertEquals('xsd:complexContent', $complexContentActual->tagName);
167		$restrictionActual = $complexContentActual->getElementsByTagName('xsd:restriction');
168		$restrictionActual = $restrictionActual->item(0);
169		$this->assertEquals('xsd:restriction', $restrictionActual->tagName);
170		$this->assertEquals('soapenc:Array', $restrictionActual->getAttribute('base'));
171		$attributeActual = $restrictionActual->getElementsByTagName('xsd:attribute');
172		$attributeActual = $attributeActual->item(0);
173		$this->assertEquals('xsd:attribute', $attributeActual->tagName);
174		$this->assertEquals('soapenc:arrayType', $attributeActual->getAttribute('ref'));
175		$this->assertEquals('xsd:string[]', $attributeActual->getAttribute('soap:arrayType'));
176		}
177
178		/**
179		* @test
180		*/
181		public function shouldGenerateDOMElementsForTypesArrayOfObjectType()
182		{
183		//given
184		$parameters = [
185		new Parameter(new Node('object', '$users', true, [new Node('string', '$name', false)]), true)
186		];
187
188		//when
189		$DOMElements = $this->XMLRpcStyle->generateTypes($this->DOMDocument, $parameters, 'soap');
190
191		//then
192		Assert::thatArray($DOMElements)
193		->extracting('tagName')
194		->containsExactly('xsd:complexType', 'xsd:element', 'xsd:complexType');
195
196		//<xsd:complexType name="ArrayOfUsers">
197		// <xsd:complexContent>
198		// <xsd:restriction base="soapenc:Array">
199		// <xsd:attribute ref="soapenc:arrayType" soap:arrayType="ns:User[]"/>
200		// </xsd:restriction>
201		// </xsd:complexContent>
202		//</xsd:complexType>
203		$this->assertEquals('ArrayOfUsers', $DOMElements[0]->getAttribute('name'));
204		$complexContentActual = $DOMElements[0]->getElementsByTagName('xsd:complexContent');
205		$complexContentActual = $complexContentActual->item(0);
206		$this->assertEquals('xsd:complexContent', $complexContentActual->tagName);
207		$restrictionActual = $complexContentActual->getElementsByTagName('xsd:restriction');
208		$restrictionActual = $restrictionActual->item(0);
209		$this->assertEquals('xsd:restriction', $restrictionActual->tagName);
210		$this->assertEquals('soapenc:Array', $restrictionActual->getAttribute('base'));
211		$attributeActual = $restrictionActual->getElementsByTagName('xsd:attribute');
212		$attributeActual = $attributeActual->item(0);
213		$this->assertEquals('xsd:attribute', $attributeActual->tagName);
214		$this->assertEquals('soapenc:arrayType', $attributeActual->getAttribute('ref'));
215		$this->assertEquals('ns:User[]', $attributeActual->getAttribute('soap:arrayType'));
216
217		//<xsd:element name="User" nillable="true" type="ns:User"/>
218		$this->assertEquals('User', $DOMElements[1]->getAttribute('name'));
219		$this->assertEquals('true', $DOMElements[1]->getAttribute('nillable'));
220		$this->assertEquals('ns:User', $DOMElements[1]->getAttribute('type'));
221
222		//<xsd:complexType name="User">
223		// <xsd:sequence>
224		// <xsd:element name="name" type="xsd:string"/>
225		// </xsd:sequence>
226		//</xsd:complexType>
227		$this->assertEquals('User', $DOMElements[2]->getAttribute('name'));
228		$sequenceActual = $DOMElements[2]->getElementsByTagName('xsd:sequence');
229		$sequenceActual = $sequenceActual->item(0);
230		$this->assertEquals('xsd:sequence', $sequenceActual->tagName);
231
232		$DOMElements1Nodes = $sequenceActual->getElementsByTagName('xsd:element');
233	View Code Duplication	foreach ($DOMElements1Nodes as $DOMElements1Node) {
		0 ignored issues – show Duplication introduced 2016-07-27 05:23 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
234		$this->assertEquals('xsd:element', $DOMElements1Node->tagName);
235		$this->assertEquals('name', $DOMElements1Node->getAttribute('name'));
236		$this->assertEquals('xsd:string', $DOMElements1Node->getAttribute('type'));
237		}
238		}
239
240		/**
241		* @test
242		*/
243		public function shouldGenerateDOMElementsForTypesObjectWithSimpleTypeAndObjectInside()
244		{
245		//given
246		$elements = [
247		new Node('string', '$name', false),
248		new Node('object', '$agent', false, [new Node('int', '$number', false)])
249		];
250		$parameters = [
251		new Parameter(new Node('object', '$user', false, $elements), true)
252		];
253
254		//when
255		$DOMElements = $this->XMLRpcStyle->generateTypes($this->DOMDocument, $parameters, 'soap');
256
257		//then
258		Assert::thatArray($DOMElements)
259		->extracting('tagName')
260		->containsExactly('xsd:element', 'xsd:complexType', 'xsd:element', 'xsd:complexType');
261
262		//<xsd:element name="User" nillable="true" type="ns:User"/>
263		$this->assertEquals('User', $DOMElements[0]->getAttribute('name'));
264		$this->assertEquals('true', $DOMElements[0]->getAttribute('nillable'));
265		$this->assertEquals('ns:User', $DOMElements[0]->getAttribute('type'));
266
267		//<xsd:complexType name="User">
268		// <xsd:sequence>
269		// <xsd:element name="name" type="xsd:string"/>
270		// <xsd:element name="name" element="ns:Agent"/>
271		// </xsd:sequence>
272		//</xsd:complexType>
273		$this->assertEquals('User', $DOMElements[1]->getAttribute('name'));
274		$sequenceActual = $DOMElements[1]->getElementsByTagName('xsd:sequence');
275		$sequenceActual = $sequenceActual->item(0);
276		$this->assertEquals('xsd:sequence', $sequenceActual->tagName);
277
278		$DOMElementsNodes = $sequenceActual->getElementsByTagName('xsd:element');
279		$DOMElements1Nodes = $DOMElementsNodes->item(0);
280		$this->assertEquals('xsd:element', $DOMElements1Nodes->tagName);
281		$this->assertEquals('name', $DOMElements1Nodes->getAttribute('name'));
282		$this->assertEquals('xsd:string', $DOMElements1Nodes->getAttribute('type'));
283		$DOMElements2Nodes = $DOMElementsNodes->item(1);
284		$this->assertEquals('xsd:element', $DOMElements2Nodes->tagName);
285		$this->assertEquals('agent', $DOMElements2Nodes->getAttribute('name'));
286		$this->assertEquals('ns:Agent', $DOMElements2Nodes->getAttribute('element'));
287
288		//<xsd:element name="Agent" nillable="true" type="ns:Agent"/>
289		$this->assertEquals('Agent', $DOMElements[2]->getAttribute('name'));
290		$this->assertEquals('true', $DOMElements[2]->getAttribute('nillable'));
291		$this->assertEquals('ns:Agent', $DOMElements[2]->getAttribute('type'));
292
293		//<xsd:complexType name="Agent">
294		// <xsd:sequence>
295		// <xsd:element name="number" type="xsd:int"/>
296		// </xsd:sequence>
297		//</xsd:complexType>
298		$this->assertEquals('Agent', $DOMElements[3]->getAttribute('name'));
299		$sequenceActual = $DOMElements[3]->getElementsByTagName('xsd:sequence');
300		$sequenceActual = $sequenceActual->item(0);
301		$this->assertEquals('xsd:sequence', $sequenceActual->tagName);
302
303		$DOMElementsNodes = $sequenceActual->getElementsByTagName('xsd:element');
304		$DOMElements1Nodes = $DOMElementsNodes->item(0);
305		$this->assertEquals('xsd:element', $DOMElements1Nodes->tagName);
306		$this->assertEquals('number', $DOMElements1Nodes->getAttribute('name'));
307		$this->assertEquals('xsd:int', $DOMElements1Nodes->getAttribute('type'));
308		}
309
310		/**
311		* @test
312		*/
313		public function shouldGenerateDOMElementsForTypesObjectWithArrayOfSimpleInside()
314		{
315		//given
316		$elements = [
317		new Node('string', '$names', true)
318		];
319		$parameters = [
320		new Parameter(new Node('object', '$user', false, $elements), true)
321		];
322
323		//when
324		$DOMElements = $this->XMLRpcStyle->generateTypes($this->DOMDocument, $parameters, 'soap');
325
326		//then
327		Assert::thatArray($DOMElements)
328		->extracting('tagName')
329		->containsExactly('xsd:element', 'xsd:complexType', 'xsd:complexType');
330
331		//<xsd:element name="User" nillable="true" type="ns:User"/>
332		$this->assertEquals('User', $DOMElements[0]->getAttribute('name'));
333		$this->assertEquals('true', $DOMElements[0]->getAttribute('nillable'));
334		$this->assertEquals('ns:User', $DOMElements[0]->getAttribute('type'));
335
336		//<xsd:complexType name="User">
337		// <xsd:sequence>
338		// <xsd:element name="names" type="ns:ArrayOdNames"/>
339		// </xsd:sequence>
340		//</xsd:complexType>
341		$this->assertEquals('User', $DOMElements[1]->getAttribute('name'));
342		$sequenceActual = $DOMElements[1]->getElementsByTagName('xsd:sequence');
343		$sequenceActual = $sequenceActual->item(0);
344		$this->assertEquals('xsd:sequence', $sequenceActual->tagName);
345
346		$DOMElementsNodes = $sequenceActual->getElementsByTagName('xsd:element');
347		$DOMElements1Nodes = $DOMElementsNodes->item(0);
348		$this->assertEquals('xsd:element', $DOMElements1Nodes->tagName);
349		$this->assertEquals('names', $DOMElements1Nodes->getAttribute('name'));
350		$this->assertEquals('ns:ArrayOfNames', $DOMElements1Nodes->getAttribute('type'));
351
352		//<xsd:complexType name="ArrayOfNames">
353		// <xsd:complexContent>
354		// <xsd:restriction base="soapenc:Array">
355		// <xsd:attribute ref="soapenc:arrayType" soap:arrayType="ns:User[]"/>
356		// </xsd:restriction>
357		// </xsd:complexContent>
358		//</xsd:complexType>
359		$this->assertEquals('ArrayOfNames', $DOMElements[2]->getAttribute('name'));
360		$complexContentActual = $DOMElements[2]->getElementsByTagName('xsd:complexContent');
361		$complexContentActual = $complexContentActual->item(0);
362		$this->assertEquals('xsd:complexContent', $complexContentActual->tagName);
363		$restrictionActual = $complexContentActual->getElementsByTagName('xsd:restriction');
364		$restrictionActual = $restrictionActual->item(0);
365		$this->assertEquals('xsd:restriction', $restrictionActual->tagName);
366		$this->assertEquals('soapenc:Array', $restrictionActual->getAttribute('base'));
367		$attributeActual = $restrictionActual->getElementsByTagName('xsd:attribute');
368		$attributeActual = $attributeActual->item(0);
369		$this->assertEquals('xsd:attribute', $attributeActual->tagName);
370		$this->assertEquals('soapenc:arrayType', $attributeActual->getAttribute('ref'));
371		$this->assertEquals('xsd:string[]', $attributeActual->getAttribute('soap:arrayType'));
372		}
373		}
374

piotrooo / wsdl-creator

shouldGenerateDOMElementForBinding() A last analyzed 2020-03-15 19:17 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

shouldGenerateDOMElementForBinding() A
last analyzed 2020-03-15 19:17 UTC