ContextFactoryTest::assertNamespaceAliasesFrom() - Code Metrics - Inspection of "Merge pull request #77 from piku235/issue76" - phpDocumentor/TypeResolver - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d2473e...004d6f )

by Jaap

created 2019-08-22 17:57 UTC

ContextFactoryTest::assertNamespaceAliasesFrom() A

↳ Parent: ContextFactoryTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	22
rs	9.568
c	0
b	0
f	0
cc	1
nc	1
nop	1

<?php declare(strict_types=1);
/**
 * This file is part of phpDocumentor.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @link      http://phpdoc.org
 */

namespace phpDocumentor\Reflection\Types {

// Added imports on purpose as mock for the unit tests, please do not remove.
    use Mockery as m, phpDocumentor;
    use phpDocumentor\Reflection\DocBlock;
    use phpDocumentor\Reflection\DocBlock\Tag;
    use PHPUnit\Framework\TestCase; // yes, the slash is part of the test
    use PHPUnit\Framework\{
        Assert,
        Exception as e
    };
    use \ReflectionClass;
    use stdClass;

    /**
     * @coversDefaultClass \phpDocumentor\Reflection\Types\ContextFactory
     * @covers ::<private>
     */
    class ContextFactoryTest extends TestCase
    {
        /**
         * @covers ::createFromReflector
         * @covers ::createForNamespace
         * @uses phpDocumentor\Reflection\Types\Context
         */
        public function testReadsNamespaceFromClassReflection() : void
        {
            $fixture = new ContextFactory();
            $context = $fixture->createFromReflector(new ReflectionClass($this));

            $this->assertSame(__NAMESPACE__, $context->getNamespace());
        }

        /**
         * @covers ::createFromReflector
         * @covers ::createForNamespace
         * @uses phpDocumentor\Reflection\Types\Context
         */
        public function testReadsAliasesFromClassReflection() : void
        {
            $fixture = new ContextFactory();
            $context = $fixture->createFromReflector(new ReflectionClass($this));

            $this->assertNamespaceAliasesFrom($context);
        }

        /**
         * @covers ::createForNamespace
         * @uses phpDocumentor\Reflection\Types\Context
         */
        public function testReadsNamespaceFromProvidedNamespaceAndContent() : void
        {
            $fixture = new ContextFactory();
            $context = $fixture->createForNamespace(__NAMESPACE__, file_get_contents(__FILE__));

            $this->assertSame(__NAMESPACE__, $context->getNamespace());
        }

        /**
         * @covers ::createForNamespace
         * @uses phpDocumentor\Reflection\Types\Context
         */
        public function testReadsAliasesFromProvidedNamespaceAndContent() : void
        {
            $fixture = new ContextFactory();
            $context = $fixture->createForNamespace(__NAMESPACE__, file_get_contents(__FILE__));

            $this->assertNamespaceAliasesFrom($context);
        }

        /**
         * @covers ::createForNamespace
         * @uses phpDocumentor\Reflection\Types\Context
         */
        public function testTraitUseIsNotDetectedAsNamespaceUse() : void
        {
            $php = '<?php declare(strict_types=1);
                namespace Foo;

                trait FooTrait {}

                class FooClass {
                    use FooTrait;
                }
            ';

            $fixture = new ContextFactory();
            $context = $fixture->createForNamespace('Foo', $php);

            $this->assertSame([], $context->getNamespaceAliases());
        }

        /**
         * @covers ::createForNamespace
         * @uses phpDocumentor\Reflection\Types\Context
         */
        public function testAllOpeningBracesAreCheckedWhenSearchingForEndOfClass() : void
        {
            $php = '<?php declare(strict_types=1);
                namespace Foo;

                trait FooTrait {}
                trait BarTrait {}

                class FooClass {
                    use FooTrait;

                    public function bar()
                    {
                        echo "{$baz}";
                        echo "${baz}";
                    }
                }

                class BarClass {
                    use BarTrait;

                    public function bar()
                    {
                        echo "{$baz}";
                        echo "${baz}";
                    }
                }
            ';

            $fixture = new ContextFactory();
            $context = $fixture->createForNamespace('Foo', $php);

            $this->assertSame([], $context->getNamespaceAliases());
        }

