RouteExpressionParserTest::parseDataProvider() - Code Metrics - yarhon/RouteGuardBundle - Measure and Improve Code Quality continuously with Scrutinizer

RouteExpressionParserTest::parseDataProvider() A
last analyzed 2018-12-01 21:53 UTC

↳ Parent: RouteExpressionParserTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	66
Code Lines	38

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	38
dl	0
loc	66
rs	9.312
c	0
b	0
f	0
cc	1
nc	1
nop	0

How to fix Long Method

<?php

/*
 *
 * (c) Yaroslav Honcharuk <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Yarhon\RouteGuardBundle\Tests\Twig\TokenParser;

use Twig\Node\Node;
use Twig\Node\Expression\ConstantExpression;
use Twig\Node\Expression\ArrayExpression;
use Twig\Error\SyntaxError;
use Yarhon\RouteGuardBundle\Tests\Twig\AbstractNodeTest;
use Yarhon\RouteGuardBundle\Twig\Node\RouteExpression;

class RouteExpressionParserTest extends AbstractNodeTest
{
    /**
     * @dataProvider parseDataProvider
     */
    public function testParse($source, $expected)
    {
        $node = $this->parse($source);
        $node = $node->getNode('condition');

        $this->assertEquals($expected, $node);
    }

    public function parseDataProvider()
    {
        return [
            [
                '{% $tagName "secure1" %}{% end$tagName %}',
                new RouteExpression(
                    new Node([
                        new ConstantExpression('secure1', 0),
                    ])
                ),
            ],
            [
                '{% $tagName "secure1", {page: 10} %}{% end$tagName %}',
                new RouteExpression(
                    new Node([
                        new ConstantExpression('secure1', 0),
                        new ArrayExpression([
                            new ConstantExpression('page', 0),
                            new ConstantExpression(10, 0),
                        ], 0),
                    ])
                ),
            ],
            [
                '{% $tagName "secure1", {}, "POST" %}{% end$tagName %}',
                new RouteExpression(
                    new Node([
                        new ConstantExpression('secure1', 0),
                        new ArrayExpression([], 0),
                        new ConstantExpression('POST', 0),
                    ])
                ),
            ],
            [
                '{% $tagName "secure1" as path %}{% end$tagName %}',
                (new RouteExpression(
                    new Node([
                        new ConstantExpression('secure1', 0),
                    ])
                ))->setGenerateAs('path', false),
            ],
            [
                '{% $tagName "secure1" as path relative %}{% end$tagName %}',
                (new RouteExpression(
                    new Node([
                        new ConstantExpression('secure1', 0),
                    ])
                ))->setGenerateAs('path', true),
            ],

            [
                '{% $tagName "secure1" as path absolute %}{% end$tagName %}',
                (new RouteExpression(
                    new Node([
                        new ConstantExpression('secure1', 0),
                    ])
                ))->setGenerateAs('path', false),
            ],

            [
                '{% $tagName "secure1" as url %}{% end$tagName %}',
                (new RouteExpression(
                    new Node([
                        new ConstantExpression('secure1', 0),
                    ])
                ))->setGenerateAs('url', false),
            ],
        ];
    }

    /**
     * @dataProvider parseExceptionDataProvider
     */
    public function testParseException($source, $expected)
    {
        $this->expectException($expected[0]);
        if (isset($expected[1])) {
            $this->expectExceptionMessage($expected[1]);
        }

        $this->parse($source);
    }

    public function parseExceptionDataProvider()
    {
        return [
            [
                // with "as" and no params
                '{% $tagName "secure1" as %}{% end$tagName %}',
                [SyntaxError::class, '"name" expected with value "url" or "path"'],
            ],

            [
                // with "as" and invalid function name
                '{% $tagName "secure1" as blabla %}{% end$tagName %}',
                [SyntaxError::class, '"name" expected with value "url" or "path"'],
            ],

            [
                // with "as" and invalid relative param
                '{% $tagName "secure1" as path blabla %}{% end$tagName %}',
                [SyntaxError::class],
            ],
        ];
    }
}


