ProcessorTest::testSetParameters() - Code Metrics - Inspection of "Use ::class" - JeroenDeDauw/ParamProcessor - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ebda25...4c5acd )

by Jeroen De

created 2019-07-28 09:14 UTC

ProcessorTest::testSetParameters() A

↳ Parent: ProcessorTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	7
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	3

<?php

namespace ParamProcessor\Tests;

use ParamProcessor\ParamDefinitionFactory;
use ParamProcessor\ProcessedParam;
use ParamProcessor\ProcessingError;
use ParamProcessor\ProcessingResult;
use ParamProcessor\Processor;
use ParamProcessor\Options;
use PHPUnit\Framework\TestCase;

/**
 * @covers \ParamProcessor\Processor
 *
 * @licence GNU GPL v2+
 * @author Jeroen De Dauw < [email protected] >
 */
class ProcessorTest extends TestCase {

	public function newFromOptionsProvider() {
		$options = [];

		$option = new Options();

		$options[] = clone $option;

		$option->setName( 'foobar' );
		$option->setLowercaseNames( false );

		$options[] = clone $option;

		return $this->arrayWrap( $options );
	}

	private function arrayWrap( array $elements ) {
		return array_map(
			function( $element ) {
				return [ $element ];
			},
			$elements
		);
	}

	public function testNewFromOptions() {
		$this->assertEquals( new Options(), Processor::newFromOptions( new Options() )->getOptions() );
	}

	/**
	 * Simple parameter definitions and values that should all pass.
	 *
	 * @return array
	 */
	private function getSimpleParams() {
		$params = [
			'awesome' => 'yes',
			'Howmuch ' => '9001',
			'FLOAT' => '4.2',
			' page' => 'Ohi there!',
			' text     ' => 'foo bar baz o_O',
		];

		$definitions = [
			'awesome' => [
				'type' => 'boolean',
			],
			'howmuch' => [
				'type' => 'integer',
			],
			'float' => [
				'type' => 'float',
			],
			'page' => [
				'type' => 'string',
				'hastoexist' => false,
			],
			'text' => [],
		];

		$options = new Options();

		$expected = [
			'awesome' => true,
			'howmuch' => 9001,
			'float' => 4.2,
			'page' => 'Ohi there!',
			'text' => 'foo bar baz o_O',
		];

		return [ $params, $definitions, $options, $expected ];
	}

	/**
	 * Simple parameter definitions with defaults and values
	 * that are invalid or missing and therefore default.
	 *
	 * @return array
	 */
	private function getDefaultingParams() {
		$params = [
			'awesome' => 'omg!',
			'howmuch' => 'omg!',
			'float' => 'omg!',
			'page' => 42,
			'whot?' => 'O_o',
			'integerr' => ' 9001 ',
		];

		$definitions = [
			'awesome' => [
				'type' => 'boolean',
				'default' => true,
			],
			'howmuch' => [
				'type' => 'integer',
				'default' => 9001,
			],
			'float' => [
				'type' => 'float',
				'default' => 4.2,
			],
			'page' => [
				'type' => 'string',
				'hastoexist' => false,
				'default' => 'Ohi there!',
			],
			'text' => [
				'default' => 'foo bar baz o_O',
			],
			'integerr' => [
				'type' => 'integer',
				'default' => 42,
			],
		];

		$options = new Options();
		$options->setTrimValues( false );

		$expected = [
			'awesome' => true,
			'howmuch' => 9001,
			'float' => 4.2,
			'page' => 'Ohi there!',
			'text' => 'foo bar baz o_O',
			'integerr' => 42,
		];

		return [ $params, $definitions, $options, $expected ];
	}

