Issues in InterfaceDescriptorTest.php - All Issues - Inspection of "Simplified Twig writer" - phpDocumentor/phpDocumentor - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 0cc20e...dccdc9 )

by Mike

created 2019-06-16 07:55 UTC

Descriptor/InterfaceDescriptorTest.php (1 issue)

Labels

Documentation 1

Severity

Minor 1

Ceeram 1

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php
/**
 * phpDocumentor
 *
 * PHP Version 5.3
 *
 * @copyright 2010-2018 Mike van Riel / Naenius (http://www.naenius.com)
 * @license   http://www.opensource.org/licenses/mit-license.php MIT
 * @link      http://phpdoc.org
 */

namespace phpDocumentor\Descriptor;

use Mockery as m;
use phpDocumentor\Descriptor\Tag\AuthorDescriptor;
use phpDocumentor\Descriptor\Tag\VersionDescriptor;

/**
 * Tests the functionality for the InterfaceDescriptor class.
 * @coversDefaultClass \phpDocumentor\Descriptor\InterfaceDescriptor
 */
class InterfaceDescriptorTest extends \Mockery\Adapter\Phpunit\MockeryTestCase
{
    /** @var InterfaceDescriptor $fixture */
    protected $fixture;

    /**
     * Creates a new (empty) fixture object.
     */
    protected function setUp()
    {
        $this->fixture = new InterfaceDescriptor();
    }

    /**
     * Tests whether all collection objects are properly initialized.
     *
     * @covers ::__construct
     */
    public function testInitialize()
    {
        $this->assertAttributeInstanceOf(Collection::class, 'parents', $this->fixture);
        $this->assertAttributeInstanceOf(Collection::class, 'constants', $this->fixture);
        $this->assertAttributeInstanceOf(Collection::class, 'methods', $this->fixture);
    }

    /**
     * @covers ::setParent
     * @covers ::getParent
     */
    public function testSettingAndGettingParentInterfaces()
    {
        $this->assertInstanceOf(Collection::class, $this->fixture->getParent());

        $mock = m::mock(Collection::class);

        $this->fixture->setParent($mock);

        $this->assertSame($mock, $this->fixture->getParent());
    }

    /**
     * @covers ::setConstants
     * @covers ::getConstants
     */
    public function testSettingAndGettingConstants()
    {
        $this->assertInstanceOf(Collection::class, $this->fixture->getConstants());

        $mock = m::mock(Collection::class);

        $this->fixture->setConstants($mock);

        $this->assertSame($mock, $this->fixture->getConstants());
    }

    /**
     * @covers ::setMethods
     * @covers ::getMethods
     */
    public function testSettingAndGettingMethods()
    {
        $this->assertInstanceOf(Collection::class, $this->fixture->getMethods());

        $mock = m::mock(Collection::class);

        $this->fixture->setMethods($mock);

        $this->assertSame($mock, $this->fixture->getMethods());
    }

    /**
     * @covers ::getInheritedConstants
     */
    public function testGetInheritedConstantsNoParent()
    {
        $descriptor = new InterfaceDescriptor();
        $this->assertInstanceOf(Collection::class, $descriptor->getInheritedConstants());

        $descriptor->setParent(new \stdClass());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $this->assertInstanceOf(Collection::class, $descriptor->getInheritedConstants());
    }

    /**
     * @covers \phpDocumentor\Descriptor\DescriptorAbstract::getSummary
     */
    public function testSummaryInheritsWhenNoneIsPresent()
    {
        // Arrange
        $summary = 'This is a summary';
        $this->fixture->setSummary(null);
        $parentInterface = $this->whenFixtureHasParentInterface();
        $parentInterface->setSummary($summary);

        // Act
        $result = $this->fixture->getSummary();

        // Assert
        $this->assertSame($summary, $result);
    }

