PropertyTest::testClone() - Code Metrics - Inspection of "Implement __clone to fully support deep cloning" - wmde/WikibaseDataModel - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — deepCloning ( b0de0a )

by no

created 2016-02-12 10:01 UTC

PropertyTest::testClone() B

↳ Parent: PropertyTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	32
Code Lines	24

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	32
rs	8.8571
nc	1
cc	1
eloc	24
nop	0

<?php

namespace Wikibase\DataModel\Tests\Entity;

use InvalidArgumentException;
use Wikibase\DataModel\Entity\Property;
use Wikibase\DataModel\Entity\PropertyId;
use Wikibase\DataModel\Snak\PropertyNoValueSnak;
use Wikibase\DataModel\Statement\Statement;
use Wikibase\DataModel\Statement\StatementList;
use Wikibase\DataModel\Term\Fingerprint;

/**
 * @covers Wikibase\DataModel\Entity\Property
 * @covers Wikibase\DataModel\Entity\Entity
 *
 * @group Wikibase
 * @group WikibaseProperty
 * @group WikibaseDataModel
 * @group PropertyTest
 *
 * @licence GNU GPL v2+
 * @author Jeroen De Dauw < [email protected] >
 */
class PropertyTest extends EntityTest {


	/**
	 * @see EntityTest::getNewEmpty
	 *
	 * @since 0.1
	 *
	 * @return Property
	 */
	protected function getNewEmpty() {
		return Property::newFromType( 'string' );
	}

	public function testConstructorWithAllParameters() {
		$property = new Property(
			new PropertyId( 'P42' ),
			new Fingerprint(),
			'string',
			new StatementList()
		);
		$this->assertInstanceOf( 'Wikibase\DataModel\Entity\Property', $property );
		$this->assertEquals( new PropertyId( 'P42' ), $property->getId() );
		$this->assertEquals( new Fingerprint(), $property->getFingerprint() );
		$this->assertEquals( 'string', $property->getDataTypeId() );
		$this->assertEquals( new StatementList(), $property->getStatements() );
	}

	public function testConstructorWithMinimalParameters() {
		$property = new Property( null, null, '' );
		$this->assertInstanceOf( 'Wikibase\DataModel\Entity\Property', $property );
		$this->assertNull( $property->getId() );
		$this->assertEquals( new Fingerprint(), $property->getFingerprint() );
		$this->assertEquals( '', $property->getDataTypeId() );
		$this->assertEquals( new StatementList(), $property->getStatements() );
	}

	/**
	 * @expectedException InvalidArgumentException
	 */
	public function testGivenInvalidType_ConstructorThrowsException() {
		new Property( null, null, null );
	}

	public function testNewFromType() {
		$property = Property::newFromType( 'string' );
		$this->assertInstanceOf( 'Wikibase\DataModel\Entity\Property', $property );
		$this->assertEquals( 'string', $property->getDataTypeId() );
	}

	public function testSetAndGetDataTypeId() {
		$property = Property::newFromType( 'string' );

		foreach ( array( 'string', 'foobar', 'nyan', 'string' ) as $typeId ) {
			$property->setDataTypeId( $typeId );
			$this->assertEquals( $typeId, $property->getDataTypeId() );
		}
	}

	public function testWhenIdSetWithNumber_GetIdReturnsPropertyId() {
		$property = Property::newFromType( 'string' );
		$property->setId( 42 );

		$this->assertHasCorrectIdType( $property );
	}

	protected function assertHasCorrectIdType( Property $property ) {
		$this->assertInstanceOf( 'Wikibase\DataModel\Entity\PropertyId', $property->getId() );
	}

	public function testWhenIdSetWithPropertyId_GetIdReturnsPropertyId() {
		$property = Property::newFromType( 'string' );
		$property->setId( new PropertyId( 'P42' ) );

		$this->assertHasCorrectIdType( $property );
	}

	public function testPropertyWithTypeIsEmpty() {
		$this->assertTrue( Property::newFromType( 'string' )->isEmpty() );
	}

	public function testPropertyWithIdIsEmpty() {
		$property = Property::newFromType( 'string' );
		$property->setId( 1337 );
		$this->assertTrue( $property->isEmpty() );
	}

	public function testPropertyWithFingerprintIsNotEmpty() {
		$property = Property::newFromType( 'string' );
		$property->getFingerprint()->setAliasGroup( 'en', array( 'foo' ) );
		$this->assertFalse( $property->isEmpty() );
	}

