ParamProcessor\Tests\Unit\Definitions\ParamDefinitionTest

Complexity

Total Complexity

19

Size/Duplication

Total Lines	151
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
	valueProvider()	0	1	?
	getType()	0	1	?
A	getDefinitions()	0	11	1
A	definitionProvider()	0	9	2
A	getEmptyInstance()	0	7	1
A	instanceProvider()	0	14	3
A	testGetType()	0	3	1
A	testValidate()	0	24	4
A	testFormat()	0	25	4
A	validate()	0	12	2
A	testConstructingWithoutMessageLeadsToDefaultMessage()	0	6	1

<?php

namespace ParamProcessor\Tests\Unit\Definitions;

use ParamProcessor\IParamDefinition;
use ParamProcessor\Options;
use ParamProcessor\PackagePrivate\Param;
use ParamProcessor\ParamDefinition;
use ParamProcessor\ParamDefinitionFactory;
use PHPUnit\Framework\TestCase;

/**
 * @licence GNU GPL v2+
 * @author Jeroen De Dauw < jeroendedauw@gmail.com >
 */
abstract class ParamDefinitionTest extends TestCase {

	/**
	 * Returns a list of arrays that hold values to test handling of.
	 * Each array holds the following unnamed elements:
	 * - value (mixed, required)
	 * - valid (boolean, required)
	 * - expected (mixed, optional)
	 *
	 * ie array( '42', true, 42 )
	 *
	 * @since 0.1
	 *
	 * @param boolean $stringlyTyped
	 *
	 * @return array
	 */
	public abstract function valueProvider( $stringlyTyped = true );

	public abstract function getType();

	public function getDefinitions() {
		$params = [];

		$params['empty'] = [];

		$params['values'] = [
			'values' => [ 'foo', '1', '0.1', 'yes', 1, 0.1 ]
		];

		return $params;
	}

	public function definitionProvider() {
		$definitions = $this->getDefinitions();

		foreach ( $definitions as &$definition ) {
			$definition['type'] = $this->getType();
		}

		return $definitions;
	}

	public function getEmptyInstance() {
		return ParamDefinitionFactory::singleton()->newDefinitionFromArray( [

The method ParamProcessor\ParamDefinitionFactory::singleton() has been deprecated with message: since 1.0

			'name' => 'empty',
			'message' => 'test-empty',
			'type' => $this->getType(),
		] );
	}

	public function instanceProvider() {
		$definitions = [];

		foreach ( $this->definitionProvider() as $name => $definition ) {
			if ( !array_key_exists( 'message', $definition ) ) {
				$definition['message'] = 'test-' . $name;
			}

			$definition['name'] = $name;
			$definitions[] = [ ParamDefinitionFactory::singleton()->newDefinitionFromArray( $definition ) ];

The method ParamProcessor\ParamDefinitionFactory::singleton() has been deprecated with message: since 1.0

		}

		return $definitions;
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetType( IParamDefinition $definition ) {
		$this->assertEquals( $this->getType(), $definition->getType() );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testValidate( IParamDefinition $definition ) {
		foreach ( [ true, false ] as $stringlyTyped ) {
			$values = $this->valueProvider( $stringlyTyped );
			$options = new Options();
			$options->setRawStringInputs( $stringlyTyped );

			foreach ( $values[$definition->getName()] as $data ) {
				list( $input, $valid, ) = $data;

				$param = new Param( $definition );
				$param->setUserValue( $definition->getName(), $input, $options );
				$definitions = [];
				$param->process( $definitions, [], $options );

				$this->assertEquals(
					$valid,
					$param->getErrors() === [],
					'The validation process should ' . ( $valid ? '' : 'not ' ) . 'pass'
				);
			}
		}

		$this->assertTrue( true );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testFormat( IParamDefinition $sourceDefinition ) {
		$values = $this->valueProvider();
		$options = new Options();

		foreach ( $values[$sourceDefinition->getName()] as $data ) {
			$definition = clone $sourceDefinition;

			list( $input, $valid, ) = $data;

			$param = new Param( $definition );
			$param->setUserValue( $definition->getName(), $input, $options );

			if ( $valid && array_key_exists( 2, $data ) ) {
				$defs = [];
				$param->process( $defs, [], $options );

				$this->assertEquals(
					$data[2],
					$param->getValue()
				);
			}
		}

		$this->assertTrue( true );
	}

	protected function validate( ParamDefinition $definition, $testValue, $validity, Options $options = null ) {
		$def = clone $definition;
		$options = $options === null ? new Options() : $options;

		$param = new Param( $def );
		$param->setUserValue( $def->getName(), $testValue, $options );

		$defs = [];
		$param->process( $defs, [], $options );

		$this->assertEquals( $validity, $param->getErrors() === [] );
	}

	public function testConstructingWithoutMessageLeadsToDefaultMessage() {
		$this->assertSame(
			'validator-message-nodesc',
			( new ParamDefinition( 'type', 'name' ) )->getMessage()
		);
	}

}