        /**
         * @covers ::createFromReflector
         */
        public function testEmptyFileName() : void
        {
            $fixture = new ContextFactory();
            $context = $fixture->createFromReflector(new ReflectionClass(stdClass::class));

            $this->assertSame([], $context->getNamespaceAliases());
        }

        /**
         * @covers ::createFromReflector
         */
        public function testEvalDClass() : void
        {
            eval(<<<PHP
namespace Foo;

class Bar
{
}
PHP
);
            $fixture = new ContextFactory();
            $context = $fixture->createFromReflector(new ReflectionClass('Foo\Bar'));

            $this->assertSame([], $context->getNamespaceAliases());
        }

        public function assertNamespaceAliasesFrom(Context $context)
        {
            $expected = [
                'm' => m::class,
                'DocBlock' => DocBlock::class,
                'Tag' => Tag::class,
                'phpDocumentor' => 'phpDocumentor',
                'TestCase' => TestCase::class,
                'Assert' => Assert::class,
                'e' => e::class,
                ReflectionClass::class => ReflectionClass::class,
                'stdClass' => 'stdClass',
            ];

            $actual = $context->getNamespaceAliases();

            // sort so that order differences don't break it
            asort($expected);
            asort($actual);

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

        public function tearDown()
        {
            m::close();
        }
    }
}

namespace phpDocumentor\Reflection\Types\Mock {

    // the following import should not show in the tests above
    use phpDocumentor\Reflection\DocBlock\Description;