	public function testClearRemovesAllButId() {
		$property = Property::newFromType( 'string' );
		$property->setId( 42 );
		$property->getFingerprint()->setLabel( 'en', 'foo' );
		$property->getStatements()->addNewStatement( new PropertyNoValueSnak( 1 ) );

		$property->clear();

		$this->assertEquals( new PropertyId( 'P42' ), $property->getId() );
		$this->assertTrue( $property->isEmpty() );
	}

	public function testGetStatementsReturnsEmptyListForEmptyProperty() {
		$property = Property::newFromType( 'string' );

		$this->assertEquals( new StatementList(), $property->getStatements() );
	}

	public function testSetAndGetStatements() {
		$property = Property::newFromType( 'string' );

		$statementList = $this->newNonEmptyStatementList();
		$property->setStatements( $statementList );

		$this->assertEquals( $statementList, $property->getStatements() );
	}

	private function newNonEmptyStatementList() {
		$statementList = new StatementList();
		$statementList->addNewStatement( new PropertyNoValueSnak( 42 ) );
		$statementList->addNewStatement( new PropertyNoValueSnak( 1337 ) );

		return $statementList;
	}

	public function equalsProvider() {
		$firstProperty = Property::newFromType( 'string' );
		$firstProperty->setStatements( $this->newNonEmptyStatementList() );

		$secondProperty = Property::newFromType( 'string' );
		$secondProperty->setStatements( $this->newNonEmptyStatementList() );

		$secondPropertyWithId = clone $secondProperty;
		$secondPropertyWithId->setId( 42 );

		$differentId = clone $secondPropertyWithId;
		$differentId->setId( 43 );

		return array(
			array( Property::newFromType( 'string' ), Property::newFromType( 'string' ) ),
			array( $firstProperty, $secondProperty ),
			array( $secondProperty, $secondPropertyWithId ),
			array( $secondPropertyWithId, $differentId ),
		);
	}

	/**
	 * @dataProvider equalsProvider
	 */
	public function testEquals( Property $firstProperty, Property $secondProperty ) {
		$this->assertTrue( $firstProperty->equals( $secondProperty ) );
		$this->assertTrue( $secondProperty->equals( $firstProperty ) );
	}

	private function getBaseProperty() {
		$property = Property::newFromType( 'string' );

		$property->setId( 42 );
		$property->getFingerprint()->setLabel( 'en', 'Same' );
		$property->getFingerprint()->setDescription( 'en', 'Same' );
		$property->getFingerprint()->setAliasGroup( 'en', array( 'Same' ) );
		$property->setStatements( $this->newNonEmptyStatementList() );

		return $property;
	}

	public function notEqualsProvider() {
		$differentLabel = $this->getBaseProperty();
		$differentLabel->getFingerprint()->setLabel( 'en', 'Different' );

		$differentDescription = $this->getBaseProperty();
		$differentDescription->getFingerprint()->setDescription( 'en', 'Different' );

		$differentAlias = $this->getBaseProperty();
		$differentAlias->getFingerprint()->setAliasGroup( 'en', array( 'Different' ) );

		$differentStatement = $this->getBaseProperty();
		$differentStatement->setStatements( new StatementList() );

		$property = $this->getBaseProperty();

		return array(
			'empty' => array( $property, Property::newFromType( 'string' ) ),
			'label' => array( $property, $differentLabel ),
			'description' => array( $property, $differentDescription ),
			'alias' => array( $property, $differentAlias ),
			'dataType' => array( Property::newFromType( 'string' ), Property::newFromType( 'foo' ) ),
			'statement' => array( $property, $differentStatement ),
		);
	}

	/**
	 * @dataProvider notEqualsProvider
	 */
	public function testNotEquals( Property $firstProperty, Property $secondProperty ) {
		$this->assertFalse( $firstProperty->equals( $secondProperty ) );
		$this->assertFalse( $secondProperty->equals( $firstProperty ) );
	}

	public function testPropertyWithStatementsIsNotEmpty() {
		$property = Property::newFromType( 'string' );
		$property->setStatements( $this->newNonEmptyStatementList() );

		$this->assertFalse( $property->isEmpty() );
	}

