HookRunnerTest::optionsProvider() - Code Metrics - Inspection of "Drop support for old version of PHP and MW" - JeroenDeDauw/ParserHooks - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#18)

by Jeroen De

created 2017-03-30 05:53 UTC

HookRunnerTest::optionsProvider() A

↳ Parent: HookRunnerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	52
Code Lines	37

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	37
nc	1
nop	0
dl	0
loc	52
rs	9.4929
c	0
b	0
f	0

How to fix Long Method

<?php

namespace ParserHooks\Tests;

use ParamProcessor\ProcessedParam;
use ParamProcessor\ProcessingResult;
use ParserHooks\FunctionRunner;
use ParserHooks\HookDefinition;
use ParserHooks\HookRunner;

/**
 * @covers ParserHooks\HookRunner
 * @covers ParserHooks\Internal\Runner
 *
 * @group ParserHooks
 *
 * @licence GNU GPL v2+
 * @author Jeroen De Dauw < [email protected] >
 */
class HookRunnerTest extends \PHPUnit_Framework_TestCase {

	public function optionsProvider() {
		return array(
			array(
				array(
					HookRunner::OPT_DO_PARSE => true,
				),
				array(),
				array(),
				array(),
			),
			array(
				array(
					HookRunner::OPT_DO_PARSE => false,
				),
				array(),
				array(),
				array(),
			),
			array(
				array(
					HookRunner::OPT_DO_PARSE => true,
				),
				array(
					'foo' => 'bar',
					'baz' => 'bah',
				),
				array(),
				array(
					'foo' => 'bar',
					'baz' => 'bah',
				),
			),
			array(
				array(
					HookRunner::OPT_DO_PARSE => true,
				),
				array(
					'foo' => 'bar',
					'baz' => 'bah',
				),
				array(
					'ohi',
					'there',
				),
				array(
					'ohi' => self::INPUT_TEXT,
					'foo' => 'bar',
					'baz' => 'bah',
				),
			),
		);
	}

	const HOOK_HANDLER_RESULT = 'hook handler result';
	const PARSE_RESULT = 'the parsed result';
	const INPUT_TEXT = 'input text';

	protected $options;

	protected $frame;
	protected $parser;

	/**
	 * @dataProvider optionsProvider
	 */
	public function testRun( array $options, array $params, array $defaultParams, array $expectedParams ) {
		$this->options = $options;

		$this->frame = $this->getMock( 'PPFrame' );
		$this->parser = $this->newMockParser();

		$runner = $this->newHookRunner( $defaultParams, $expectedParams );

		$result = $runner->run(
			self::INPUT_TEXT,
			$params,
			$this->parser,
			$this->frame
		);

		$expectedResult = $this->options[HookRunner::OPT_DO_PARSE] ? self::PARSE_RESULT : self::HOOK_HANDLER_RESULT;

		$this->assertEquals( $expectedResult, $result );
	}

	protected function newHookRunner( array $defaultParams, array $expectedParams ) {
		$processedParams = new ProcessingResult( array(
			'foo' => new ProcessedParam( 'foo', 'bar', false )
		) );

		$definition = new HookDefinition(
			'someHook',
			array(),
			$defaultParams
		);

		$paramProcessor = $this->newMockParamProcessor( $expectedParams, $processedParams );

		$hookHandler = $this->newMockHookHandler( $processedParams );

		return new HookRunner(
			$definition,
			$hookHandler,
			$this->options,
			$paramProcessor
		);
	}

	protected function newMockParser() {
		$parser = $this->getMock( 'Parser' );

		if ( $this->options[HookRunner::OPT_DO_PARSE] ) {
			$parser->expects( $this->once() )
				->method( 'recursiveTagParse' )
				->with(
					$this->equalTo( self::HOOK_HANDLER_RESULT ),
					$this->equalTo( $this->frame )
				)
				->will( $this->returnValue( self::PARSE_RESULT ) );
		}
		else {
			$parser->expects( $this->never() )
				->method( 'recursiveTagParse' );
		}

		return $parser;
	}

	protected function newMockHookHandler( $expectedProcessor ) {
		$hookHandler = $this->getMock( 'ParserHooks\HookHandler' );

		$hookHandler->expects( $this->once() )
			->method( 'handle' )
			->with(
				$this->equalTo( $this->parser ),
				$this->equalTo( $expectedProcessor )
			)
			->will( $this->returnValue( self::HOOK_HANDLER_RESULT ) );

		return $hookHandler;
	}

	protected function newMockParamProcessor( $expandedParams, $processedParams ) {
		$paramProcessor = $this->getMockBuilder( 'ParamProcessor\Processor' )
			->disableOriginalConstructor()->getMock();

		$paramProcessor->expects( $this->once() )
			->method( 'setParameters' )
			->with( $this->equalTo( $expandedParams ) );

		$paramProcessor->expects( $this->once() )
			->method( 'processParameters' )
			->will( $this->returnValue( $processedParams ) );

		return $paramProcessor;
	}

}


