Wikibase\DataModel\Services\Tests\Statement\Grouper\FilteringStatementGrouperTest

Complexity

Total Complexity

10

Size/Duplication

Total Lines	116
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes	4
Bugs	1	Features	2

10 Methods

Rating	Name	Duplication	Size	Complexity
A	newStatementFilter()	0	11	1
A	testConstructorThrowsException()	0	4	1
A	testDoesNotAcceptTwoDefaults()	0	4	1
A	testDefaultGroupIsAlwaysThere()	0	6	1
A	testCanOverrideDefaultGroup()	0	9	1
A	testAllGroupsAreAlwaysThere()	0	8	1
A	testDefaultGroupIsLast()	0	11	1
A	testCanOverrideDefaultGroupPosition()	0	12	1
A	testCanRepurposeDefaultGroup()	0	13	1
B	testGroupStatements()	0	25	1

<?php

namespace Wikibase\DataModel\Services\Tests\Statement\Grouper;

use PHPUnit_Framework_TestCase;
use Wikibase\DataModel\Services\Statement\Grouper\FilteringStatementGrouper;
use Wikibase\DataModel\Snak\PropertyNoValueSnak;
use Wikibase\DataModel\Statement\Statement;
use Wikibase\DataModel\Statement\StatementList;

/**
 * @covers Wikibase\DataModel\Services\Statement\Grouper\FilteringStatementGrouper
 *
 * @licence GNU GPL v2+
 * @author Thiemo Mättig
 */
class FilteringStatementGrouperTest extends PHPUnit_Framework_TestCase {

	private function newStatementFilter( $propertyId = 'P1' ) {
		$filter = $this->getMock( 'Wikibase\DataModel\Statement\StatementFilter' );

		$filter->expects( $this->any() )
			->method( 'statementMatches' )
			->will( $this->returnCallback( function( Statement $statement ) use ( $propertyId ) {
				return $statement->getPropertyId()->getSerialization() === $propertyId;
			} ) );

		return $filter;
	}

	public function testConstructorThrowsException() {
		$this->setExpectedException( 'InvalidArgumentException' );
		new FilteringStatementGrouper( array( 'invalid' ) );
	}

	public function testDoesNotAcceptTwoDefaults() {
		$this->setExpectedException( 'InvalidArgumentException' );
		new FilteringStatementGrouper( array( 'default1' => null, 'default2' => null ) );
	}

	public function testDefaultGroupIsAlwaysThere() {
		$grouper = new FilteringStatementGrouper( array() );
		$groups = $grouper->groupStatements( new StatementList() );

		$this->assertArrayHasKey( 'statements', $groups );
	}

	public function testCanOverrideDefaultGroup() {
		$grouper = new FilteringStatementGrouper( array(
			'default' => null,
		) );
		$groups = $grouper->groupStatements( new StatementList() );

		$this->assertArrayHasKey( 'default', $groups );
		$this->assertArrayNotHasKey( 'statements', $groups );
	}

	public function testAllGroupsAreAlwaysThere() {
		$grouper = new FilteringStatementGrouper( array(
			'p1' => $this->newStatementFilter(),
		) );
		$groups = $grouper->groupStatements( new StatementList() );

		$this->assertArrayHasKey( 'p1', $groups );
	}

	public function testDefaultGroupIsLast() {
		$statements = new StatementList();
		$statements->addNewStatement( new PropertyNoValueSnak( 1 ) );

		$grouper = new FilteringStatementGrouper( array(
			'p1' => $this->newStatementFilter(),
		) );
		$groups = $grouper->groupStatements( $statements );

		$this->assertSame( array( 'p1', 'statements' ), array_keys( $groups ) );
	}

	public function testCanOverrideDefaultGroupPosition() {
		$statements = new StatementList();
		$statements->addNewStatement( new PropertyNoValueSnak( 1 ) );

		$grouper = new FilteringStatementGrouper( array(
			'statements' => null,
			'p1' => $this->newStatementFilter(),
		) );
		$groups = $grouper->groupStatements( $statements );

		$this->assertSame( array( 'statements', 'p1' ), array_keys( $groups ) );
	}

	public function testCanRepurposeDefaultGroup() {
		$statements = new StatementList();
		$statements->addNewStatement( new PropertyNoValueSnak( 1 ) );

		$grouper = new FilteringStatementGrouper( array(
			'statements' => $this->newStatementFilter(),
		) );
		$groups = $grouper->groupStatements( $statements );

		$this->assertCount( 1, $groups );
		$this->assertArrayHasKey( 'statements', $groups );
		$this->assertCount( 1, $groups['statements'] );
	}

	public function testGroupStatements() {
		$statement1 = new Statement( new PropertyNoValueSnak( 1 ) );
		$statement2 = new Statement( new PropertyNoValueSnak( 2 ) );
		$statement3 = new Statement( new PropertyNoValueSnak( 1 ) );
		$statements = new StatementList( $statement1, $statement2, $statement3 );

		$grouper = new FilteringStatementGrouper( array(
			'p1' => $this->newStatementFilter( 'P1' ),
			'p2' => $this->newStatementFilter( 'P2' ),
			'p3' => $this->newStatementFilter( 'P3' ),
		) );

		$expected = array(
			'p1' => new StatementList( $statement1, $statement3 ),
			'p2' => new StatementList( $statement2 ),
			'p3' => new StatementList(),
			'statements' => new StatementList(),
		);

		$groups = $grouper->groupStatements( $statements );
		$this->assertEquals( $expected, $groups, 'first call' );

		$groups = $grouper->groupStatements( $statements );
		$this->assertEquals( $expected, $groups, 'second call' );
	}

}