	public function testClone() {
		$id = new PropertyId( 'P1' );
		$fingerprint = new Fingerprint();
		$fingerprint->setLabel( 'en', 'original' );
		$statement = new Statement( new PropertyNoValueSnak( 1 ) );
		$statements = new StatementList( $statement );
		$original = new Property( $id, $fingerprint, 'string', $statements );

		$clone = clone $original;

		// The clone must not reference the same mutable objects
		$this->assertSame( 'property', $clone->getType() );
		$this->assertSame( 'string', $clone->getDataTypeId() );
		$this->assertSame( $id, $clone->getId(), 'id is immutable and must not be cloned' );
		$this->assertNotSame( $fingerprint, $clone->getFingerprint() );
		$this->assertNotSame( $statements, $clone->getStatements() );
		$this->assertNotSame( $statement, $clone->getStatements()->toArray()[0] );

		// Modify the clone
		$clone->getFingerprint()->setLabel( 'en', 'clone' );
		$clonedStatement = $clone->getStatements()->toArray()[0];
		$clonedStatement->setRank( Statement::RANK_DEPRECATED );
		$clonedStatement->getQualifiers()->addSnak( new PropertyNoValueSnak( 1 ) );
		$clonedStatement->getReferences()->addNewReference( new PropertyNoValueSnak( 1 ) );

		// The original must not change
		$this->assertSame( 'original', $original->getFingerprint()->getLabel( 'en' )->getText() );
		$originalStatement = $original->getStatements()->toArray()[0];
		$this->assertSame( Statement::RANK_NORMAL, $originalStatement->getRank() );
		$this->assertTrue( $originalStatement->getQualifiers()->isEmpty() );
		$this->assertTrue( $originalStatement->getReferences()->isEmpty() );
	}

}


