MethodDescriptorTest::testSettingAndGettingAParent() - Code Metrics - Inspection of "Write and update more tests" - phpDocumentor/phpDocumentor - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 48a3ec...fa4cb4 )

by Mike

created 2019-06-15 08:45 UTC

testSettingAndGettingAParent() A

↳ Parent: MethodDescriptorTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?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\ReturnDescriptor;
use phpDocumentor\Descriptor\Tag\VersionDescriptor;
use phpDocumentor\Reflection\Types\String_;

/**
 * Tests the functionality for the MethodDescriptor class.
 *
 * @coversDefaultClass \phpDocumentor\Descriptor\MethodDescriptor
 * @covers ::<private>
 * @covers ::<protected>
 */
class MethodDescriptorTest extends \Mockery\Adapter\Phpunit\MockeryTestCase
{
    /** @var MethodDescriptor $fixture */
    protected $fixture;

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

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

    /**
     * @covers ::setParent
     * @covers ::getParent
     */
    public function testSettingAndGettingAParent()
    {
        $parent = new ClassDescriptor();

        $this->assertNull($this->fixture->getParent());

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

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

    /**
     * @covers ::setArguments
     * @covers ::getArguments
     */
    public function testSettingAndGettingArguments()
    {
        $this->assertInstanceOf(Collection::class, $this->fixture->getArguments());
        $this->assertCount(0, iterator_to_array($this->fixture->getArguments()));

        $argument = new ArgumentDescriptor();
        $argument->setName('name');
        $collection = new Collection([$argument]);

        $this->fixture->setArguments($collection);

        $this->assertInstanceOf(Collection::class, $this->fixture->getArguments());
        $argumentsAsArray = iterator_to_array($this->fixture->getArguments());
        $this->assertCount(1, $argumentsAsArray);
        $this->assertSame($argument, $argumentsAsArray['name']);
        $this->assertSame($argument->getMethod(), $this->fixture);
    }

    /**
     * @covers ::addArgument
     */
    public function testAddingAnArgument()
    {
        $this->assertInstanceOf(Collection::class, $this->fixture->getArguments());
        $this->assertCount(0, iterator_to_array($this->fixture->getArguments()));

        $argument = new ArgumentDescriptor();
        $argument->setName('name');

        $this->fixture->addArgument('name', $argument);

        $this->assertInstanceOf(Collection::class, $this->fixture->getArguments());
        $argumentsAsArray = iterator_to_array($this->fixture->getArguments());
        $this->assertCount(1, $argumentsAsArray);
        $this->assertSame($argument, $argumentsAsArray['name']);
        $this->assertSame($argument->getMethod(), $this->fixture);
    }

    /**
     * @covers ::isAbstract
     * @covers ::setAbstract
     */
    public function testSettingAndGettingWhetherMethodIsAbstract()
    {
        $this->assertFalse($this->fixture->isAbstract());

        $this->fixture->setAbstract(true);

        $this->assertTrue($this->fixture->isAbstract());
    }

    /**
     * @covers ::isFinal
     * @covers ::setFinal
     */
    public function testSettingAndGettingWhetherMethodIsFinal()
    {
        $this->assertFalse($this->fixture->isFinal());

        $this->fixture->setFinal(true);

        $this->assertTrue($this->fixture->isFinal());
    }

    /**
     * @covers ::isStatic
     * @covers ::setStatic
     */
    public function testSettingAndGettingWhetherMethodIsStatic()
    {
        $this->assertFalse($this->fixture->isStatic());

        $this->fixture->setStatic(true);

        $this->assertTrue($this->fixture->isStatic());
    }

    /**
     * @covers ::getVisibility
     * @covers ::setVisibility
     */
    public function testSettingAndGettingVisibility()
    {
        $this->assertEquals('public', $this->fixture->getVisibility());

        $this->fixture->setVisibility('private');

        $this->assertEquals('private', $this->fixture->getVisibility());
    }

    /**
     * @covers ::getResponse
     */
    public function testRetrieveReturnTagForResponse()
    {
        $returnDescriptor = new ReturnDescriptor('return');
        $returnDescriptor->setType(new String_());

        $this->assertNull($this->fixture->getResponse()->getType());

        $this->fixture->getTags()->set('return', new Collection([$returnDescriptor]));

        $this->assertSame($returnDescriptor, $this->fixture->getResponse());
    }

    /**
     * @covers ::setReturnType
     * @covers ::getResponse
     */
    public function testGetResponseReturnsReturnType()
    {
        $returnType = new String_();
        $this->fixture->setReturnType($returnType);

        $this->assertSame($returnType, $this->fixture->getResponse()->getType());
    }

    /**
     * @covers ::getFile
     */
    public function testRetrieveFileAssociatedWithAMethod()
    {
        // Arrange
        $file = $this->whenFixtureIsRelatedToAClassWithFile();

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

        // Assert
        $this->assertAttributeSame(null, 'fileDescriptor', $this->fixture);
        $this->assertSame($file, $result);
    }

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

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

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

    /**
     * @covers ::getSummary
     */
    public function testSummaryInheritsFromImplementedInterfaceWhenNoneIsPresent()
    {
        // Arrange
        $summary = 'This is a summary';
        $this->fixture->setSummary(null);
        $parentMethod = $this->whenFixtureHasMethodInImplementedInterfaceWithSameName($this->fixture->getName());
        $parentMethod->setSummary($summary);

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

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

    /**
     * @covers ::getDescription
     */
    public function testDescriptionInheritsWhenNoneIsPresent()
    {
        // Arrange
        $description = 'This is a description';
        $this->fixture->setDescription(null);
        $parentMethod = $this->whenFixtureHasMethodInParentClassWithSameName($this->fixture->getName());
        $parentMethod->setDescription($description);

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

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

    /**
     * @covers \phpDocumentor\Descriptor\DescriptorAbstract::getDescription
     */
    public function testDescriptionInheritsWhenInheritDocIsPresent()
    {
        // Arrange
        $description = 'This is a description';
        $this->fixture->setDescription('{@inheritDoc}');
        $parentMethod = $this->whenFixtureHasMethodInParentClassWithSameName($this->fixture->getName());
        $parentMethod->setDescription($description);

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

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

    /**
     * @covers \phpDocumentor\Descriptor\DescriptorAbstract::getDescription
     */
    public function testDescriptionIsAugmentedWhenInheritDocInlineTagIsPresent()
    {
        // Arrange
        $description = 'This is a description';
        $this->fixture->setDescription('Original description {@inheritDoc}');
        $parentMethod = $this->whenFixtureHasMethodInParentClassWithSameName($this->fixture->getName());
        $parentMethod->setDescription($description);

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

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

    /**
     * @covers ::getReturn
     */
    public function testReturnTagsInheritWhenNoneArePresent()
    {
        $this->assertInstanceOf(Collection::class, $this->fixture->getReturn());
        $this->assertSame(0, $this->fixture->getReturn()->count());

        $returnTagDescriptor = new AuthorDescriptor('return');
        $returnCollection = new Collection([$returnTagDescriptor]);
        $this->fixture->getTags()->clear();
        $parentProperty = $this->whenFixtureHasMethodInParentClassWithSameName($this->fixture->getName());
        $parentProperty->getTags()->set('return', $returnCollection);

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

        $this->assertSame($returnCollection, $result);
    }

    /**
     * @covers ::getParam
     */
    public function testParamTagsInheritWhenNoneArePresent()
    {
        $this->assertInstanceOf(Collection::class, $this->fixture->getParam());
        $this->assertSame(0, $this->fixture->getParam()->count());

        $paramTagDescriptor = new AuthorDescriptor('param');
        $paramCollection = new Collection([$paramTagDescriptor]);
        $this->fixture->getTags()->clear();
        $parentProperty = $this->whenFixtureHasMethodInParentClassWithSameName($this->fixture->getName());
        $parentProperty->getTags()->set('param', $paramCollection);

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

        $this->assertSame($paramCollection, $result);
    }

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

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

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

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

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

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

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

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

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

    /**
     * Sets up mocks as such that the fixture has a file.
     *
     * @return m\MockInterface|FileDescriptor
     */
    protected function whenFixtureIsDirectlyRelatedToAFile()
    {
        $file = m::mock(FileDescriptor::class);
        $this->fixture->setFile($file);
        return $file;
    }

    /**
     * Sets up mocks as such that the fixture has a parent class, with a file.
     *
     * @return m\MockInterface|FileDescriptor
     */
    protected function whenFixtureIsRelatedToAClassWithFile()
    {
        $file = m::mock(FileDescriptor::class);
        $parent = m::mock(ClassDescriptor::class);
        $parent->shouldReceive('getFile')->andReturn($file);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $parent->shouldReceive('getFullyQualifiedStructuralElementName')->andReturn('Class1');
        $this->fixture->setParent($parent);

        return $file;
    }

    /**
     * @param string $name The name of the current method.
     */
    protected function whenFixtureHasMethodInParentClassWithSameName($name): MethodDescriptor
    {
        $result = new MethodDescriptor();
        $result->setName($name);

        $parent = new ClassDescriptor();
        $parent->getMethods()->set($name, $result);

        $class = new ClassDescriptor();
        $class->setParent($parent);

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

        return $result;
    }

    /**
     * @param string $name The name of the current method.
     */
    protected function whenFixtureHasMethodInImplementedInterfaceWithSameName($name): MethodDescriptor
    {
        $result = new MethodDescriptor();
        $result->setName($name);

        $parent = new InterfaceDescriptor();
        $parent->getMethods()->set($name, $result);

        $class = new ClassDescriptor();
        $class->getInterfaces()->set('Implemented', $parent);

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

        return $result;
    }
}


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\ReturnDescriptor;
17			use phpDocumentor\Descriptor\Tag\VersionDescriptor;
18			use phpDocumentor\Reflection\Types\String_;
19
20			/**
21			* Tests the functionality for the MethodDescriptor class.
22			*
23			* @coversDefaultClass \phpDocumentor\Descriptor\MethodDescriptor
24			* @covers ::<private>
25			* @covers ::<protected>
26			*/
27			class MethodDescriptorTest extends \Mockery\Adapter\Phpunit\MockeryTestCase
28			{
29			/** @var MethodDescriptor $fixture */
30			protected $fixture;
31
32			/**
33			* Creates a new (empty) fixture object.
34			*/
35			protected function setUp()
36			{
37			$this->fixture = new MethodDescriptor();
38			$this->fixture->setName('method');
39			}
40
41			/**
42			* Tests whether all collection objects are properly initialized.
43			*
44			* @covers ::__construct
45			*/
46			public function testInitialize()
47			{
48			$this->assertAttributeInstanceOf(Collection::class, 'arguments', $this->fixture);
49			}
50
51			/**
52			* @covers ::setParent
53			* @covers ::getParent
54			*/
55			public function testSettingAndGettingAParent()
56			{
57			$parent = new ClassDescriptor();
58
59			$this->assertNull($this->fixture->getParent());
60
61			$this->fixture->setParent($parent);
62
63			$this->assertSame($parent, $this->fixture->getParent());
64			}
65
66			/**
67			* @covers ::setArguments
68			* @covers ::getArguments
69			*/
70			public function testSettingAndGettingArguments()
71			{
72			$this->assertInstanceOf(Collection::class, $this->fixture->getArguments());
73			$this->assertCount(0, iterator_to_array($this->fixture->getArguments()));
74
75			$argument = new ArgumentDescriptor();
76			$argument->setName('name');
77			$collection = new Collection([$argument]);
78
79			$this->fixture->setArguments($collection);
80
81			$this->assertInstanceOf(Collection::class, $this->fixture->getArguments());
82			$argumentsAsArray = iterator_to_array($this->fixture->getArguments());
83			$this->assertCount(1, $argumentsAsArray);
84			$this->assertSame($argument, $argumentsAsArray['name']);
85			$this->assertSame($argument->getMethod(), $this->fixture);
86			}
87
88			/**
89			* @covers ::addArgument
90			*/
91			public function testAddingAnArgument()
92			{
93			$this->assertInstanceOf(Collection::class, $this->fixture->getArguments());
94			$this->assertCount(0, iterator_to_array($this->fixture->getArguments()));
95
96			$argument = new ArgumentDescriptor();
97			$argument->setName('name');
98
99			$this->fixture->addArgument('name', $argument);
100
101			$this->assertInstanceOf(Collection::class, $this->fixture->getArguments());
102			$argumentsAsArray = iterator_to_array($this->fixture->getArguments());
103			$this->assertCount(1, $argumentsAsArray);
104			$this->assertSame($argument, $argumentsAsArray['name']);
105			$this->assertSame($argument->getMethod(), $this->fixture);
106			}
107
108			/**
109			* @covers ::isAbstract
110			* @covers ::setAbstract
111			*/
112			public function testSettingAndGettingWhetherMethodIsAbstract()
113			{
114			$this->assertFalse($this->fixture->isAbstract());
115
116			$this->fixture->setAbstract(true);
117
118			$this->assertTrue($this->fixture->isAbstract());
119			}
120
121			/**
122			* @covers ::isFinal
123			* @covers ::setFinal
124			*/
125			public function testSettingAndGettingWhetherMethodIsFinal()
126			{
127			$this->assertFalse($this->fixture->isFinal());
128
129			$this->fixture->setFinal(true);
130
131			$this->assertTrue($this->fixture->isFinal());
132			}
133
134			/**
135			* @covers ::isStatic
136			* @covers ::setStatic
137			*/
138			public function testSettingAndGettingWhetherMethodIsStatic()
139			{
140			$this->assertFalse($this->fixture->isStatic());
141
142			$this->fixture->setStatic(true);
143
144			$this->assertTrue($this->fixture->isStatic());
145			}
146
147			/**
148			* @covers ::getVisibility
149			* @covers ::setVisibility
150			*/
151			public function testSettingAndGettingVisibility()
152			{
153			$this->assertEquals('public', $this->fixture->getVisibility());
154
155			$this->fixture->setVisibility('private');
156
157			$this->assertEquals('private', $this->fixture->getVisibility());
158			}
159
160			/**
161			* @covers ::getResponse
162			*/
163			public function testRetrieveReturnTagForResponse()
164			{
165			$returnDescriptor = new ReturnDescriptor('return');
166			$returnDescriptor->setType(new String_());
167
168			$this->assertNull($this->fixture->getResponse()->getType());
169
170			$this->fixture->getTags()->set('return', new Collection([$returnDescriptor]));
171
172			$this->assertSame($returnDescriptor, $this->fixture->getResponse());
173			}
174
175			/**
176			* @covers ::setReturnType
177			* @covers ::getResponse
178			*/
179			public function testGetResponseReturnsReturnType()
180			{
181			$returnType = new String_();
182			$this->fixture->setReturnType($returnType);
183
184			$this->assertSame($returnType, $this->fixture->getResponse()->getType());
185			}
186
187			/**
188			* @covers ::getFile
189			*/
190			public function testRetrieveFileAssociatedWithAMethod()
191			{
192			// Arrange
193			$file = $this->whenFixtureIsRelatedToAClassWithFile();
194
195			// Act
196			$result = $this->fixture->getFile();
197
198			// Assert
199			$this->assertAttributeSame(null, 'fileDescriptor', $this->fixture);
200			$this->assertSame($file, $result);
201			}
202
203			/**
204			* @covers \phpDocumentor\Descriptor\DescriptorAbstract::getSummary
205			*/
206			public function testSummaryInheritsWhenNoneIsPresent()
207			{
208			// Arrange
209			$summary = 'This is a summary';
210			$this->fixture->setSummary(null);
211			$parentMethod = $this->whenFixtureHasMethodInParentClassWithSameName($this->fixture->getName());
212			$parentMethod->setSummary($summary);
213
214			// Act
215			$result = $this->fixture->getSummary();
216
217			// Assert
218			$this->assertSame($summary, $result);
219			}
220
221			/**
222			* @covers ::getSummary
223			*/
224			public function testSummaryInheritsFromImplementedInterfaceWhenNoneIsPresent()
225			{
226			// Arrange
227			$summary = 'This is a summary';
228			$this->fixture->setSummary(null);
229			$parentMethod = $this->whenFixtureHasMethodInImplementedInterfaceWithSameName($this->fixture->getName());
230			$parentMethod->setSummary($summary);
231
232			// Act
233			$result = $this->fixture->getSummary();
234
235			// Assert
236			$this->assertSame($summary, $result);
237			}
238
239			/**
240			* @covers ::getDescription
241			*/
242			public function testDescriptionInheritsWhenNoneIsPresent()
243			{
244			// Arrange
245			$description = 'This is a description';
246			$this->fixture->setDescription(null);
247			$parentMethod = $this->whenFixtureHasMethodInParentClassWithSameName($this->fixture->getName());
248			$parentMethod->setDescription($description);
249
250			// Act
251			$result = $this->fixture->getDescription();
252
253			// Assert
254			$this->assertSame($description, $result);
255			}
256
257			/**
258			* @covers \phpDocumentor\Descriptor\DescriptorAbstract::getDescription
259			*/
260			public function testDescriptionInheritsWhenInheritDocIsPresent()
261			{
262			// Arrange
263			$description = 'This is a description';
264			$this->fixture->setDescription('{@inheritDoc}');
265			$parentMethod = $this->whenFixtureHasMethodInParentClassWithSameName($this->fixture->getName());
266			$parentMethod->setDescription($description);
267
268			// Act
269			$result = $this->fixture->getDescription();
270
271			// Assert
272			$this->assertSame($description, $result);
273			}
274
275			/**
276			* @covers \phpDocumentor\Descriptor\DescriptorAbstract::getDescription
277			*/
278			public function testDescriptionIsAugmentedWhenInheritDocInlineTagIsPresent()
279			{
280			// Arrange
281			$description = 'This is a description';
282			$this->fixture->setDescription('Original description {@inheritDoc}');
283			$parentMethod = $this->whenFixtureHasMethodInParentClassWithSameName($this->fixture->getName());
284			$parentMethod->setDescription($description);
285
286			// Act
287			$result = $this->fixture->getDescription();
288
289			// Assert
290			$this->assertSame('Original description ' . $description, $result);
291			}
292
293			/**
294			* @covers ::getReturn
295			*/
296			public function testReturnTagsInheritWhenNoneArePresent()
297			{
298			$this->assertInstanceOf(Collection::class, $this->fixture->getReturn());
299			$this->assertSame(0, $this->fixture->getReturn()->count());
300
301			$returnTagDescriptor = new AuthorDescriptor('return');
302			$returnCollection = new Collection([$returnTagDescriptor]);
303			$this->fixture->getTags()->clear();
304			$parentProperty = $this->whenFixtureHasMethodInParentClassWithSameName($this->fixture->getName());
305			$parentProperty->getTags()->set('return', $returnCollection);
306
307			$result = $this->fixture->getReturn();
308
309			$this->assertSame($returnCollection, $result);
310			}
311
312			/**
313			* @covers ::getParam
314			*/
315			public function testParamTagsInheritWhenNoneArePresent()
316			{
317			$this->assertInstanceOf(Collection::class, $this->fixture->getParam());
318			$this->assertSame(0, $this->fixture->getParam()->count());
319
320			$paramTagDescriptor = new AuthorDescriptor('param');
321			$paramCollection = new Collection([$paramTagDescriptor]);
322			$this->fixture->getTags()->clear();
323			$parentProperty = $this->whenFixtureHasMethodInParentClassWithSameName($this->fixture->getName());
324			$parentProperty->getTags()->set('param', $paramCollection);
325
326			$result = $this->fixture->getParam();
327
328			$this->assertSame($paramCollection, $result);
329			}
330
331			/**
332			* @covers ::getAuthor
333			* @covers \phpDocumentor\Descriptor\DescriptorAbstract::getAuthor
334			*/
335			public function testAuthorTagsInheritWhenNoneArePresent()
336			{
337			// Arrange
338			$authorTagDescriptor = new AuthorDescriptor('author');
339			$authorCollection = new Collection([$authorTagDescriptor]);
340			$this->fixture->getTags()->clear();
341			$parentProperty = $this->whenFixtureHasMethodInParentClassWithSameName($this->fixture->getName());
342			$parentProperty->getTags()->set('author', $authorCollection);
343
344			// Act
345			$result = $this->fixture->getAuthor();
346
347			// Assert
348			$this->assertSame($authorCollection, $result);
349			}
350
351			/**
352			* @covers ::getVersion
353			* @covers \phpDocumentor\Descriptor\DescriptorAbstract::getVersion
354			*/
355			public function testVersionTagsInheritWhenNoneArePresent()
356			{
357			// Arrange
358			$versionTagDescriptor = new VersionDescriptor('version');
359			$versionCollection = new Collection([$versionTagDescriptor]);
360			$this->fixture->getTags()->clear();
361			$parentProperty = $this->whenFixtureHasMethodInParentClassWithSameName($this->fixture->getName());
362			$parentProperty->getTags()->set('version', $versionCollection);
363
364			// Act
365			$result = $this->fixture->getVersion();
366
367			// Assert
368			$this->assertSame($versionCollection, $result);
369			}
370
371			/**
372			* @covers ::getCopyright
373			* @covers \phpDocumentor\Descriptor\DescriptorAbstract::getCopyright
374			*/
375			public function testCopyrightTagsInheritWhenNoneArePresent()
376			{
377			// Arrange
378			$copyrightTagDescriptor = new TagDescriptor('copyright');
379			$copyrightCollection = new Collection([$copyrightTagDescriptor]);
380			$this->fixture->getTags()->clear();
381			$parentProperty = $this->whenFixtureHasMethodInParentClassWithSameName($this->fixture->getName());
382			$parentProperty->getTags()->set('copyright', $copyrightCollection);
383
384			// Act
385			$result = $this->fixture->getCopyright();
386
387			// Assert
388			$this->assertSame($copyrightCollection, $result);
389			}
390
391			/**
392			* Sets up mocks as such that the fixture has a file.
393			*
394			* @return m\MockInterface\|FileDescriptor
395			*/
396			protected function whenFixtureIsDirectlyRelatedToAFile()
397			{
398			$file = m::mock(FileDescriptor::class);
399			$this->fixture->setFile($file);
400			return $file;
401			}
402
403			/**
404			* Sets up mocks as such that the fixture has a parent class, with a file.
405			*
406			* @return m\MockInterface\|FileDescriptor
407			*/
408			protected function whenFixtureIsRelatedToAClassWithFile()
409			{
410			$file = m::mock(FileDescriptor::class);
411			$parent = m::mock(ClassDescriptor::class);
412			$parent->shouldReceive('getFile')->andReturn($file);
			0 ignored issues – show Bug introduced 2017-10-10 14:32 UTC by Report Bug Copy Issue Report The method `andReturn` does only exist in `Mockery\ExpectationInterface`, but not in `Mockery\HigherOrderMessage`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
413			$parent->shouldReceive('getFullyQualifiedStructuralElementName')->andReturn('Class1');
414			$this->fixture->setParent($parent);
415
416			return $file;
417			}
418
419			/**
420			* @param string $name The name of the current method.
421			*/
422			protected function whenFixtureHasMethodInParentClassWithSameName($name): MethodDescriptor
423			{
424			$result = new MethodDescriptor();
425			$result->setName($name);
426
427			$parent = new ClassDescriptor();
428			$parent->getMethods()->set($name, $result);
429
430			$class = new ClassDescriptor();
431			$class->setParent($parent);
432
433			$this->fixture->setParent($class);
434
435			return $result;
436			}
437
438			/**
439			* @param string $name The name of the current method.
440			*/
441			protected function whenFixtureHasMethodInImplementedInterfaceWithSameName($name): MethodDescriptor
442			{
443			$result = new MethodDescriptor();
444			$result->setName($name);
445
446			$parent = new InterfaceDescriptor();
447			$parent->getMethods()->set($name, $result);
448
449			$class = new ClassDescriptor();
450			$class->getInterfaces()->set('Implemented', $parent);
451
452			$this->fixture->setParent($class);
453
454			return $result;
455			}
456			}
457

phpDocumentor / phpDocumentor

Push — develop ( 48a3ec...fa4cb4 )

testSettingAndGettingAParent() A

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like