UsedSymbolCollectorTest - Code Metrics - maglnet/ComposerRequireChecker - Measure and Improve Code Quality continuously with Scrutinizer

UsedSymbolCollectorTest A
last analyzed 2020-10-01 20:50 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	289
Duplicated Lines	0 %

Importance

Changes	5
Bugs	1	Features	1

Metric	Value
wmc	22
eloc	157
c	5
b	1
f	1
dl	0
loc	289
rs	10

22 Methods

Rating	Name	Size	Complexity
A	testStaticPropertyFetch()	11	1
A	testExtendingInterface()	11	1
A	testMethodParameterTypeAsString()	14	1
A	testFunctionParameterTypeAsString()	14	1
A	testCatch()	10	1
A	testClassConstantFetch()	11	1
A	testImplements()	11	1
A	testFunctionParameterType()	14	1
A	testExtendingClass()	10	1
A	testFunctionReturnType()	11	1
A	testInstanceof()	11	1
A	testNew()	11	1
A	testMethodParameterType()	14	1
A	testFunctionCallUsage()	11	1
A	testStaticCall()	11	1
A	setUp()	5	1
A	testBeforeTraverseResetsRecordedSymbols()	9	1
A	testTraits()	9	1
A	testTraitUseVisibilityAdaptation()	10	1
A	testConstantFetch()	11	1
A	testTraitUsePrecedenceAdaptation()	12	1
A	testMethodReturnType()	11	1

<?php

namespace ComposerRequireCheckerTest\NodeVisitor;

use ComposerRequireChecker\NodeVisitor\UsedSymbolCollector;
use PhpParser\Node\Expr\ClassConstFetch;
use PhpParser\Node\Expr\ConstFetch;
use PhpParser\Node\Expr\FuncCall;
use PhpParser\Node\Expr\Instanceof_;
use PhpParser\Node\Expr\New_;
use PhpParser\Node\Expr\StaticCall;
use PhpParser\Node\Expr\StaticPropertyFetch;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Name;
use PhpParser\Node\Param;
use PhpParser\Node\Stmt\Catch_;
use PhpParser\Node\Stmt\Class_;
use PhpParser\Node\Stmt\ClassMethod;
use PhpParser\Node\Stmt\Function_;
use PhpParser\Node\Stmt\Interface_;
use PhpParser\Node\Stmt\TraitUse;
use PhpParser\Node\Stmt\TraitUseAdaptation\Alias;
use PhpParser\Node\Stmt\TraitUseAdaptation\Precedence;
use PHPUnit\Framework\TestCase;

/**
 * @covers \ComposerRequireChecker\NodeVisitor\UsedSymbolCollector
 */
final class UsedSymbolCollectorTest extends TestCase
{
    /** @var UsedSymbolCollector */
    private $visitor;

    protected function setUp(): void
    {
        parent::setUp();

        $this->visitor = new UsedSymbolCollector();
    }

    public function testExtendingClass(): void
    {
        $node = new Class_('Foo');
        $node->extends = new Name('Bar');

        $this->visitor->enterNode($node);

        $symbols = $this->visitor->getCollectedSymbols();
        $this->assertCount(1, $symbols);
        $this->assertContains('Bar', $symbols);
    }

    public function testExtendingInterface(): void
    {
        $node = new Interface_('Foo');
        $node->extends = [new Name('Bar'), new Name('Baz')];

        $this->visitor->enterNode($node);

        $symbols = $this->visitor->getCollectedSymbols();
        $this->assertCount(2, $symbols);
        $this->assertContains('Bar', $symbols);
        $this->assertContains('Baz', $symbols);
    }

    public function testImplements(): void
    {
        $node = new Class_('Foo');
        $node->implements = [new Name('Bar'), new Name('Baz')];

        $this->visitor->enterNode($node);

        $symbols = $this->visitor->getCollectedSymbols();
        $this->assertCount(2, $symbols);
        $this->assertContains('Bar', $symbols);
        $this->assertContains('Baz', $symbols);
    }

    public function testStaticCall(): void
    {
        $class = new Name('Foo');
        $node = new StaticCall($class, 'foo');
        $node->class = $class;

        $this->visitor->enterNode($node);

        $symbols = $this->visitor->getCollectedSymbols();
        $this->assertCount(1, $symbols);
        $this->assertContains('Foo', $symbols);
    }

    public function testStaticPropertyFetch(): void
    {
        $class = new Name('Foo');
        $node = new StaticPropertyFetch($class, 'foo');
        $node->class = $class;

        $this->visitor->enterNode($node);

        $symbols = $this->visitor->getCollectedSymbols();
        $this->assertCount(1, $symbols);
        $this->assertContains('Foo', $symbols);
    }