1			<?php
2
3			/*
4			*
5			* (c) Yaroslav Honcharuk <[email protected]>
6			*
7			* For the full copyright and license information, please view the LICENSE
8			* file that was distributed with this source code.
9			*/
10
11			namespace Yarhon\RouteGuardBundle\Tests\Twig\TokenParser;
12
13			use Twig\Node\Node;
14			use Twig\Node\Expression\ConstantExpression;
15			use Twig\Node\Expression\ArrayExpression;
16			use Twig\Error\SyntaxError;
17			use Yarhon\RouteGuardBundle\Tests\Twig\AbstractNodeTest;
18			use Yarhon\RouteGuardBundle\Twig\Node\RouteExpression;
19
20			class RouteExpressionParserTest extends AbstractNodeTest
21			{
22			/**
23			* @dataProvider parseDataProvider
24			*/
25			public function testParse($source, $expected)
26			{
27			$node = $this->parse($source);
28			$node = $node->getNode('condition');
29
30			$this->assertEquals($expected, $node);
31			}
32
33			public function parseDataProvider()
34			{
35			return [
36			[
37			'{% $tagName "secure1" %}{% end$tagName %}',
38			new RouteExpression(
39			new Node([
40			new ConstantExpression('secure1', 0),
41			])
42			),
43			],
44			[
45			'{% $tagName "secure1", {page: 10} %}{% end$tagName %}',
46			new RouteExpression(
47			new Node([
48			new ConstantExpression('secure1', 0),
49			new ArrayExpression([
50			new ConstantExpression('page', 0),
51			new ConstantExpression(10, 0),
52			], 0),
53			])
54			),
55			],
56			[
57			'{% $tagName "secure1", {}, "POST" %}{% end$tagName %}',
58			new RouteExpression(
59			new Node([
60			new ConstantExpression('secure1', 0),
61			new ArrayExpression([], 0),
62			new ConstantExpression('POST', 0),
63			])
64			),
65			],
66			[
67			'{% $tagName "secure1" as path %}{% end$tagName %}',
68			(new RouteExpression(
69			new Node([
70			new ConstantExpression('secure1', 0),
71			])
72			))->setGenerateAs('path', false),
73			],
74			[
75			'{% $tagName "secure1" as path relative %}{% end$tagName %}',
76			(new RouteExpression(
77			new Node([
78			new ConstantExpression('secure1', 0),
79			])
80			))->setGenerateAs('path', true),
81			],
82
83			[
84			'{% $tagName "secure1" as path absolute %}{% end$tagName %}',
85			(new RouteExpression(
86			new Node([
87			new ConstantExpression('secure1', 0),
88			])
89			))->setGenerateAs('path', false),
90			],
91
92			[
93			'{% $tagName "secure1" as url %}{% end$tagName %}',
94			(new RouteExpression(
95			new Node([
96			new ConstantExpression('secure1', 0),
97			])
98			))->setGenerateAs('url', false),
99			],
100			];
101			}
102
103			/**
104			* @dataProvider parseExceptionDataProvider
105			*/
106			public function testParseException($source, $expected)
107			{
108			$this->expectException($expected[0]);
109			if (isset($expected[1])) {
110			$this->expectExceptionMessage($expected[1]);
111			}
112
113			$this->parse($source);
114			}
115
116			public function parseExceptionDataProvider()
117			{
118			return [
119			[
120			// with "as" and no params
121			'{% $tagName "secure1" as %}{% end$tagName %}',
122			[SyntaxError::class, '"name" expected with value "url" or "path"'],
123			],
124
125			[
126			// with "as" and invalid function name
127			'{% $tagName "secure1" as blabla %}{% end$tagName %}',
128			[SyntaxError::class, '"name" expected with value "url" or "path"'],
129			],
130
131			[
132			// with "as" and invalid relative param
133			'{% $tagName "secure1" as path blabla %}{% end$tagName %}',
134			[SyntaxError::class],
135			],
136			];
137			}
138			}
139

yarhon / RouteGuardBundle

RouteExpressionParserTest::parseDataProvider() A last analyzed 2018-12-01 21:53 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

RouteExpressionParserTest::parseDataProvider() A
last analyzed 2018-12-01 21:53 UTC