    class Foo extends Description
    {
        // dummy class
    }
}


1			<?php declare(strict_types=1);
2			/**
3			* This file is part of phpDocumentor.
4			*
5			* For the full copyright and license information, please view the LICENSE
6			* file that was distributed with this source code.
7			*
8			* @link http://phpdoc.org
9			*/
10
11			namespace phpDocumentor\Reflection\Types {
12
13			// Added imports on purpose as mock for the unit tests, please do not remove.
14			use Mockery as m, phpDocumentor;
15			use phpDocumentor\Reflection\DocBlock;
16			use phpDocumentor\Reflection\DocBlock\Tag;
17			use PHPUnit\Framework\TestCase; // yes, the slash is part of the test
18			use PHPUnit\Framework\{
19			Assert,
20			Exception as e
21			};
22			use \ReflectionClass;
23			use stdClass;
24
25			/**
26			* @coversDefaultClass \phpDocumentor\Reflection\Types\ContextFactory
27			* @covers ::<private>
28			*/
29			class ContextFactoryTest extends TestCase
30			{
31			/**
32			* @covers ::createFromReflector
33			* @covers ::createForNamespace
34			* @uses phpDocumentor\Reflection\Types\Context
35			*/
36			public function testReadsNamespaceFromClassReflection() : void
37			{
38			$fixture = new ContextFactory();
39			$context = $fixture->createFromReflector(new ReflectionClass($this));
40
41			$this->assertSame(__NAMESPACE__, $context->getNamespace());
42			}
43
44			/**
45			* @covers ::createFromReflector
46			* @covers ::createForNamespace
47			* @uses phpDocumentor\Reflection\Types\Context
48			*/
49			public function testReadsAliasesFromClassReflection() : void
50			{
51			$fixture = new ContextFactory();
52			$context = $fixture->createFromReflector(new ReflectionClass($this));
53
54			$this->assertNamespaceAliasesFrom($context);
55			}
56
57			/**
58			* @covers ::createForNamespace
59			* @uses phpDocumentor\Reflection\Types\Context
60			*/
61			public function testReadsNamespaceFromProvidedNamespaceAndContent() : void
62			{
63			$fixture = new ContextFactory();
64			$context = $fixture->createForNamespace(__NAMESPACE__, file_get_contents(__FILE__));
65
66			$this->assertSame(__NAMESPACE__, $context->getNamespace());
67			}
68
69			/**
70			* @covers ::createForNamespace
71			* @uses phpDocumentor\Reflection\Types\Context
72			*/
73			public function testReadsAliasesFromProvidedNamespaceAndContent() : void
74			{
75			$fixture = new ContextFactory();
76			$context = $fixture->createForNamespace(__NAMESPACE__, file_get_contents(__FILE__));
77
78			$this->assertNamespaceAliasesFrom($context);
79			}
80
81			/**
82			* @covers ::createForNamespace
83			* @uses phpDocumentor\Reflection\Types\Context
84			*/
85			public function testTraitUseIsNotDetectedAsNamespaceUse() : void
86			{
87			$php = '<?php declare(strict_types=1);
88			namespace Foo;
89
90			trait FooTrait {}
91
92			class FooClass {
93			use FooTrait;
94			}
95			';
96
97			$fixture = new ContextFactory();
98			$context = $fixture->createForNamespace('Foo', $php);
99
100			$this->assertSame([], $context->getNamespaceAliases());
101			}
102
103			/**
104			* @covers ::createForNamespace
105			* @uses phpDocumentor\Reflection\Types\Context
106			*/
107			public function testAllOpeningBracesAreCheckedWhenSearchingForEndOfClass() : void
108			{
109			$php = '<?php declare(strict_types=1);
110			namespace Foo;
111
112			trait FooTrait {}
113			trait BarTrait {}
114
115			class FooClass {
116			use FooTrait;
117
118			public function bar()
119			{
120			echo "{$baz}";
121			echo "${baz}";
122			}
123			}
124
125			class BarClass {
126			use BarTrait;
127
128			public function bar()
129			{
130			echo "{$baz}";
131			echo "${baz}";
132			}
133			}
134			';
135
136			$fixture = new ContextFactory();
137			$context = $fixture->createForNamespace('Foo', $php);
138
139			$this->assertSame([], $context->getNamespaceAliases());
140			}
141
142			/**
143			* @covers ::createFromReflector
144			*/
145			public function testEmptyFileName() : void
146			{
147			$fixture = new ContextFactory();
148			$context = $fixture->createFromReflector(new ReflectionClass(stdClass::class));
149
150			$this->assertSame([], $context->getNamespaceAliases());
151			}
152
153			/**
154			* @covers ::createFromReflector
155			*/
156			public function testEvalDClass() : void
157			{
158			eval(<<<PHP
159			namespace Foo;
160
161			class Bar
162			{
163			}
164			PHP
165			);
166			$fixture = new ContextFactory();
167			$context = $fixture->createFromReflector(new ReflectionClass('Foo\Bar'));
168
169			$this->assertSame([], $context->getNamespaceAliases());
170			}
171
172			public function assertNamespaceAliasesFrom(Context $context)
173			{
174			$expected = [
175			'm' => m::class,
176			'DocBlock' => DocBlock::class,
177			'Tag' => Tag::class,
178			'phpDocumentor' => 'phpDocumentor',
179			'TestCase' => TestCase::class,
180			'Assert' => Assert::class,
181			'e' => e::class,
182			ReflectionClass::class => ReflectionClass::class,
183			'stdClass' => 'stdClass',
184			];
185
186			$actual = $context->getNamespaceAliases();
187
188			// sort so that order differences don't break it
189			asort($expected);
190			asort($actual);
191
192			$this->assertSame($expected, $actual);
193			}
194
195			public function tearDown()
196			{
197			m::close();
198			}
199			}
200			}
201
202			namespace phpDocumentor\Reflection\Types\Mock {
203
204			// the following import should not show in the tests above
205			use phpDocumentor\Reflection\DocBlock\Description;
206
207			class Foo extends Description
208			{
209			// dummy class
210			}
211			}
212

phpDocumentor / TypeResolver

Push — master ( d2473e...004d6f )

ContextFactoryTest::assertNamespaceAliasesFrom() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like