1			<?php
2
3			namespace Wikibase\DataModel\Tests\Entity;
4
5			use InvalidArgumentException;
6			use Wikibase\DataModel\Entity\Property;
7			use Wikibase\DataModel\Entity\PropertyId;
8			use Wikibase\DataModel\Snak\PropertyNoValueSnak;
9			use Wikibase\DataModel\Statement\Statement;
10			use Wikibase\DataModel\Statement\StatementList;
11			use Wikibase\DataModel\Term\Fingerprint;
12
13			/**
14			* @covers Wikibase\DataModel\Entity\Property
15			* @covers Wikibase\DataModel\Entity\Entity
16			*
17			* @group Wikibase
18			* @group WikibaseProperty
19			* @group WikibaseDataModel
20			* @group PropertyTest
21			*
22			* @licence GNU GPL v2+
23			* @author Jeroen De Dauw < [email protected] >
24			*/
25			class PropertyTest extends EntityTest {
			0 ignored issues – show Deprecated Code introduced 2015-11-27 17:36 UTC by Report Bug Copy Issue Report The class `Wikibase\DataModel\Tests\Entity\EntityTest` has been deprecated with message: This test class is to be phased out, and should not be used from outside of the component! This class, trait or interface has been deprecated. The supplier of the file has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the type will be removed from the class and what other constant to use instead. Loading history...
26
27			/**
28			* @see EntityTest::getNewEmpty
29			*
30			* @since 0.1
31			*
32			* @return Property
33			*/
34			protected function getNewEmpty() {
35			return Property::newFromType( 'string' );
36			}
37
38			public function testConstructorWithAllParameters() {
39			$property = new Property(
40			new PropertyId( 'P42' ),
41			new Fingerprint(),
42			'string',
43			new StatementList()
44			);
45			$this->assertInstanceOf( 'Wikibase\DataModel\Entity\Property', $property );
46			$this->assertEquals( new PropertyId( 'P42' ), $property->getId() );
47			$this->assertEquals( new Fingerprint(), $property->getFingerprint() );
48			$this->assertEquals( 'string', $property->getDataTypeId() );
49			$this->assertEquals( new StatementList(), $property->getStatements() );
50			}
51
52			public function testConstructorWithMinimalParameters() {
53			$property = new Property( null, null, '' );
54			$this->assertInstanceOf( 'Wikibase\DataModel\Entity\Property', $property );
55			$this->assertNull( $property->getId() );
56			$this->assertEquals( new Fingerprint(), $property->getFingerprint() );
57			$this->assertEquals( '', $property->getDataTypeId() );
58			$this->assertEquals( new StatementList(), $property->getStatements() );
59			}
60
61			/**
62			* @expectedException InvalidArgumentException
63			*/
64			public function testGivenInvalidType_ConstructorThrowsException() {
65			new Property( null, null, null );
66			}
67
68			public function testNewFromType() {
69			$property = Property::newFromType( 'string' );
70			$this->assertInstanceOf( 'Wikibase\DataModel\Entity\Property', $property );
71			$this->assertEquals( 'string', $property->getDataTypeId() );
72			}
73
74			public function testSetAndGetDataTypeId() {
75			$property = Property::newFromType( 'string' );
76
77			foreach ( array( 'string', 'foobar', 'nyan', 'string' ) as $typeId ) {
78			$property->setDataTypeId( $typeId );
79			$this->assertEquals( $typeId, $property->getDataTypeId() );
80			}
81			}
82
83			public function testWhenIdSetWithNumber_GetIdReturnsPropertyId() {
84			$property = Property::newFromType( 'string' );
85			$property->setId( 42 );
86
87			$this->assertHasCorrectIdType( $property );
88			}
89
90			protected function assertHasCorrectIdType( Property $property ) {
91			$this->assertInstanceOf( 'Wikibase\DataModel\Entity\PropertyId', $property->getId() );
92			}
93
94			public function testWhenIdSetWithPropertyId_GetIdReturnsPropertyId() {
95			$property = Property::newFromType( 'string' );
96			$property->setId( new PropertyId( 'P42' ) );
97
98			$this->assertHasCorrectIdType( $property );
99			}
100
101			public function testPropertyWithTypeIsEmpty() {
102			$this->assertTrue( Property::newFromType( 'string' )->isEmpty() );
103			}
104
105			public function testPropertyWithIdIsEmpty() {
106			$property = Property::newFromType( 'string' );
107			$property->setId( 1337 );
108			$this->assertTrue( $property->isEmpty() );
109			}
110
111			public function testPropertyWithFingerprintIsNotEmpty() {
112			$property = Property::newFromType( 'string' );
113			$property->getFingerprint()->setAliasGroup( 'en', array( 'foo' ) );
114			$this->assertFalse( $property->isEmpty() );
115			}
116
117			public function testClearRemovesAllButId() {
118			$property = Property::newFromType( 'string' );
119			$property->setId( 42 );
120			$property->getFingerprint()->setLabel( 'en', 'foo' );
121			$property->getStatements()->addNewStatement( new PropertyNoValueSnak( 1 ) );
122
123			$property->clear();
124
125			$this->assertEquals( new PropertyId( 'P42' ), $property->getId() );
126			$this->assertTrue( $property->isEmpty() );
127			}
128
129			public function testGetStatementsReturnsEmptyListForEmptyProperty() {
130			$property = Property::newFromType( 'string' );
131
132			$this->assertEquals( new StatementList(), $property->getStatements() );
133			}
134
135			public function testSetAndGetStatements() {
136			$property = Property::newFromType( 'string' );
137
138			$statementList = $this->newNonEmptyStatementList();
139			$property->setStatements( $statementList );
140
141			$this->assertEquals( $statementList, $property->getStatements() );
142			}
143
144			private function newNonEmptyStatementList() {
145			$statementList = new StatementList();
146			$statementList->addNewStatement( new PropertyNoValueSnak( 42 ) );
147			$statementList->addNewStatement( new PropertyNoValueSnak( 1337 ) );
148
149			return $statementList;
150			}
151
152			public function equalsProvider() {
153			$firstProperty = Property::newFromType( 'string' );
154			$firstProperty->setStatements( $this->newNonEmptyStatementList() );
155
156			$secondProperty = Property::newFromType( 'string' );
157			$secondProperty->setStatements( $this->newNonEmptyStatementList() );
158
159			$secondPropertyWithId = clone $secondProperty;
160			$secondPropertyWithId->setId( 42 );
161
162			$differentId = clone $secondPropertyWithId;
163			$differentId->setId( 43 );
164
165			return array(
166			array( Property::newFromType( 'string' ), Property::newFromType( 'string' ) ),
167			array( $firstProperty, $secondProperty ),
168			array( $secondProperty, $secondPropertyWithId ),
169			array( $secondPropertyWithId, $differentId ),
170			);
171			}
172
173			/**
174			* @dataProvider equalsProvider
175			*/
176			public function testEquals( Property $firstProperty, Property $secondProperty ) {
177			$this->assertTrue( $firstProperty->equals( $secondProperty ) );
178			$this->assertTrue( $secondProperty->equals( $firstProperty ) );
179			}
180
181			private function getBaseProperty() {
182			$property = Property::newFromType( 'string' );
183
184			$property->setId( 42 );
185			$property->getFingerprint()->setLabel( 'en', 'Same' );
186			$property->getFingerprint()->setDescription( 'en', 'Same' );
187			$property->getFingerprint()->setAliasGroup( 'en', array( 'Same' ) );
188			$property->setStatements( $this->newNonEmptyStatementList() );
189
190			return $property;
191			}
192
193			public function notEqualsProvider() {
194			$differentLabel = $this->getBaseProperty();
195			$differentLabel->getFingerprint()->setLabel( 'en', 'Different' );
196
197			$differentDescription = $this->getBaseProperty();
198			$differentDescription->getFingerprint()->setDescription( 'en', 'Different' );
199
200			$differentAlias = $this->getBaseProperty();
201			$differentAlias->getFingerprint()->setAliasGroup( 'en', array( 'Different' ) );
202
203			$differentStatement = $this->getBaseProperty();
204			$differentStatement->setStatements( new StatementList() );
205
206			$property = $this->getBaseProperty();
207
208			return array(
209			'empty' => array( $property, Property::newFromType( 'string' ) ),
210			'label' => array( $property, $differentLabel ),
211			'description' => array( $property, $differentDescription ),
212			'alias' => array( $property, $differentAlias ),
213			'dataType' => array( Property::newFromType( 'string' ), Property::newFromType( 'foo' ) ),
214			'statement' => array( $property, $differentStatement ),
215			);
216			}
217
218			/**
219			* @dataProvider notEqualsProvider
220			*/
221			public function testNotEquals( Property $firstProperty, Property $secondProperty ) {
222			$this->assertFalse( $firstProperty->equals( $secondProperty ) );
223			$this->assertFalse( $secondProperty->equals( $firstProperty ) );
224			}
225
226			public function testPropertyWithStatementsIsNotEmpty() {
227			$property = Property::newFromType( 'string' );
228			$property->setStatements( $this->newNonEmptyStatementList() );
229
230			$this->assertFalse( $property->isEmpty() );
231			}
232
233			public function testClone() {
234			$id = new PropertyId( 'P1' );
235			$fingerprint = new Fingerprint();
236			$fingerprint->setLabel( 'en', 'original' );
237			$statement = new Statement( new PropertyNoValueSnak( 1 ) );
238			$statements = new StatementList( $statement );
239			$original = new Property( $id, $fingerprint, 'string', $statements );
240
241			$clone = clone $original;
242
243			// The clone must not reference the same mutable objects
244			$this->assertSame( 'property', $clone->getType() );
245			$this->assertSame( 'string', $clone->getDataTypeId() );
246			$this->assertSame( $id, $clone->getId(), 'id is immutable and must not be cloned' );
247			$this->assertNotSame( $fingerprint, $clone->getFingerprint() );
248			$this->assertNotSame( $statements, $clone->getStatements() );
249			$this->assertNotSame( $statement, $clone->getStatements()->toArray()[0] );
250
251			// Modify the clone
252			$clone->getFingerprint()->setLabel( 'en', 'clone' );
253			$clonedStatement = $clone->getStatements()->toArray()[0];
254			$clonedStatement->setRank( Statement::RANK_DEPRECATED );
255			$clonedStatement->getQualifiers()->addSnak( new PropertyNoValueSnak( 1 ) );
256			$clonedStatement->getReferences()->addNewReference( new PropertyNoValueSnak( 1 ) );
257
258			// The original must not change
259			$this->assertSame( 'original', $original->getFingerprint()->getLabel( 'en' )->getText() );
260			$originalStatement = $original->getStatements()->toArray()[0];
261			$this->assertSame( Statement::RANK_NORMAL, $originalStatement->getRank() );
262			$this->assertTrue( $originalStatement->getQualifiers()->isEmpty() );
263			$this->assertTrue( $originalStatement->getReferences()->isEmpty() );
264			}
265
266			}
267

wmde / WikibaseDataModel

Push — deepCloning ( b0de0a )

PropertyTest::testClone() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like