DataTypes\Tests\Phpunit\DataTypeFactoryTest

Complexity

Total Complexity

10

Size/Duplication

Total Lines	88
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	testConstructor()	0	4	1
A	valueTypesProvider()	0	7	1
A	testConstructorThrowsException()	0	4	1
A	invalidConstructorArgumentProvider()	0	10	1
A	testGetTypeIds()	0	6	1
A	testGetType()	0	6	1
A	testGetUnknownType()	0	6	1
A	testGetTypes()	0	6	1
A	provideDataTypeBuilder()	0	9	1
A	testDataTypeBuilder()	0	8	1

<?php

namespace DataTypes\Tests\Phpunit;

use DataTypes\DataType;
use DataTypes\DataTypeFactory;
use InvalidArgumentException;
use OutOfBoundsException;
use PHPUnit_Framework_TestCase;

/**
 * @covers DataTypes\DataTypeFactory
 *
 * @group DataTypes
 *
 * @license GPL-2.0+
 * @author Jeroen De Dauw < jeroendedauw@gmail.com >
 * @author Daniel Kinzler
 * @author Thiemo Mättig
 */
class DataTypeFactoryTest extends PHPUnit_Framework_TestCase {

	/**
	 * @dataProvider valueTypesProvider
	 */
	public function testConstructor( array $valueTypes ) {
		$instance = new DataTypeFactory( $valueTypes );
		$this->assertInstanceOf( DataTypeFactory::class, $instance );
	}

	public function valueTypesProvider() {
		return [
			[ [] ],
			[ [ 'string' => 'string' ] ],
			[ [ 'customType' => 'customValueType' ] ],
		];
	}

	/**
	 * @dataProvider invalidConstructorArgumentProvider
	 */
	public function testConstructorThrowsException( array $argument ) {
		$this->setExpectedException( InvalidArgumentException::class );
		new DataTypeFactory( $argument );
	}

	public function invalidConstructorArgumentProvider() {
		return [
			[ [ 'string' => '' ] ],
			[ [ 'string' => 1 ] ],
			[ [ 'string' => new DataType( 'string', 'string' ) ] ],
			[ [ '' => 'string' ] ],
			[ [ 0 => 'string' ] ],
			[ [ 0 => new DataType( 'string', 'string' ) ] ],
		];
	}

	public function testGetTypeIds() {
		$instance = new DataTypeFactory( [ 'customType' => 'string' ] );

		$expected = [ 'customType' ];
		$this->assertSame( $expected, $instance->getTypeIds() );
	}

	public function testGetType() {
		$instance = new DataTypeFactory( [ 'customType' => 'string' ] );

		$expected = new DataType( 'customType', 'string' );
		$this->assertEquals( $expected, $instance->getType( 'customType' ) );
	}

	public function testGetUnknownType() {
		$instance = new DataTypeFactory( [] );

		$this->setExpectedException( OutOfBoundsException::class );
		$instance->getType( 'unknownTypeId' );
	}

	public function testGetTypes() {
		$instance = new DataTypeFactory( [ 'customType' => 'string' ] );

		$expected = [ 'customType' => new DataType( 'customType', 'string' ) ];
		$this->assertEquals( $expected, $instance->getTypes() );
	}

	public static function provideDataTypeBuilder() {
		return [
			[
				'data-type',
				[ 'data-type' => 'valuetype' ],
				'valuetype'
			],
		];
	}

	/**
	 * @dataProvider provideDataTypeBuilder
	 */
	public function testDataTypeBuilder( $id, $types, $expected ) {
		$factory = new DataTypeFactory( $types );

		$type = $factory->getType( $id );

		$this->assertEquals( $id, $type->getId() );
		$this->assertEquals( $expected, $type->getDataValueType() );
	}

}