1			<?php
2
3			namespace ParserHooks\Tests;
4
5			use ParamProcessor\ProcessedParam;
6			use ParamProcessor\ProcessingResult;
7			use ParserHooks\FunctionRunner;
8			use ParserHooks\HookDefinition;
9			use ParserHooks\HookRunner;
10
11			/**
12			* @covers ParserHooks\HookRunner
13			* @covers ParserHooks\Internal\Runner
14			*
15			* @group ParserHooks
16			*
17			* @licence GNU GPL v2+
18			* @author Jeroen De Dauw < [email protected] >
19			*/
20			class HookRunnerTest extends \PHPUnit_Framework_TestCase {
21
22			public function optionsProvider() {
23			return array(
24			array(
25			array(
26			HookRunner::OPT_DO_PARSE => true,
27			),
28			array(),
29			array(),
30			array(),
31			),
32			array(
33			array(
34			HookRunner::OPT_DO_PARSE => false,
35			),
36			array(),
37			array(),
38			array(),
39			),
40			array(
41			array(
42			HookRunner::OPT_DO_PARSE => true,
43			),
44			array(
45			'foo' => 'bar',
46			'baz' => 'bah',
47			),
48			array(),
49			array(
50			'foo' => 'bar',
51			'baz' => 'bah',
52			),
53			),
54			array(
55			array(
56			HookRunner::OPT_DO_PARSE => true,
57			),
58			array(
59			'foo' => 'bar',
60			'baz' => 'bah',
61			),
62			array(
63			'ohi',
64			'there',
65			),
66			array(
67			'ohi' => self::INPUT_TEXT,
68			'foo' => 'bar',
69			'baz' => 'bah',
70			),
71			),
72			);
73			}
74
75			const HOOK_HANDLER_RESULT = 'hook handler result';
76			const PARSE_RESULT = 'the parsed result';
77			const INPUT_TEXT = 'input text';
78
79			protected $options;
80
81			protected $frame;
82			protected $parser;
83
84			/**
85			* @dataProvider optionsProvider
86			*/
87			public function testRun( array $options, array $params, array $defaultParams, array $expectedParams ) {
88			$this->options = $options;
89
90			$this->frame = $this->getMock( 'PPFrame' );
91			$this->parser = $this->newMockParser();
92
93			$runner = $this->newHookRunner( $defaultParams, $expectedParams );
94
95			$result = $runner->run(
96			self::INPUT_TEXT,
97			$params,
98			$this->parser,
99			$this->frame
100			);
101
102			$expectedResult = $this->options[HookRunner::OPT_DO_PARSE] ? self::PARSE_RESULT : self::HOOK_HANDLER_RESULT;
103
104			$this->assertEquals( $expectedResult, $result );
105			}
106
107			protected function newHookRunner( array $defaultParams, array $expectedParams ) {
108			$processedParams = new ProcessingResult( array(
109			'foo' => new ProcessedParam( 'foo', 'bar', false )
110			) );
111
112			$definition = new HookDefinition(
113			'someHook',
114			array(),
115			$defaultParams
116			);
117
118			$paramProcessor = $this->newMockParamProcessor( $expectedParams, $processedParams );
119
120			$hookHandler = $this->newMockHookHandler( $processedParams );
121
122			return new HookRunner(
123			$definition,
124			$hookHandler,
125			$this->options,
126			$paramProcessor
127			);
128			}
129
130			protected function newMockParser() {
131			$parser = $this->getMock( 'Parser' );
132
133			if ( $this->options[HookRunner::OPT_DO_PARSE] ) {
134			$parser->expects( $this->once() )
135			->method( 'recursiveTagParse' )
136			->with(
137			$this->equalTo( self::HOOK_HANDLER_RESULT ),
138			$this->equalTo( $this->frame )
139			)
140			->will( $this->returnValue( self::PARSE_RESULT ) );
141			}
142			else {
143			$parser->expects( $this->never() )
144			->method( 'recursiveTagParse' );
145			}
146
147			return $parser;
148			}
149
150			protected function newMockHookHandler( $expectedProcessor ) {
151			$hookHandler = $this->getMock( 'ParserHooks\HookHandler' );
152
153			$hookHandler->expects( $this->once() )
154			->method( 'handle' )
155			->with(
156			$this->equalTo( $this->parser ),
157			$this->equalTo( $expectedProcessor )
158			)
159			->will( $this->returnValue( self::HOOK_HANDLER_RESULT ) );
160
161			return $hookHandler;
162			}
163
164			protected function newMockParamProcessor( $expandedParams, $processedParams ) {
165			$paramProcessor = $this->getMockBuilder( 'ParamProcessor\Processor' )
166			->disableOriginalConstructor()->getMock();
167
168			$paramProcessor->expects( $this->once() )
169			->method( 'setParameters' )
170			->with( $this->equalTo( $expandedParams ) );
171
172			$paramProcessor->expects( $this->once() )
173			->method( 'processParameters' )
174			->will( $this->returnValue( $processedParams ) );
175
176			return $paramProcessor;
177			}
178
179			}
180

JeroenDeDauw / ParserHooks

Pull Request — master (#18)

HookRunnerTest::optionsProvider() A

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like