	/**
	 * Values and definitions in-system parameter handling.
	 * Options set to expect non-raw values.
	 *
	 * @return array
	 */
	private function getTypedParams() {
		$params = [
			'awesome' => true,
			'howmuch' => '42',
			'float' => 4.2,
			'page' => 'Ohi there!',
			'Text' => 'foo bar baz o_O',
			'text1 ' => 'foo bar baz o_O',
			' text2' => 'foo bar baz o_O',
		];

		$definitions = [
			'awesome' => [
				'type' => 'boolean',
			],
			'howmuch' => [
				'type' => 'integer',
				'default' => 9001,
			],
			'float' => [
				'type' => 'float',
				'lowerbound' => 9001,
				'default' => 9000.1
			],
			'page' => [
				'type' => 'string',
				'hastoexist' => false,
			],
			'text' => [
				'default' => 'some text',
			],
			'text1' => [
				'default' => 'some text',
			],
			'text2' => [
				'default' => 'some text',
			],
		];

		$options = new Options();
		$options->setRawStringInputs( false );
		$options->setLowercaseNames( false );
		$options->setTrimNames( false );

		$expected = [
			'awesome' => true,
			'howmuch' => 9001,
			'float' => 9000.1,
			'page' => 'Ohi there!',
			'text' => 'some text',
			'text1' => 'some text',
			'text2' => 'some text',
		];

		return [ $params, $definitions, $options, $expected ];
	}

	/**
	 * Values with capitalization and preceding/tailing spaces to test
	 * of the clean options work.
	 *
	 * @return array
	 */
	private function getUncleanParams() {
		$params = [
			'awesome' => ' yes ',
			'text' => ' FOO  bar  ',
			'integerr' => ' 9001 ',
		];

		$definitions = [
			'awesome' => [
				'type' => 'boolean',
			],
			'text' => [
				'default' => 'bar',
			],
			'integerr' => [
				'type' => 'integer',
				'default' => 42,
			],
		];

		$options = new Options();
		$options->setLowercaseValues( true );
		$options->setTrimValues( true );

		$expected = [
			'awesome' => true,
			'text' => 'foo  bar',
			'integerr' => 9001,
		];

		return [ $params, $definitions, $options, $expected ];
	}

	/**
	 * List parameters to test if list handling works correctly.
	 *
	 * @return array
	 */
	private function getListParams() {
		$params = [
			'awesome' => ' yes, no, on, off ',
			'float' => ' 9001 ; 42 ; 4.2;0',
		];

		$definitions = [
			'awesome' => [
				'type' => 'boolean',
				'islist' => true,
			],
			'text' => [
				'default' => [ 'bar' ],
				'islist' => true,
			],
			'float' => [
				'type' => 'float',
				'islist' => true,
				'delimiter' => ';'
			],
		];

		$options = new Options();
		$options->setLowercaseValues( true );
		$options->setTrimValues( true );

		$expected = [
			'awesome' => [ true, false, true, false ],
			'text' => [ 'bar' ],
			'float' => [ 9001.0, 42.0, 4.2, 0.0 ],
		];

		return [ $params, $definitions, $options, $expected ];
	}

	public function parameterProvider() {
		// $params, $definitions [, $options]
		$argLists = [];

		$argLists[] = $this->getSimpleParams();

		$argLists[] = $this->getDefaultingParams();

		$argLists[] = $this->getTypedParams();

		$argLists[] = $this->getUncleanParams();

		$argLists[] = $this->getListParams();

		foreach ( $argLists as &$argList ) {
			foreach ( $argList[1] as $key => &$definition ) {
				$definition['message'] = 'test-' . $key;
			}

			if ( !array_key_exists( 2, $argList ) ) {
				$argList[2] = new Options();
			}
		}

		return $argLists;
	}

	/**
	 * @dataProvider parameterProvider
	 */
	public function testSetParameters( array $params, array $definitions, Options $options ) {
		$validator = Processor::newFromOptions( $options );

		$validator->setParameters( $params, $definitions );

		$this->assertTrue( true ); // TODO
	}

