Issues in ConstantDescriptorTest.php - All Issues - Inspection of "Delete Scrybe" - phpDocumentor/phpDocumentor - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 8eb671...133594 )

by Mike

created 2019-06-14 08:00 UTC

Descriptor/ConstantDescriptorTest.php (1 issue)

Labels

Severity

Minor 1

Mike van Riel 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\VarDescriptor;
use phpDocumentor\Descriptor\Tag\VersionDescriptor;
use phpDocumentor\Reflection\Type;
use phpDocumentor\Reflection\Types\Array_;
use phpDocumentor\Reflection\Types\String_;

/**
 * Tests the functionality for the ConstantDescriptor class.
 */
class ConstantDescriptorTest extends \Mockery\Adapter\Phpunit\MockeryTestCase
{
    /** @var ConstantDescriptor $fixture */
    protected $fixture;

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

    /**
     * @covers \phpDocumentor\Descriptor\ConstantDescriptor::getParent
     * @covers \phpDocumentor\Descriptor\ConstantDescriptor::setParent
     */
    public function testSetAndGetParentClass()
    {
        $this->assertNull($this->fixture->getParent());

        $parentMock = m::mock('phpDocumentor\Descriptor\ClassDescriptor');
        $parentMock->shouldReceive('getFullyQualifiedStructuralElementName')->andReturn('TestClass');

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

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

    /**
     * @covers \phpDocumentor\Descriptor\ConstantDescriptor::setParent
     * @expectedException \InvalidArgumentException
     */
    public function testSettingAParentFailsWhenInputIsNotNullClassOrInterface()
    {
        $this->fixture->setParent('string');
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * @covers \phpDocumentor\Descriptor\ConstantDescriptor::getParent
     * @covers \phpDocumentor\Descriptor\ConstantDescriptor::setParent
     */
    public function testSetAndGetParentInterface()
    {
        $this->assertNull($this->fixture->getParent());

        $parentMock = m::mock('phpDocumentor\Descriptor\InterfaceDescriptor');
        $parentMock->shouldReceive('getFullyQualifiedStructuralElementName')->andReturn('TestInterface');
        $this->fixture->setParent($parentMock);

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

    /**
     * @covers \phpDocumentor\Descriptor\ConstantDescriptor::getTypes
     * @covers \phpDocumentor\Descriptor\ConstantDescriptor::setTypes
     */
    public function testSetAndGetTypes()
    {
        $this->assertEquals(null, $this->fixture->getType());
        $expected = new Array_();

        $this->fixture->setTypes($expected);

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

    /**
     * @covers \phpDocumentor\Descriptor\ConstantDescriptor::getTypes
     * @covers \phpDocumentor\Descriptor\ConstantDescriptor::getVar
     */
    public function testTestgetTypesDerivedFromVarTag()
    {
        $expected = new String_();

        $varTag = new VarDescriptor('var');
        $varTag->setType($expected);

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

        $this->assertEquals($expected, $this->fixture->getType());
    }

    /**
     * @covers \phpDocumentor\Descriptor\ConstantDescriptor::getTypes
     * @covers \phpDocumentor\Descriptor\ConstantDescriptor::getVar
     */
    public function testGetTypesUsingInheritanceOfVarTag()
    {
        $expected = new String_();

        $constantName = 'CONSTANT';
        $this->fixture->setName($constantName);
        $parentClass = $this->createParentClassWithSuperClassAndConstant($expected, $constantName);

        // Attempt to get the types; which come from the superclass' constants
        $this->fixture->setParent($parentClass);
        $types = $this->fixture->getType();

        $this->assertSame($expected, $types);
    }

    /**
     * @covers \phpDocumentor\Descriptor\ConstantDescriptor::getValue
     * @covers \phpDocumentor\Descriptor\ConstantDescriptor::setValue
     */
    public function testSetAndGetValue()
    {
        $this->assertNull($this->fixture->getValue());

        $this->fixture->setValue('a');

        $this->assertSame('a', $this->fixture->getValue());
    }

    /**
     * @covers \phpDocumentor\Descriptor\ConstantDescriptor::getFile
     */
    public function testRetrieveFileAssociatedWithAGlobalConstant()
    {
        // Arrange
        $file = $this->whenFixtureIsDirectlyRelatedToAFile();

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

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

    /**
     * @covers \phpDocumentor\Descriptor\ConstantDescriptor::getFile
     */
    public function testRetrieveFileAssociatedWithAClassConstant()
    {
        // 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);
        $parentConstant = $this->whenFixtureHasConstantInParentClassWithSameName($this->fixture->getName());
        $parentConstant->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);
        $parentConstant = $this->whenFixtureHasConstantInParentClassWithSameName($this->fixture->getName());
        $parentConstant->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}');
        $parentConstant = $this->whenFixtureHasConstantInParentClassWithSameName($this->fixture->getName());
        $parentConstant->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}');
        $parentConstant = $this->whenFixtureHasConstantInParentClassWithSameName($this->fixture->getName());
        $parentConstant->setDescription($description);

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

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

    /**
     * @covers \phpDocumentor\Descriptor\ConstantDescriptor::getVar
     */
    public function testVarTagsInheritWhenNoneArePresent()
    {
        // Arrange
        $varTagDescriptor = new VarDescriptor('var');
        $varCollection = new Collection([$varTagDescriptor]);
        $this->fixture->getTags()->clear();
        $parentProperty = $this->whenFixtureHasConstantInParentClassWithSameName($this->fixture->getName());
        $parentProperty->getTags()->set('var', $varCollection);

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

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

    /**
     * @covers \phpDocumentor\Descriptor\DescriptorAbstract::getPackage
     */
    public function testPackageInheritWhenNoneArePresent()
    {
        // Arrange
        $packageTagDescriptor = new PackageDescriptor();
        $this->fixture->setPackage('');
        $parentProperty = $this->whenFixtureHasConstantInParentClassWithSameName($this->fixture->getName());
        $parentProperty->setPackage($packageTagDescriptor);

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

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

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

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

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

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

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

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

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

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

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

    /**
     * Creates a parentClass for a Constant with a SuperClass, which in turn has a constant exposing the given types.
     *
     * The created ParentClass can be used to test the inheritance of properties of a constant descriptor, such as
     * inheriting type information.
     *
     * @param Type $type
     * @param string $constantName
     *
     * @return m\MockInterface|ClassDescriptor
     */
    protected function createParentClassWithSuperClassAndConstant(Type $type, $constantName)
    {
        // construct the to-be-inherited constant and its @var tag
        $varTag = m::mock('phpDocumentor\Descriptor\Tag\VarDescriptor');
        $varTag->shouldReceive('getType')->andReturn($type);

        $parentConstant = m::mock('\phpDocumentor\Descriptor\ConstantDescriptor');
        $parentConstant->shouldReceive('getVar')->andReturn(new Collection([$varTag]));

        // create SuperClassMock and add a Constant collection with out to-be-inherited constant
        $superClass = m::mock('phpDocumentor\Descriptor\ClassDescriptor');
        $superClass->shouldReceive('getConstants')->andReturn(
            new Collection(
                [$constantName => $parentConstant]
            )
        );

        // create and set the parent class for our fixture
        $parentClass = m::mock('phpDocumentor\Descriptor\ClassDescriptor');
        $parentClass->shouldReceive('getFullyQualifiedStructuralElementName')->andReturn('TestClass');
        $parentClass->shouldReceive('getParent')->andReturn($superClass);

        return $parentClass;
    }

    /**
     * Sets up mocks as such that the fixture has a file.
     *
     * @return m\MockInterface|FileDescriptor
     */
    protected function whenFixtureIsDirectlyRelatedToAFile()
    {
        $file = m::mock('phpDocumentor\Descriptor\FileDescriptor');
        $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('phpDocumentor\Descriptor\FileDescriptor');
        $parent = m::mock('phpDocumentor\Descriptor\ClassDescriptor');
        $parent->shouldReceive('getFile')->andReturn($file);
        $parent->shouldReceive('getFullyQualifiedStructuralElementName')->andReturn('Class1');
        $this->fixture->setParent($parent);

        return $file;
    }

    /**
     * @param string $name The name of the current constant.
     *
     * @return ConstantDescriptor
     */
    protected function whenFixtureHasConstantInParentClassWithSameName($name)
    {
        $result = new ConstantDescriptor();
        $result->setName($name);

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

        $class = new ClassDescriptor();
        $class->setParent($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\VarDescriptor;
17			use phpDocumentor\Descriptor\Tag\VersionDescriptor;
18			use phpDocumentor\Reflection\Type;
19			use phpDocumentor\Reflection\Types\Array_;
20			use phpDocumentor\Reflection\Types\String_;
21
22			/**
23			* Tests the functionality for the ConstantDescriptor class.
24			*/
25			class ConstantDescriptorTest extends \Mockery\Adapter\Phpunit\MockeryTestCase
26			{
27			/** @var ConstantDescriptor $fixture */
28			protected $fixture;
29
30			/**
31			* Creates a new (empty) fixture object.
32			*/
33			protected function setUp()
34			{
35			$this->fixture = new ConstantDescriptor();
36			$this->fixture->setName('CONSTANT');
37			}
38
39			/**
40			* @covers \phpDocumentor\Descriptor\ConstantDescriptor::getParent
41			* @covers \phpDocumentor\Descriptor\ConstantDescriptor::setParent
42			*/
43			public function testSetAndGetParentClass()
44			{
45			$this->assertNull($this->fixture->getParent());
46
47			$parentMock = m::mock('phpDocumentor\Descriptor\ClassDescriptor');
48			$parentMock->shouldReceive('getFullyQualifiedStructuralElementName')->andReturn('TestClass');
49
50			$this->fixture->setParent($parentMock);
51
52			$this->assertSame($parentMock, $this->fixture->getParent());
53			}
54
55			/**
56			* @covers \phpDocumentor\Descriptor\ConstantDescriptor::setParent
57			* @expectedException \InvalidArgumentException
58			*/
59			public function testSettingAParentFailsWhenInputIsNotNullClassOrInterface()
60			{
61			$this->fixture->setParent('string');
			0 ignored issues – show Documentation introduced 2015-12-02 21:15 UTC by Report Bug Copy Issue Report Show Similar Issues like this `'string'` is of type `string`, but the function expects a `object<phpDocumentor\Des...terfaceDescriptor>\|null`. 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...
62			}
63
64			/**
65			* @covers \phpDocumentor\Descriptor\ConstantDescriptor::getParent
66			* @covers \phpDocumentor\Descriptor\ConstantDescriptor::setParent
67			*/
68			public function testSetAndGetParentInterface()
69			{
70			$this->assertNull($this->fixture->getParent());
71
72			$parentMock = m::mock('phpDocumentor\Descriptor\InterfaceDescriptor');
73			$parentMock->shouldReceive('getFullyQualifiedStructuralElementName')->andReturn('TestInterface');
74			$this->fixture->setParent($parentMock);
75
76			$this->assertSame($parentMock, $this->fixture->getParent());
77			}
78
79			/**
80			* @covers \phpDocumentor\Descriptor\ConstantDescriptor::getTypes
81			* @covers \phpDocumentor\Descriptor\ConstantDescriptor::setTypes
82			*/
83			public function testSetAndGetTypes()
84			{
85			$this->assertEquals(null, $this->fixture->getType());
86			$expected = new Array_();
87
88			$this->fixture->setTypes($expected);
89
90			$this->assertSame($expected, $this->fixture->getType());
91			}
92
93			/**
94			* @covers \phpDocumentor\Descriptor\ConstantDescriptor::getTypes
95			* @covers \phpDocumentor\Descriptor\ConstantDescriptor::getVar
96			*/
97			public function testTestgetTypesDerivedFromVarTag()
98			{
99			$expected = new String_();
100
101			$varTag = new VarDescriptor('var');
102			$varTag->setType($expected);
103
104			$this->fixture->getTags()->set('var', new Collection([$varTag]));
105
106			$this->assertEquals($expected, $this->fixture->getType());
107			}
108
109			/**
110			* @covers \phpDocumentor\Descriptor\ConstantDescriptor::getTypes
111			* @covers \phpDocumentor\Descriptor\ConstantDescriptor::getVar
112			*/
113			public function testGetTypesUsingInheritanceOfVarTag()
114			{
115			$expected = new String_();
116
117			$constantName = 'CONSTANT';
118			$this->fixture->setName($constantName);
119			$parentClass = $this->createParentClassWithSuperClassAndConstant($expected, $constantName);
120
121			// Attempt to get the types; which come from the superclass' constants
122			$this->fixture->setParent($parentClass);
123			$types = $this->fixture->getType();
124
125			$this->assertSame($expected, $types);
126			}
127
128			/**
129			* @covers \phpDocumentor\Descriptor\ConstantDescriptor::getValue
130			* @covers \phpDocumentor\Descriptor\ConstantDescriptor::setValue
131			*/
132			public function testSetAndGetValue()
133			{
134			$this->assertNull($this->fixture->getValue());
135
136			$this->fixture->setValue('a');
137
138			$this->assertSame('a', $this->fixture->getValue());
139			}
140
141			/**
142			* @covers \phpDocumentor\Descriptor\ConstantDescriptor::getFile
143			*/
144			public function testRetrieveFileAssociatedWithAGlobalConstant()
145			{
146			// Arrange
147			$file = $this->whenFixtureIsDirectlyRelatedToAFile();
148
149			// Act
150			$result = $this->fixture->getFile();
151
152			// Assert
153			$this->assertSame($file, $result);
154			}
155
156			/**
157			* @covers \phpDocumentor\Descriptor\ConstantDescriptor::getFile
158			*/
159			public function testRetrieveFileAssociatedWithAClassConstant()
160			{
161			// Arrange
162			$file = $this->whenFixtureIsRelatedToAClassWithFile();
163
164			// Act
165			$result = $this->fixture->getFile();
166
167			// Assert
168			$this->assertAttributeSame(null, 'fileDescriptor', $this->fixture);
169			$this->assertSame($file, $result);
170			}
171
172			/**
173			* @covers \phpDocumentor\Descriptor\DescriptorAbstract::getSummary
174			*/
175			public function testSummaryInheritsWhenNoneIsPresent()
176			{
177			// Arrange
178			$summary = 'This is a summary';
179			$this->fixture->setSummary(null);
180			$parentConstant = $this->whenFixtureHasConstantInParentClassWithSameName($this->fixture->getName());
181			$parentConstant->setSummary($summary);
182
183			// Act
184			$result = $this->fixture->getSummary();
185
186			// Assert
187			$this->assertSame($summary, $result);
188			}
189
190			/**
191			* @covers \phpDocumentor\Descriptor\DescriptorAbstract::getDescription
192			*/
193			public function testDescriptionInheritsWhenNoneIsPresent()
194			{
195			// Arrange
196			$description = 'This is a description';
197			$this->fixture->setDescription(null);
198			$parentConstant = $this->whenFixtureHasConstantInParentClassWithSameName($this->fixture->getName());
199			$parentConstant->setDescription($description);
200
201			// Act
202			$result = $this->fixture->getDescription();
203
204			// Assert
205			$this->assertSame($description, $result);
206			}
207
208			/**
209			* @covers \phpDocumentor\Descriptor\DescriptorAbstract::getDescription
210			*/
211			public function testDescriptionInheritsWhenInheritDocIsPresent()
212			{
213			// Arrange
214			$description = 'This is a description';
215			$this->fixture->setDescription('{@inheritDoc}');
216			$parentConstant = $this->whenFixtureHasConstantInParentClassWithSameName($this->fixture->getName());
217			$parentConstant->setDescription($description);
218
219			// Act
220			$result = $this->fixture->getDescription();
221
222			// Assert
223			$this->assertSame($description, $result);
224			}
225
226			/**
227			* @covers \phpDocumentor\Descriptor\DescriptorAbstract::getDescription
228			*/
229			public function testDescriptionIsAugmentedWhenInheritDocInlineTagIsPresent()
230			{
231			// Arrange
232			$description = 'This is a description';
233			$this->fixture->setDescription('Original description {@inheritDoc}');
234			$parentConstant = $this->whenFixtureHasConstantInParentClassWithSameName($this->fixture->getName());
235			$parentConstant->setDescription($description);
236
237			// Act
238			$result = $this->fixture->getDescription();
239
240			// Assert
241			$this->assertSame('Original description ' . $description, $result);
242			}
243
244			/**
245			* @covers \phpDocumentor\Descriptor\ConstantDescriptor::getVar
246			*/
247			public function testVarTagsInheritWhenNoneArePresent()
248			{
249			// Arrange
250			$varTagDescriptor = new VarDescriptor('var');
251			$varCollection = new Collection([$varTagDescriptor]);
252			$this->fixture->getTags()->clear();
253			$parentProperty = $this->whenFixtureHasConstantInParentClassWithSameName($this->fixture->getName());
254			$parentProperty->getTags()->set('var', $varCollection);
255
256			// Act
257			$result = $this->fixture->getVar();
258
259			// Assert
260			$this->assertSame($varCollection, $result);
261			}
262
263			/**
264			* @covers \phpDocumentor\Descriptor\DescriptorAbstract::getPackage
265			*/
266			public function testPackageInheritWhenNoneArePresent()
267			{
268			// Arrange
269			$packageTagDescriptor = new PackageDescriptor();
270			$this->fixture->setPackage('');
271			$parentProperty = $this->whenFixtureHasConstantInParentClassWithSameName($this->fixture->getName());
272			$parentProperty->setPackage($packageTagDescriptor);
273
274			// Act
275			$result = $this->fixture->getPackage();
276
277			// Assert
278			$this->assertSame($packageTagDescriptor, $result);
279			}
280
281			/**
282			* @covers \phpDocumentor\Descriptor\DescriptorAbstract::getAuthor
283			*/
284			public function testAuthorTagsInheritWhenNoneArePresent()
285			{
286			// Arrange
287			$authorTagDescriptor = new AuthorDescriptor('author');
288			$authorCollection = new Collection([$authorTagDescriptor]);
289			$this->fixture->getTags()->clear();
290			$parentProperty = $this->whenFixtureHasConstantInParentClassWithSameName($this->fixture->getName());
291			$parentProperty->getTags()->set('author', $authorCollection);
292
293			// Act
294			$result = $this->fixture->getAuthor();
295
296			// Assert
297			$this->assertSame($authorCollection, $result);
298			}
299
300			/**
301			* @covers \phpDocumentor\Descriptor\DescriptorAbstract::getVersion
302			*/
303			public function testVersionTagsInheritWhenNoneArePresent()
304			{
305			// Arrange
306			$versionTagDescriptor = new VersionDescriptor('version');
307			$versionCollection = new Collection([$versionTagDescriptor]);
308			$this->fixture->getTags()->clear();
309			$parentProperty = $this->whenFixtureHasConstantInParentClassWithSameName($this->fixture->getName());
310			$parentProperty->getTags()->set('version', $versionCollection);
311
312			// Act
313			$result = $this->fixture->getVersion();
314
315			// Assert
316			$this->assertSame($versionCollection, $result);
317			}
318
319			/**
320			* @covers \phpDocumentor\Descriptor\DescriptorAbstract::getCopyright
321			*/
322			public function testCopyrightTagsInheritWhenNoneArePresent()
323			{
324			// Arrange
325			$copyrightTagDescriptor = new TagDescriptor('copyright');
326			$copyrightCollection = new Collection([$copyrightTagDescriptor]);
327			$this->fixture->getTags()->clear();
328			$parentProperty = $this->whenFixtureHasConstantInParentClassWithSameName($this->fixture->getName());
329			$parentProperty->getTags()->set('copyright', $copyrightCollection);
330
331			// Act
332			$result = $this->fixture->getCopyright();
333
334			// Assert
335			$this->assertSame($copyrightCollection, $result);
336			}
337
338			/**
339			* Creates a parentClass for a Constant with a SuperClass, which in turn has a constant exposing the given types.
340			*
341			* The created ParentClass can be used to test the inheritance of properties of a constant descriptor, such as
342			* inheriting type information.
343			*
344			* @param Type $type
345			* @param string $constantName
346			*
347			* @return m\MockInterface\|ClassDescriptor
348			*/
349			protected function createParentClassWithSuperClassAndConstant(Type $type, $constantName)
350			{
351			// construct the to-be-inherited constant and its @var tag
352			$varTag = m::mock('phpDocumentor\Descriptor\Tag\VarDescriptor');
353			$varTag->shouldReceive('getType')->andReturn($type);
354
355			$parentConstant = m::mock('\phpDocumentor\Descriptor\ConstantDescriptor');
356			$parentConstant->shouldReceive('getVar')->andReturn(new Collection([$varTag]));
357
358			// create SuperClassMock and add a Constant collection with out to-be-inherited constant
359			$superClass = m::mock('phpDocumentor\Descriptor\ClassDescriptor');
360			$superClass->shouldReceive('getConstants')->andReturn(
361			new Collection(
362			[$constantName => $parentConstant]
363			)
364			);
365
366			// create and set the parent class for our fixture
367			$parentClass = m::mock('phpDocumentor\Descriptor\ClassDescriptor');
368			$parentClass->shouldReceive('getFullyQualifiedStructuralElementName')->andReturn('TestClass');
369			$parentClass->shouldReceive('getParent')->andReturn($superClass);
370
371			return $parentClass;
372			}
373
374			/**
375			* Sets up mocks as such that the fixture has a file.
376			*
377			* @return m\MockInterface\|FileDescriptor
378			*/
379			protected function whenFixtureIsDirectlyRelatedToAFile()
380			{
381			$file = m::mock('phpDocumentor\Descriptor\FileDescriptor');
382			$this->fixture->setFile($file);
383			return $file;
384			}
385
386			/**
387			* Sets up mocks as such that the fixture has a parent class, with a file.
388			*
389			* @return m\MockInterface\|FileDescriptor
390			*/
391			protected function whenFixtureIsRelatedToAClassWithFile()
392			{
393			$file = m::mock('phpDocumentor\Descriptor\FileDescriptor');
394			$parent = m::mock('phpDocumentor\Descriptor\ClassDescriptor');
395			$parent->shouldReceive('getFile')->andReturn($file);
396			$parent->shouldReceive('getFullyQualifiedStructuralElementName')->andReturn('Class1');
397			$this->fixture->setParent($parent);
398
399			return $file;
400			}
401
402			/**
403			* @param string $name The name of the current constant.
404			*
405			* @return ConstantDescriptor
406			*/
407			protected function whenFixtureHasConstantInParentClassWithSameName($name)
408			{
409			$result = new ConstantDescriptor();
410			$result->setName($name);
411
412			$parent = new ClassDescriptor();
413			$parent->getConstants()->set($name, $result);
414
415			$class = new ClassDescriptor();
416			$class->setParent($parent);
417
418			$this->fixture->setParent($class);
419
420			return $result;
421			}
422			}
423

phpDocumentor / phpDocumentor

Push — develop ( 8eb671...133594 )

Descriptor/ConstantDescriptorTest.php (1 issue)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like