    /**
     * @covers \phpDocumentor\Descriptor\DescriptorAbstract::getDescription
     */
    public function testDescriptionInheritsWhenNoneIsPresent()
    {
        // Arrange
        $description = 'This is a description';
        $this->fixture->setDescription(null);
        $parentInterface = $this->whenFixtureHasParentInterface();
        $parentInterface->setDescription($description);

        // Act
        $result = $this->fixture->getDescription();

        // Assert
        $this->assertSame($description, $result);
    }

    /**
     * @covers \phpDocumentor\Descriptor\DescriptorAbstract::getAuthor
     */
    public function testAuthorTagsInheritWhenNoneArePresent()
    {
        // Arrange
        $authorTagDescriptor = new AuthorDescriptor('author');
        $authorCollection = new Collection([$authorTagDescriptor]);
        $this->fixture->getTags()->clear();
        $parentProperty = $this->whenFixtureHasParentInterface();
        $parentProperty->getTags()->set('author', $authorCollection);

        // Act
        $result = $this->fixture->getAuthor();

        // Assert
        $this->assertSame($authorCollection, $result);
    }

    /**
     * @covers \phpDocumentor\Descriptor\DescriptorAbstract::getCopyright
     */
    public function testCopyrightTagsInheritWhenNoneArePresent()
    {
        // Arrange
        $copyrightTagDescriptor = new TagDescriptor('copyright');
        $copyrightCollection = new Collection([$copyrightTagDescriptor]);
        $this->fixture->getTags()->clear();
        $parentProperty = $this->whenFixtureHasParentInterface();
        $parentProperty->getTags()->set('copyright', $copyrightCollection);

        // Act
        $result = $this->fixture->getCopyright();

        // Assert
        $this->assertSame($copyrightCollection, $result);
    }

    /**
     * @covers \phpDocumentor\Descriptor\DescriptorAbstract::getVersion
     */
    public function testVersionTagsInheritWhenNoneArePresent()
    {
        // Arrange
        $versionTagDescriptor = new VersionDescriptor('version');
        $versionCollection = new Collection([$versionTagDescriptor]);
        $this->fixture->getTags()->clear();
        $parentProperty = $this->whenFixtureHasParentInterface();
        $parentProperty->getTags()->set('version', $versionCollection);

        // Act
        $result = $this->fixture->getVersion();

        // Assert
        $this->assertSame($versionCollection, $result);
    }

    /**
     * @covers ::getInheritedConstants
     */
    public function testGetInheritedConstantsWithClassDescriptorParent()
    {
        $constantInParent = $this->givenConstantWithName('constant');
        $constantInGrandParent = $this->givenConstantWithName('constantInGrandParent');
        $constantInParentClass = $this->givenConstantWithName('constantInClass');

        $parentInterface = new InterfaceDescriptor();
        $parentInterface->setConstants(new Collection([$constantInParent]));

        $parentClass = new ClassDescriptor();
        $parentClass->setConstants(new Collection([$constantInParentClass]));

        $grandParentInterface = new InterfaceDescriptor();
        $grandParentInterface->setConstants(new Collection([$constantInGrandParent]));

        $parentInterface->setParent(new Collection([$grandParentInterface]));
        $this->fixture->setParent(new Collection([$parentInterface, $parentClass]));

        $result = $this->fixture->getInheritedConstants();

        $this->assertInstanceOf(Collection::class, $result);
        $this->assertSame([$constantInParent, $constantInGrandParent], $result->getAll());
    }

    /**
     * @covers ::getInheritedMethods
     */
    public function testRetrievingInheritedMethodsReturnsEmptyCollectionWithoutParent()
    {
        $inheritedMethods = $this->fixture->getInheritedMethods();
        $this->assertInstanceOf(Collection::class, $inheritedMethods);
        $this->assertCount(0, $inheritedMethods);
    }