	/**
	 * @dataProvider parameterProvider
	 */
	public function testValidateParameters( array $params, array $definitions, Options $options, array $expected = [] ) {
		$validator = Processor::newFromOptions( $options );

		$validator->setParameters( $params, $definitions );

		$processingResult = $validator->processParameters();

		$actualValues = [];

		foreach ( $processingResult->getParameters() as $param ) {
			$actualValues[$param->getName()] = $param->getValue();
		}

		$this->assertEquals( $expected, $actualValues );


	}

	public function testProcessParametersOnEmptyOptions() {
		$processor = Processor::newDefault();

		$this->assertInstanceOf(
			ProcessingResult::class,
			$processor->processParameters()
		);
	}

	public function testErrorsCanBeRetrievedAfterProcessing() {
		$processor = Processor::newDefault();

		$this->processWithOneError( $processor );

		$this->assertCount( 1, $processor->getErrors() );
	}

	private function processWithOneError( Processor $processor ) {
		$processor->setParameters(
			[],
			[
				'awesome' => [
					'type' => 'boolean',
					'message' => 'test-awesome'
				],
			]
		);

		// There should be a single "missing required parameter" error.
		$processor->processParameters();
	}

	public function testErrorsAreClearedBetweenProcessingRuns() {
		$processor = Processor::newDefault();

		$this->processWithOneError( $processor );
		$processor->setParameters( [], [] );
		$processor->processParameters();

		$this->assertEmpty( $processor->getErrors() );
	}

	public function testInvalidListElementsAreOmitted() {
		$processor = Processor::newDefault();

		$processor->setFunctionParams(
			[
				'some-list=1,2,3, ,4,'
			],
			[
				'some-list' => [
					'type' => 'integer',
					'message' => 'test',
					'islist' => true
				],
			]
		);

		$this->assertSame(
			[ 1, 2, 3, 4 ],
			$processor->processParameters()->getParameters()['some-list']->getValue()
		);
	}

	public function testListParametersAreNotDefaultedWhenSomeElementsAreInvalid() {
		$processor = Processor::newDefault();

		$processor->setFunctionParams(
			[
				'some-list=1,nan'
			],
			[
				'some-list' => [
					'type' => 'integer',
					'message' => 'test',
					'islist' => true,
					'default' => []
				],
			]
		);

		$this->assertSame(
			[ 1 ],
			$processor->processParameters()->getParameters()['some-list']->getValue()
		);
	}

	public function testListParametersAreDefaultedWhenAllElementsAreInvalid() {
		$processor = Processor::newDefault();

		$processor->setFunctionParams(
			[
				'some-list=such,nan'
			],
			[
				'some-list' => [
					'type' => 'integer',
					'message' => 'test',
					'islist' => true,
					'default' => [ 42 ]
				],
			]
		);

		$this->assertSame(
			[ 42 ],
			$processor->processParameters()->getParameters()['some-list']->getValue()
		);
	}

	public function testSetParameterDefinitions() {
		$processor = Processor::newDefault();

		$processor->setFunctionParams( [ 'some-list=42,23,9001' ] );

		$processor->setParameterDefinitions(
			[
				( ParamDefinitionFactory::newDefault() )->newDefinitionFromArray(
					[
						'name' => 'some-list',
						'type' => 'integer',
						'message' => 'test',
						'islist' => true
					]
				)
			]
		);

		$this->assertSame(
			[ 42, 23, 9001 ],
			$processor->processParameters()->getParameters()['some-list']->getValue()
		);
	}

}