    public function testClassConstantFetch(): void
    {
        $class = new Name('Foo');
        $node = new ClassConstFetch($class, 'FOO');
        $node->class = $class;

        $this->visitor->enterNode($node);

        $symbols = $this->visitor->getCollectedSymbols();
        $this->assertCount(1, $symbols);
        $this->assertContains('Foo', $symbols);
    }

    public function testNew(): void
    {
        $class = new Name('Foo');
        $node = new New_($class);
        $node->class = $class;

        $this->visitor->enterNode($node);

        $symbols = $this->visitor->getCollectedSymbols();
        $this->assertCount(1, $symbols);
        $this->assertContains('Foo', $symbols);
    }

    public function testInstanceof(): void
    {
        $class = new Name('Foo');
        $node = new Instanceof_(new Variable('foo'), $class);
        $node->class = $class;

        $this->visitor->enterNode($node);

        $symbols = $this->visitor->getCollectedSymbols();
        $this->assertCount(1, $symbols);
        $this->assertContains('Foo', $symbols);
    }

    public function testCatch(): void
    {
        $class = new Name('Foo');
        $node = new Catch_([$class], new Variable('e'));

        $this->visitor->enterNode($node);

        $symbols = $this->visitor->getCollectedSymbols();
        $this->assertCount(1, $symbols);
        $this->assertContains('Foo', $symbols);
    }

    public function testFunctionCallUsage(): void
    {
        $functionName = new Name('foo');
        $node = new FuncCall($functionName);
        $node->name = $functionName;

        $this->visitor->enterNode($node);

        $symbols = $this->visitor->getCollectedSymbols();
        $this->assertCount(1, $symbols);
        $this->assertContains('foo', $symbols);
    }

    public function testFunctionParameterType(): void
    {
        $functionName = new Name('foo');
        $node = new Function_($functionName);
        $node->name = $functionName;

        $param = new Param(new Variable('bar'));
        $param->type = new Name('Baz');
        $node->params = [$param];

        $this->visitor->enterNode($node);

        $symbols = $this->visitor->getCollectedSymbols();
        $this->assertCount(1, $symbols);
        $this->assertContains('Baz', $symbols);
    }

    public function testFunctionParameterTypeAsString(): void
    {
        $functionName = new Name('foo');
        $node = new Function_($functionName);
        $node->name = $functionName;

        $param = new Param(new Variable('bar'));
        $param->type = 'Baz';
        $node->params = [$param];

        $this->visitor->enterNode($node);

        $symbols = $this->visitor->getCollectedSymbols();
        $this->assertCount(1, $symbols);
        $this->assertContains('Baz', $symbols);
    }

    public function testMethodParameterType(): void
    {
        $functionName = new Name('foo');
        $node = new ClassMethod($functionName);
        $node->name = $functionName;

        $param = new Param(new Variable('bar'));
        $param->type = new Name('Baz');
        $node->params = [$param];

        $this->visitor->enterNode($node);

        $symbols = $this->visitor->getCollectedSymbols();
        $this->assertCount(1, $symbols);
        $this->assertContains('Baz', $symbols);
    }

    public function testMethodParameterTypeAsString(): void
    {
        $functionName = new Name('foo');
        $node = new ClassMethod($functionName);
        $node->name = $functionName;

        $param = new Param(new Variable('bar'));
        $param->type = 'Baz';
        $node->params = [$param];

        $this->visitor->enterNode($node);

        $symbols = $this->visitor->getCollectedSymbols();
        $this->assertCount(1, $symbols);
        $this->assertContains('Baz', $symbols);
    }

    public function testFunctionReturnType(): void
    {
        $functionName = new Name('foo');
        $node = new Function_($functionName);
        $node->returnType = new Name('Bar');

        $this->visitor->enterNode($node);

        $symbols = $this->visitor->getCollectedSymbols();
        $this->assertCount(1, $symbols);
        $this->assertContains('Bar', $symbols);
    }

    public function testMethodReturnType(): void
    {
        $functionName = new Name('foo');
        $node = new ClassMethod($functionName);
        $node->returnType = new Name('Bar');

        $this->visitor->enterNode($node);

        $symbols = $this->visitor->getCollectedSymbols();
        $this->assertCount(1, $symbols);
        $this->assertContains('Bar', $symbols);
    }

    public function testConstantFetch(): void
    {
        $exceptionClass = new Name('FooException');
        $node = new ConstFetch($exceptionClass);
        $node->name = $exceptionClass;

        $this->visitor->enterNode($node);

        $symbols = $this->visitor->getCollectedSymbols();
        $this->assertCount(1, $symbols);
        $this->assertContains('FooException', $symbols);
    }