    /**
     * @covers ::getInheritedMethods
     */
    public function testRetrievingInheritedMethodsReturnsCollectionWithParent()
    {
        $parentDescriptor = new MethodDescriptor();
        $parentDescriptor->setName('parent');
        $parentDescriptorCollection = new Collection();
        $parentDescriptorCollection->add($parentDescriptor);
        $parent = new InterfaceDescriptor();
        $parent->setMethods($parentDescriptorCollection);
        $parentCollection = new Collection();
        $parentCollection->add($parent);

        $grandParentDescriptor = new MethodDescriptor();
        $grandParentDescriptor->setName('grandparent');
        $grandParentDescriptorCollection = new Collection();
        $grandParentDescriptorCollection->add($grandParentDescriptor);
        $grandParent = new InterfaceDescriptor();
        $grandParent->setMethods($grandParentDescriptorCollection);
        $grandParentCollection = new Collection();
        $grandParentCollection->add($grandParent);

        $parent->setParent($grandParentCollection);

        $this->fixture->setParent($parentCollection);
        $result = $this->fixture->getInheritedMethods();

        $this->assertInstanceOf(Collection::class, $result);

        $this->assertSame([$parentDescriptor, $grandParentDescriptor], $result->getAll());
    }

    /**
     * @return InterfaceDescriptor
     */
    protected function whenFixtureHasParentInterface()
    {
        $interface = new InterfaceDescriptor();
        $this->fixture->getParent()->set('IA', $interface);

        return $interface;
    }

    private function givenConstantWithName(string $name): ConstantDescriptor
    {
        $constantInParent = new ConstantDescriptor();
        $constantInParent->setName($name);

        return $constantInParent;
    }
}