1			<?php
2
3			namespace ParamProcessor\Tests;
4
5			use ParamProcessor\ParamDefinitionFactory;
6			use ParamProcessor\ProcessedParam;
7			use ParamProcessor\ProcessingError;
8			use ParamProcessor\ProcessingResult;
9			use ParamProcessor\Processor;
10			use ParamProcessor\Options;
11			use PHPUnit\Framework\TestCase;
12
13			/**
14			* @covers \ParamProcessor\Processor
15			*
16			* @licence GNU GPL v2+
17			* @author Jeroen De Dauw < [email protected] >
18			*/
19			class ProcessorTest extends TestCase {
20
21			public function newFromOptionsProvider() {
22			$options = [];
23
24			$option = new Options();
25
26			$options[] = clone $option;
27
28			$option->setName( 'foobar' );
29			$option->setLowercaseNames( false );
30
31			$options[] = clone $option;
32
33			return $this->arrayWrap( $options );
34			}
35
36			private function arrayWrap( array $elements ) {
37			return array_map(
38			function( $element ) {
39			return [ $element ];
40			},
41			$elements
42			);
43			}
44
45			public function testNewFromOptions() {
46			$this->assertEquals( new Options(), Processor::newFromOptions( new Options() )->getOptions() );
47			}
48
49			/**
50			* Simple parameter definitions and values that should all pass.
51			*
52			* @return array
53			*/
54			private function getSimpleParams() {
55			$params = [
56			'awesome' => 'yes',
57			'Howmuch ' => '9001',
58			'FLOAT' => '4.2',
59			' page' => 'Ohi there!',
60			' text ' => 'foo bar baz o_O',
61			];
62
63			$definitions = [
64			'awesome' => [
65			'type' => 'boolean',
66			],
67			'howmuch' => [
68			'type' => 'integer',
69			],
70			'float' => [
71			'type' => 'float',
72			],
73			'page' => [
74			'type' => 'string',
75			'hastoexist' => false,
76			],
77			'text' => [],
78			];
79
80			$options = new Options();
81
82			$expected = [
83			'awesome' => true,
84			'howmuch' => 9001,
85			'float' => 4.2,
86			'page' => 'Ohi there!',
87			'text' => 'foo bar baz o_O',
88			];
89
90			return [ $params, $definitions, $options, $expected ];
91			}
92
93			/**
94			* Simple parameter definitions with defaults and values
95			* that are invalid or missing and therefore default.
96			*
97			* @return array
98			*/
99			private function getDefaultingParams() {
100			$params = [
101			'awesome' => 'omg!',
102			'howmuch' => 'omg!',
103			'float' => 'omg!',
104			'page' => 42,
105			'whot?' => 'O_o',
106			'integerr' => ' 9001 ',
107			];
108
109			$definitions = [
110			'awesome' => [
111			'type' => 'boolean',
112			'default' => true,
113			],
114			'howmuch' => [
115			'type' => 'integer',
116			'default' => 9001,
117			],
118			'float' => [
119			'type' => 'float',
120			'default' => 4.2,
121			],
122			'page' => [
123			'type' => 'string',
124			'hastoexist' => false,
125			'default' => 'Ohi there!',
126			],
127			'text' => [
128			'default' => 'foo bar baz o_O',
129			],
130			'integerr' => [
131			'type' => 'integer',
132			'default' => 42,
133			],
134			];
135
136			$options = new Options();
137			$options->setTrimValues( false );
138
139			$expected = [
140			'awesome' => true,
141			'howmuch' => 9001,
142			'float' => 4.2,
143			'page' => 'Ohi there!',
144			'text' => 'foo bar baz o_O',
145			'integerr' => 42,
146			];
147
148			return [ $params, $definitions, $options, $expected ];
149			}
150
151			/**
152			* Values and definitions in-system parameter handling.
153			* Options set to expect non-raw values.
154			*
155			* @return array
156			*/
157			private function getTypedParams() {
158			$params = [
159			'awesome' => true,
160			'howmuch' => '42',
161			'float' => 4.2,
162			'page' => 'Ohi there!',
163			'Text' => 'foo bar baz o_O',
164			'text1 ' => 'foo bar baz o_O',
165			' text2' => 'foo bar baz o_O',
166			];
167
168			$definitions = [
169			'awesome' => [
170			'type' => 'boolean',
171			],
172			'howmuch' => [
173			'type' => 'integer',
174			'default' => 9001,
175			],
176			'float' => [
177			'type' => 'float',
178			'lowerbound' => 9001,
179			'default' => 9000.1
180			],
181			'page' => [
182			'type' => 'string',
183			'hastoexist' => false,
184			],
185			'text' => [
186			'default' => 'some text',
187			],
188			'text1' => [
189			'default' => 'some text',
190			],
191			'text2' => [
192			'default' => 'some text',
193			],
194			];
195
196			$options = new Options();
197			$options->setRawStringInputs( false );
198			$options->setLowercaseNames( false );
199			$options->setTrimNames( false );
200
201			$expected = [
202			'awesome' => true,
203			'howmuch' => 9001,
204			'float' => 9000.1,
205			'page' => 'Ohi there!',
206			'text' => 'some text',
207			'text1' => 'some text',
208			'text2' => 'some text',
209			];
210
211			return [ $params, $definitions, $options, $expected ];
212			}
213
214			/**
215			* Values with capitalization and preceding/tailing spaces to test
216			* of the clean options work.
217			*
218			* @return array
219			*/
220			private function getUncleanParams() {
221			$params = [
222			'awesome' => ' yes ',
223			'text' => ' FOO bar ',
224			'integerr' => ' 9001 ',
225			];
226
227			$definitions = [
228			'awesome' => [
229			'type' => 'boolean',
230			],
231			'text' => [
232			'default' => 'bar',
233			],
234			'integerr' => [
235			'type' => 'integer',
236			'default' => 42,
237			],
238			];
239
240			$options = new Options();
241			$options->setLowercaseValues( true );
242			$options->setTrimValues( true );
243
244			$expected = [
245			'awesome' => true,
246			'text' => 'foo bar',
247			'integerr' => 9001,
248			];
249
250			return [ $params, $definitions, $options, $expected ];
251			}
252
253			/**
254			* List parameters to test if list handling works correctly.
255			*
256			* @return array
257			*/
258			private function getListParams() {
259			$params = [
260			'awesome' => ' yes, no, on, off ',
261			'float' => ' 9001 ; 42 ; 4.2;0',
262			];
263
264			$definitions = [
265			'awesome' => [
266			'type' => 'boolean',
267			'islist' => true,
268			],
269			'text' => [
270			'default' => [ 'bar' ],
271			'islist' => true,
272			],
273			'float' => [
274			'type' => 'float',
275			'islist' => true,
276			'delimiter' => ';'
277			],
278			];
279
280			$options = new Options();
281			$options->setLowercaseValues( true );
282			$options->setTrimValues( true );
283
284			$expected = [
285			'awesome' => [ true, false, true, false ],
286			'text' => [ 'bar' ],
287			'float' => [ 9001.0, 42.0, 4.2, 0.0 ],
288			];
289
290			return [ $params, $definitions, $options, $expected ];
291			}
292
293			public function parameterProvider() {
294			// $params, $definitions [, $options]
295			$argLists = [];
296
297			$argLists[] = $this->getSimpleParams();
298
299			$argLists[] = $this->getDefaultingParams();
300
301			$argLists[] = $this->getTypedParams();
302
303			$argLists[] = $this->getUncleanParams();
304
305			$argLists[] = $this->getListParams();
306
307			foreach ( $argLists as &$argList ) {
308			foreach ( $argList[1] as $key => &$definition ) {
309			$definition['message'] = 'test-' . $key;
310			}
311
312			if ( !array_key_exists( 2, $argList ) ) {
313			$argList[2] = new Options();
314			}
315			}
316
317			return $argLists;
318			}
319
320			/**
321			* @dataProvider parameterProvider
322			*/
323			public function testSetParameters( array $params, array $definitions, Options $options ) {
324			$validator = Processor::newFromOptions( $options );
325
326			$validator->setParameters( $params, $definitions );
327
328			$this->assertTrue( true ); // TODO
329			}
330
331			/**
332			* @dataProvider parameterProvider
333			*/
334			public function testValidateParameters( array $params, array $definitions, Options $options, array $expected = [] ) {
335			$validator = Processor::newFromOptions( $options );
336
337			$validator->setParameters( $params, $definitions );
338
339			$processingResult = $validator->processParameters();
340
341			$actualValues = [];
342
343			foreach ( $processingResult->getParameters() as $param ) {
344			$actualValues[$param->getName()] = $param->getValue();
345			}
346
347			$this->assertEquals( $expected, $actualValues );
348
349
350			}
351
352			public function testProcessParametersOnEmptyOptions() {
353			$processor = Processor::newDefault();
354
355			$this->assertInstanceOf(
356			ProcessingResult::class,
357			$processor->processParameters()
358			);
359			}
360
361			public function testErrorsCanBeRetrievedAfterProcessing() {
362			$processor = Processor::newDefault();
363
364			$this->processWithOneError( $processor );
365
366			$this->assertCount( 1, $processor->getErrors() );
367			}
368
369			private function processWithOneError( Processor $processor ) {
370			$processor->setParameters(
371			[],
372			[
373			'awesome' => [
374			'type' => 'boolean',
375			'message' => 'test-awesome'
376			],
377			]
378			);
379
380			// There should be a single "missing required parameter" error.
381			$processor->processParameters();
382			}
383
384			public function testErrorsAreClearedBetweenProcessingRuns() {
385			$processor = Processor::newDefault();
386
387			$this->processWithOneError( $processor );
388			$processor->setParameters( [], [] );
389			$processor->processParameters();
390
391			$this->assertEmpty( $processor->getErrors() );
392			}
393
394			public function testInvalidListElementsAreOmitted() {
395			$processor = Processor::newDefault();
396
397			$processor->setFunctionParams(
398			[
399			'some-list=1,2,3, ,4,'
400			],
401			[
402			'some-list' => [
403			'type' => 'integer',
404			'message' => 'test',
405			'islist' => true
406			],
407			]
408			);
409
410			$this->assertSame(
411			[ 1, 2, 3, 4 ],
412			$processor->processParameters()->getParameters()['some-list']->getValue()
413			);
414			}
415
416			public function testListParametersAreNotDefaultedWhenSomeElementsAreInvalid() {
417			$processor = Processor::newDefault();
418
419			$processor->setFunctionParams(
420			[
421			'some-list=1,nan'
422			],
423			[
424			'some-list' => [
425			'type' => 'integer',
426			'message' => 'test',
427			'islist' => true,
428			'default' => []
429			],
430			]
431			);
432
433			$this->assertSame(
434			[ 1 ],
435			$processor->processParameters()->getParameters()['some-list']->getValue()
436			);
437			}
438
439			public function testListParametersAreDefaultedWhenAllElementsAreInvalid() {
440			$processor = Processor::newDefault();
441
442			$processor->setFunctionParams(
443			[
444			'some-list=such,nan'
445			],
446			[
447			'some-list' => [
448			'type' => 'integer',
449			'message' => 'test',
450			'islist' => true,
451			'default' => [ 42 ]
452			],
453			]
454			);
455
456			$this->assertSame(
457			[ 42 ],
458			$processor->processParameters()->getParameters()['some-list']->getValue()
459			);
460			}
461
462			public function testSetParameterDefinitions() {
463			$processor = Processor::newDefault();
464
465			$processor->setFunctionParams( [ 'some-list=42,23,9001' ] );
466
467			$processor->setParameterDefinitions(
468			[
469			( ParamDefinitionFactory::newDefault() )->newDefinitionFromArray(
470			[
471			'name' => 'some-list',
472			'type' => 'integer',
473			'message' => 'test',
474			'islist' => true
475			]
476			)
477			]
478			);
479
480			$this->assertSame(
481			[ 42, 23, 9001 ],
482			$processor->processParameters()->getParameters()['some-list']->getValue()
483			);
484			}
485
486			}
487

JeroenDeDauw / ParamProcessor

Push — master ( ebda25...4c5acd )

ProcessorTest::testSetParameters() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like