    public function testTraits(): void
    {
        $node = new TraitUse([new Name('Foo')]);

        $this->visitor->enterNode($node);

        $symbols = $this->visitor->getCollectedSymbols();
        $this->assertCount(1, $symbols);
        $this->assertContains('Foo', $symbols);
    }

    public function testTraitUseVisibilityAdaptation(): void
    {
        $traitUseAdaption = new Alias(null, 'testMethod', Class_::MODIFIER_PUBLIC, null);
        $traitUse = new TraitUse([new Name('Foo')], [$traitUseAdaption]);

        $this->visitor->enterNode($traitUse);

        $symbols = $this->visitor->getCollectedSymbols();
        $this->assertCount(1, $symbols);
        $this->assertContains('Foo', $symbols);
    }

    public function testTraitUsePrecedenceAdaptation(): void
    {
        $traitUseAdaption = new Precedence(new Name('Bar'), 'testMethod', [new Name('Baz')]);
        $traitUse = new TraitUse([new Name('Foo')], [$traitUseAdaption]);

        $this->visitor->enterNode($traitUse);

        $symbols = $this->visitor->getCollectedSymbols();
        $this->assertCount(3, $symbols);
        $this->assertContains('Foo', $symbols);
        $this->assertContains('Bar', $symbols);
        $this->assertContains('Baz', $symbols);
    }

    public function testBeforeTraverseResetsRecordedSymbols(): void
    {
        $node = new Class_('Foo');
        $node->extends = new Name('Bar');
        $this->visitor->enterNode($node);

        $this->visitor->beforeTraverse([]);

        $this->assertCount(0, $this->visitor->getCollectedSymbols());
    }
}