1			<?php
2			/**
3			* phpDocumentor
4			*
5			* PHP Version 5.3
6			*
7			* @copyright 2010-2018 Mike van Riel / Naenius (http://www.naenius.com)
8			* @license http://www.opensource.org/licenses/mit-license.php MIT
9			* @link http://phpdoc.org
10			*/
11
12			namespace phpDocumentor\Descriptor;
13
14			use Mockery as m;
15			use phpDocumentor\Descriptor\Tag\AuthorDescriptor;
16			use phpDocumentor\Descriptor\Tag\VersionDescriptor;
17
18			/**
19			* Tests the functionality for the InterfaceDescriptor class.
20			* @coversDefaultClass \phpDocumentor\Descriptor\InterfaceDescriptor
21			*/
22			class InterfaceDescriptorTest extends \Mockery\Adapter\Phpunit\MockeryTestCase
23			{
24			/** @var InterfaceDescriptor $fixture */
25			protected $fixture;
26
27			/**
28			* Creates a new (empty) fixture object.
29			*/
30			protected function setUp()
31			{
32			$this->fixture = new InterfaceDescriptor();
33			}
34
35			/**
36			* Tests whether all collection objects are properly initialized.
37			*
38			* @covers ::__construct
39			*/
40			public function testInitialize()
41			{
42			$this->assertAttributeInstanceOf(Collection::class, 'parents', $this->fixture);
43			$this->assertAttributeInstanceOf(Collection::class, 'constants', $this->fixture);
44			$this->assertAttributeInstanceOf(Collection::class, 'methods', $this->fixture);
45			}
46
47			/**
48			* @covers ::setParent
49			* @covers ::getParent
50			*/
51			public function testSettingAndGettingParentInterfaces()
52			{
53			$this->assertInstanceOf(Collection::class, $this->fixture->getParent());
54
55			$mock = m::mock(Collection::class);
56
57			$this->fixture->setParent($mock);
58
59			$this->assertSame($mock, $this->fixture->getParent());
60			}
61
62			/**
63			* @covers ::setConstants
64			* @covers ::getConstants
65			*/
66			public function testSettingAndGettingConstants()
67			{
68			$this->assertInstanceOf(Collection::class, $this->fixture->getConstants());
69
70			$mock = m::mock(Collection::class);
71
72			$this->fixture->setConstants($mock);
73
74			$this->assertSame($mock, $this->fixture->getConstants());
75			}
76
77			/**
78			* @covers ::setMethods
79			* @covers ::getMethods
80			*/
81			public function testSettingAndGettingMethods()
82			{
83			$this->assertInstanceOf(Collection::class, $this->fixture->getMethods());
84
85			$mock = m::mock(Collection::class);
86
87			$this->fixture->setMethods($mock);
88
89			$this->assertSame($mock, $this->fixture->getMethods());
90			}
91
92			/**
93			* @covers ::getInheritedConstants
94			*/
95			public function testGetInheritedConstantsNoParent()
96			{
97			$descriptor = new InterfaceDescriptor();
98			$this->assertInstanceOf(Collection::class, $descriptor->getInheritedConstants());
99
100			$descriptor->setParent(new \stdClass());
			0 ignored issues – show Documentation introduced 2019-01-27 07:58 UTC by Report Bug Copy Issue Report Show Similar Issues like this `new \stdClass()` is of type `object<stdClass>`, but the function expects a `object<phpDocumentor\Descriptor\Collection>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
101			$this->assertInstanceOf(Collection::class, $descriptor->getInheritedConstants());
102			}
103
104			/**
105			* @covers \phpDocumentor\Descriptor\DescriptorAbstract::getSummary
106			*/
107			public function testSummaryInheritsWhenNoneIsPresent()
108			{
109			// Arrange
110			$summary = 'This is a summary';
111			$this->fixture->setSummary(null);
112			$parentInterface = $this->whenFixtureHasParentInterface();
113			$parentInterface->setSummary($summary);
114
115			// Act
116			$result = $this->fixture->getSummary();
117
118			// Assert
119			$this->assertSame($summary, $result);
120			}
121
122			/**
123			* @covers \phpDocumentor\Descriptor\DescriptorAbstract::getDescription
124			*/
125			public function testDescriptionInheritsWhenNoneIsPresent()
126			{
127			// Arrange
128			$description = 'This is a description';
129			$this->fixture->setDescription(null);
130			$parentInterface = $this->whenFixtureHasParentInterface();
131			$parentInterface->setDescription($description);
132
133			// Act
134			$result = $this->fixture->getDescription();
135
136			// Assert
137			$this->assertSame($description, $result);
138			}
139
140			/**
141			* @covers \phpDocumentor\Descriptor\DescriptorAbstract::getAuthor
142			*/
143			public function testAuthorTagsInheritWhenNoneArePresent()
144			{
145			// Arrange
146			$authorTagDescriptor = new AuthorDescriptor('author');
147			$authorCollection = new Collection([$authorTagDescriptor]);
148			$this->fixture->getTags()->clear();
149			$parentProperty = $this->whenFixtureHasParentInterface();
150			$parentProperty->getTags()->set('author', $authorCollection);
151
152			// Act
153			$result = $this->fixture->getAuthor();
154
155			// Assert
156			$this->assertSame($authorCollection, $result);
157			}
158
159			/**
160			* @covers \phpDocumentor\Descriptor\DescriptorAbstract::getCopyright
161			*/
162			public function testCopyrightTagsInheritWhenNoneArePresent()
163			{
164			// Arrange
165			$copyrightTagDescriptor = new TagDescriptor('copyright');
166			$copyrightCollection = new Collection([$copyrightTagDescriptor]);
167			$this->fixture->getTags()->clear();
168			$parentProperty = $this->whenFixtureHasParentInterface();
169			$parentProperty->getTags()->set('copyright', $copyrightCollection);
170
171			// Act
172			$result = $this->fixture->getCopyright();
173
174			// Assert
175			$this->assertSame($copyrightCollection, $result);
176			}
177
178			/**
179			* @covers \phpDocumentor\Descriptor\DescriptorAbstract::getVersion
180			*/
181			public function testVersionTagsInheritWhenNoneArePresent()
182			{
183			// Arrange
184			$versionTagDescriptor = new VersionDescriptor('version');
185			$versionCollection = new Collection([$versionTagDescriptor]);
186			$this->fixture->getTags()->clear();
187			$parentProperty = $this->whenFixtureHasParentInterface();
188			$parentProperty->getTags()->set('version', $versionCollection);
189
190			// Act
191			$result = $this->fixture->getVersion();
192
193			// Assert
194			$this->assertSame($versionCollection, $result);
195			}
196
197			/**
198			* @covers ::getInheritedConstants
199			*/
200			public function testGetInheritedConstantsWithClassDescriptorParent()
201			{
202			$constantInParent = $this->givenConstantWithName('constant');
203			$constantInGrandParent = $this->givenConstantWithName('constantInGrandParent');
204			$constantInParentClass = $this->givenConstantWithName('constantInClass');
205
206			$parentInterface = new InterfaceDescriptor();
207			$parentInterface->setConstants(new Collection([$constantInParent]));
208
209			$parentClass = new ClassDescriptor();
210			$parentClass->setConstants(new Collection([$constantInParentClass]));
211
212			$grandParentInterface = new InterfaceDescriptor();
213			$grandParentInterface->setConstants(new Collection([$constantInGrandParent]));
214
215			$parentInterface->setParent(new Collection([$grandParentInterface]));
216			$this->fixture->setParent(new Collection([$parentInterface, $parentClass]));
217
218			$result = $this->fixture->getInheritedConstants();
219
220			$this->assertInstanceOf(Collection::class, $result);
221			$this->assertSame([$constantInParent, $constantInGrandParent], $result->getAll());
222			}
223
224			/**
225			* @covers ::getInheritedMethods
226			*/
227			public function testRetrievingInheritedMethodsReturnsEmptyCollectionWithoutParent()
228			{
229			$inheritedMethods = $this->fixture->getInheritedMethods();
230			$this->assertInstanceOf(Collection::class, $inheritedMethods);
231			$this->assertCount(0, $inheritedMethods);
232			}
233
234			/**
235			* @covers ::getInheritedMethods
236			*/
237			public function testRetrievingInheritedMethodsReturnsCollectionWithParent()
238			{
239			$parentDescriptor = new MethodDescriptor();
240			$parentDescriptor->setName('parent');
241			$parentDescriptorCollection = new Collection();
242			$parentDescriptorCollection->add($parentDescriptor);
243			$parent = new InterfaceDescriptor();
244			$parent->setMethods($parentDescriptorCollection);
245			$parentCollection = new Collection();
246			$parentCollection->add($parent);
247
248			$grandParentDescriptor = new MethodDescriptor();
249			$grandParentDescriptor->setName('grandparent');
250			$grandParentDescriptorCollection = new Collection();
251			$grandParentDescriptorCollection->add($grandParentDescriptor);
252			$grandParent = new InterfaceDescriptor();
253			$grandParent->setMethods($grandParentDescriptorCollection);
254			$grandParentCollection = new Collection();
255			$grandParentCollection->add($grandParent);
256
257			$parent->setParent($grandParentCollection);
258
259			$this->fixture->setParent($parentCollection);
260			$result = $this->fixture->getInheritedMethods();
261
262			$this->assertInstanceOf(Collection::class, $result);
263
264			$this->assertSame([$parentDescriptor, $grandParentDescriptor], $result->getAll());
265			}
266
267			/**
268			* @return InterfaceDescriptor
269			*/
270			protected function whenFixtureHasParentInterface()
271			{
272			$interface = new InterfaceDescriptor();
273			$this->fixture->getParent()->set('IA', $interface);
274
275			return $interface;
276			}
277
278			private function givenConstantWithName(string $name): ConstantDescriptor
279			{
280			$constantInParent = new ConstantDescriptor();
281			$constantInParent->setName($name);
282
283			return $constantInParent;
284			}
285			}
286

phpDocumentor / phpDocumentor

Push — develop ( 0cc20e...dccdc9 )

Descriptor/InterfaceDescriptorTest.php (1 issue)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like