1			<?php
2
3			namespace ComposerRequireCheckerTest\NodeVisitor;
4
5			use ComposerRequireChecker\NodeVisitor\UsedSymbolCollector;
6			use PhpParser\Node\Expr\ClassConstFetch;
7			use PhpParser\Node\Expr\ConstFetch;
8			use PhpParser\Node\Expr\FuncCall;
9			use PhpParser\Node\Expr\Instanceof_;
10			use PhpParser\Node\Expr\New_;
11			use PhpParser\Node\Expr\StaticCall;
12			use PhpParser\Node\Expr\StaticPropertyFetch;
13			use PhpParser\Node\Expr\Variable;
14			use PhpParser\Node\Name;
15			use PhpParser\Node\Param;
16			use PhpParser\Node\Stmt\Catch_;
17			use PhpParser\Node\Stmt\Class_;
18			use PhpParser\Node\Stmt\ClassMethod;
19			use PhpParser\Node\Stmt\Function_;
20			use PhpParser\Node\Stmt\Interface_;
21			use PhpParser\Node\Stmt\TraitUse;
22			use PhpParser\Node\Stmt\TraitUseAdaptation\Alias;
23			use PhpParser\Node\Stmt\TraitUseAdaptation\Precedence;
24			use PHPUnit\Framework\TestCase;
25
26			/**
27			* @covers \ComposerRequireChecker\NodeVisitor\UsedSymbolCollector
28			*/
29			final class UsedSymbolCollectorTest extends TestCase
30			{
31			/** @var UsedSymbolCollector */
32			private $visitor;
33
34			protected function setUp(): void
35			{
36			parent::setUp();
37
38			$this->visitor = new UsedSymbolCollector();
39			}
40
41			public function testExtendingClass(): void
42			{
43			$node = new Class_('Foo');
44			$node->extends = new Name('Bar');
45
46			$this->visitor->enterNode($node);
47
48			$symbols = $this->visitor->getCollectedSymbols();
49			$this->assertCount(1, $symbols);
50			$this->assertContains('Bar', $symbols);
51			}
52
53			public function testExtendingInterface(): void
54			{
55			$node = new Interface_('Foo');
56			$node->extends = [new Name('Bar'), new Name('Baz')];
57
58			$this->visitor->enterNode($node);
59
60			$symbols = $this->visitor->getCollectedSymbols();
61			$this->assertCount(2, $symbols);
62			$this->assertContains('Bar', $symbols);
63			$this->assertContains('Baz', $symbols);
64			}
65
66			public function testImplements(): void
67			{
68			$node = new Class_('Foo');
69			$node->implements = [new Name('Bar'), new Name('Baz')];
70
71			$this->visitor->enterNode($node);
72
73			$symbols = $this->visitor->getCollectedSymbols();
74			$this->assertCount(2, $symbols);
75			$this->assertContains('Bar', $symbols);
76			$this->assertContains('Baz', $symbols);
77			}
78
79			public function testStaticCall(): void
80			{
81			$class = new Name('Foo');
82			$node = new StaticCall($class, 'foo');
83			$node->class = $class;
84
85			$this->visitor->enterNode($node);
86
87			$symbols = $this->visitor->getCollectedSymbols();
88			$this->assertCount(1, $symbols);
89			$this->assertContains('Foo', $symbols);
90			}
91
92			public function testStaticPropertyFetch(): void
93			{
94			$class = new Name('Foo');
95			$node = new StaticPropertyFetch($class, 'foo');
96			$node->class = $class;
97
98			$this->visitor->enterNode($node);
99
100			$symbols = $this->visitor->getCollectedSymbols();
101			$this->assertCount(1, $symbols);
102			$this->assertContains('Foo', $symbols);
103			}
104
105			public function testClassConstantFetch(): void
106			{
107			$class = new Name('Foo');
108			$node = new ClassConstFetch($class, 'FOO');
109			$node->class = $class;
110
111			$this->visitor->enterNode($node);
112
113			$symbols = $this->visitor->getCollectedSymbols();
114			$this->assertCount(1, $symbols);
115			$this->assertContains('Foo', $symbols);
116			}
117
118			public function testNew(): void
119			{
120			$class = new Name('Foo');
121			$node = new New_($class);
122			$node->class = $class;
123
124			$this->visitor->enterNode($node);
125
126			$symbols = $this->visitor->getCollectedSymbols();
127			$this->assertCount(1, $symbols);
128			$this->assertContains('Foo', $symbols);
129			}
130
131			public function testInstanceof(): void
132			{
133			$class = new Name('Foo');
134			$node = new Instanceof_(new Variable('foo'), $class);
135			$node->class = $class;
136
137			$this->visitor->enterNode($node);
138
139			$symbols = $this->visitor->getCollectedSymbols();
140			$this->assertCount(1, $symbols);
141			$this->assertContains('Foo', $symbols);
142			}
143
144			public function testCatch(): void
145			{
146			$class = new Name('Foo');
147			$node = new Catch_([$class], new Variable('e'));
148
149			$this->visitor->enterNode($node);
150
151			$symbols = $this->visitor->getCollectedSymbols();
152			$this->assertCount(1, $symbols);
153			$this->assertContains('Foo', $symbols);
154			}
155
156			public function testFunctionCallUsage(): void
157			{
158			$functionName = new Name('foo');
159			$node = new FuncCall($functionName);
160			$node->name = $functionName;
161
162			$this->visitor->enterNode($node);
163
164			$symbols = $this->visitor->getCollectedSymbols();
165			$this->assertCount(1, $symbols);
166			$this->assertContains('foo', $symbols);
167			}
168
169			public function testFunctionParameterType(): void
170			{
171			$functionName = new Name('foo');
172			$node = new Function_($functionName);
173			$node->name = $functionName;
			0 ignored issues – show Documentation Bug introduced 2018-06-26 20:23 UTC by Report Bug Copy Issue Report It seems like `$functionName` of type `PhpParser\Node\Name` is incompatible with the declared type `PhpParser\Node\Identifier` of property `$name`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
174			$param = new Param(new Variable('bar'));
175			$param->type = new Name('Baz');
176			$node->params = [$param];
177
178			$this->visitor->enterNode($node);
179
180			$symbols = $this->visitor->getCollectedSymbols();
181			$this->assertCount(1, $symbols);
182			$this->assertContains('Baz', $symbols);
183			}
184
185			public function testFunctionParameterTypeAsString(): void
186			{
187			$functionName = new Name('foo');
188			$node = new Function_($functionName);
189			$node->name = $functionName;
			0 ignored issues – show Documentation Bug introduced 2018-06-26 20:23 UTC by Report Bug Copy Issue Report It seems like `$functionName` of type `PhpParser\Node\Name` is incompatible with the declared type `PhpParser\Node\Identifier` of property `$name`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
190			$param = new Param(new Variable('bar'));
191			$param->type = 'Baz';
192			$node->params = [$param];
193
194			$this->visitor->enterNode($node);
195
196			$symbols = $this->visitor->getCollectedSymbols();
197			$this->assertCount(1, $symbols);
198			$this->assertContains('Baz', $symbols);
199			}
200
201			public function testMethodParameterType(): void
202			{
203			$functionName = new Name('foo');
204			$node = new ClassMethod($functionName);
205			$node->name = $functionName;
			0 ignored issues – show Documentation Bug introduced 2018-06-26 20:23 UTC by Report Bug Copy Issue Report It seems like `$functionName` of type `PhpParser\Node\Name` is incompatible with the declared type `PhpParser\Node\Identifier` of property `$name`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
206			$param = new Param(new Variable('bar'));
207			$param->type = new Name('Baz');
208			$node->params = [$param];
209
210			$this->visitor->enterNode($node);
211
212			$symbols = $this->visitor->getCollectedSymbols();
213			$this->assertCount(1, $symbols);
214			$this->assertContains('Baz', $symbols);
215			}
216
217			public function testMethodParameterTypeAsString(): void
218			{
219			$functionName = new Name('foo');
220			$node = new ClassMethod($functionName);
221			$node->name = $functionName;
			0 ignored issues – show Documentation Bug introduced 2018-06-26 20:23 UTC by Report Bug Copy Issue Report It seems like `$functionName` of type `PhpParser\Node\Name` is incompatible with the declared type `PhpParser\Node\Identifier` of property `$name`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
222			$param = new Param(new Variable('bar'));
223			$param->type = 'Baz';
224			$node->params = [$param];
225
226			$this->visitor->enterNode($node);
227
228			$symbols = $this->visitor->getCollectedSymbols();
229			$this->assertCount(1, $symbols);
230			$this->assertContains('Baz', $symbols);
231			}
232
233			public function testFunctionReturnType(): void
234			{
235			$functionName = new Name('foo');
236			$node = new Function_($functionName);
237			$node->returnType = new Name('Bar');
238
239			$this->visitor->enterNode($node);
240
241			$symbols = $this->visitor->getCollectedSymbols();
242			$this->assertCount(1, $symbols);
243			$this->assertContains('Bar', $symbols);
244			}
245
246			public function testMethodReturnType(): void
247			{
248			$functionName = new Name('foo');
249			$node = new ClassMethod($functionName);
250			$node->returnType = new Name('Bar');
251
252			$this->visitor->enterNode($node);
253
254			$symbols = $this->visitor->getCollectedSymbols();
255			$this->assertCount(1, $symbols);
256			$this->assertContains('Bar', $symbols);
257			}
258
259			public function testConstantFetch(): void
260			{
261			$exceptionClass = new Name('FooException');
262			$node = new ConstFetch($exceptionClass);
263			$node->name = $exceptionClass;
264
265			$this->visitor->enterNode($node);
266
267			$symbols = $this->visitor->getCollectedSymbols();
268			$this->assertCount(1, $symbols);
269			$this->assertContains('FooException', $symbols);
270			}
271
272			public function testTraits(): void
273			{
274			$node = new TraitUse([new Name('Foo')]);
275
276			$this->visitor->enterNode($node);
277
278			$symbols = $this->visitor->getCollectedSymbols();
279			$this->assertCount(1, $symbols);
280			$this->assertContains('Foo', $symbols);
281			}
282
283			public function testTraitUseVisibilityAdaptation(): void
284			{
285			$traitUseAdaption = new Alias(null, 'testMethod', Class_::MODIFIER_PUBLIC, null);
286			$traitUse = new TraitUse([new Name('Foo')], [$traitUseAdaption]);
287
288			$this->visitor->enterNode($traitUse);
289
290			$symbols = $this->visitor->getCollectedSymbols();
291			$this->assertCount(1, $symbols);
292			$this->assertContains('Foo', $symbols);
293			}
294
295			public function testTraitUsePrecedenceAdaptation(): void
296			{
297			$traitUseAdaption = new Precedence(new Name('Bar'), 'testMethod', [new Name('Baz')]);
298			$traitUse = new TraitUse([new Name('Foo')], [$traitUseAdaption]);
299
300			$this->visitor->enterNode($traitUse);
301
302			$symbols = $this->visitor->getCollectedSymbols();
303			$this->assertCount(3, $symbols);
304			$this->assertContains('Foo', $symbols);
305			$this->assertContains('Bar', $symbols);
306			$this->assertContains('Baz', $symbols);
307			}
308
309			public function testBeforeTraverseResetsRecordedSymbols(): void
310			{
311			$node = new Class_('Foo');
312			$node->extends = new Name('Bar');
313			$this->visitor->enterNode($node);
314
315			$this->visitor->beforeTraverse([]);
316
317			$this->assertCount(0, $this->visitor->getCollectedSymbols());
318			}
319			}
320

maglnet / ComposerRequireChecker

UsedSymbolCollectorTest A last analyzed 2020-10-01 20:50 UTC

Complexity

Size/Duplication

Importance

22 Methods

Duplication Side-by-Side

Filter issues like

UsedSymbolCollectorTest A
last analyzed 2020-10-01 20:50 UTC