ReferenceTest::testReferenceHashStability() - Code Metrics - Inspection of "Ensure hash stability" - wmde/WikibaseDataModel - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Push — master ( cd1faf...671641 )

by adam

created 2020-05-27 09:35 UTC

ReferenceTest::testReferenceHashStability() A

↳ Parent: ReferenceTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace Wikibase\DataModel\Tests;

use DataValues\StringValue;
use InvalidArgumentException;
use Wikibase\DataModel\Entity\PropertyId;
use Wikibase\DataModel\Reference;
use Wikibase\DataModel\Snak\PropertyNoValueSnak;
use Wikibase\DataModel\Snak\PropertySomeValueSnak;
use Wikibase\DataModel\Snak\PropertyValueSnak;
use Wikibase\DataModel\Snak\SnakList;

/**
 * @covers \Wikibase\DataModel\Reference
 *
 * @group Wikibase
 * @group WikibaseDataModel
 * @group WikibaseReference
 *
 * @license GPL-2.0-or-later
 * @author Jeroen De Dauw < [email protected] >
 */
class ReferenceTest extends \PHPUnit\Framework\TestCase {

	public function snakListProvider() {
		$snakLists = [];

		$snakLists[] = new SnakList();

		$snakLists[] = new SnakList(
			[ new PropertyValueSnak( new PropertyId( 'P1' ), new StringValue( 'a' ) ) ]
		);

		$snakLists[] = new SnakList( [
			new PropertyValueSnak( new PropertyId( 'P1' ), new StringValue( 'a' ) ),
			new PropertySomeValueSnak( new PropertyId( 'P2' ) ),
			new PropertyNoValueSnak( new PropertyId( 'P3' ) )
		] );

		$argLists = [];

		foreach ( $snakLists as $snakList ) {
			$argLists[] = [ $snakList ];
		}

		return $argLists;
	}

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

		$references[] = new Reference();

		$references[] = new Reference( [
			new PropertyValueSnak( new PropertyId( 'P1' ), new StringValue( 'a' ) ),
		] );

		$references[] = new Reference( [
			new PropertyValueSnak( new PropertyId( 'P1' ), new StringValue( 'a' ) ),
			new PropertySomeValueSnak( new PropertyId( 'P2' ) ),
		] );

		$argLists = [];

		foreach ( $references as $reference ) {
			$argLists[] = [ $reference ];
		}

		return $argLists;
	}

	/**
	 * @dataProvider snakListProvider
	 */
	public function testConstructor( SnakList $snaks ) {
		$omnomnomReference = new Reference( $snaks );

		$this->assertInstanceOf( Reference::class, $omnomnomReference );

		$this->assertEquals( $snaks, $omnomnomReference->getSnaks() );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetHashReturnsString( Reference $reference ) {
		$this->assertIsString( $reference->getHash() );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetHashIsStable( Reference $reference ) {
		$this->assertEquals( $reference->getHash(), $reference->getHash() );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetHashIsTheSameForInstanceWithSameValue( Reference $reference ) {
		$newRef = unserialize( serialize( $reference ) );
		$this->assertEquals( $newRef->getHash(), $reference->getHash() );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetSnaks( Reference $reference ) {
		$snaks = $reference->getSnaks();

		$this->assertInstanceOf( SnakList::class, $snaks );
	}

	/**
	 * Provides the same reference with its snak list in an unordered and in the ordered state as it
	 * would result from issuing SnakList::orderByProperty().
	 * @return array
	 */
	public function unorderedReferenceProvider() {
		$ids = [
			new PropertyId( 'P1' ),
			new PropertyId( 'P2' ),
			new PropertyId( 'P3' ),
			new PropertyId( 'P4' ),
		];

		$snakListArgs = [
			[
				new SnakList( [
					new PropertyValueSnak( $ids[0], new StringValue( 'a' ) ),
					new PropertyNoValueSnak( $ids[1] ),
					new PropertySomeValueSnak( $ids[0] ),
				] ),
				new SnakList( [
					new PropertyValueSnak( $ids[0], new StringValue( 'a' ) ),
					new PropertySomeValueSnak( $ids[0] ),
					new PropertyNoValueSnak( $ids[1] ),
				] )
			],
			[
				new SnakList( [
					new PropertyNoValueSnak( $ids[1] ),
					new PropertyNoValueSnak( $ids[0] ),
					new PropertySomeValueSnak( $ids[1] ),
					new PropertyNoValueSnak( $ids[2] ),
					new PropertySomeValueSnak( $ids[0] ),
					new PropertyNoValueSnak( $ids[3] ),
				] ),
				new SnakList( [
					new PropertyNoValueSnak( $ids[1] ),
					new PropertySomeValueSnak( $ids[1] ),
					new PropertyNoValueSnak( $ids[0] ),
					new PropertySomeValueSnak( $ids[0] ),
					new PropertyNoValueSnak( $ids[2] ),
					new PropertyNoValueSnak( $ids[3] ),
				] ),
			],
		];

		$args = [];

		foreach ( $snakListArgs as $snakLists ) {
			$args[] = [
				new Reference( $snakLists[0] ),
				new Reference( $snakLists[1] ),
			];
		}

		return $args;
	}

	/**
	 * @dataProvider unorderedReferenceProvider
	 */
	public function testUnorderedReference( Reference $unorderedReference, Reference $orderedReference ) {
		$this->assertEquals( $unorderedReference->getHash(), $orderedReference->getHash() );
	}

	public function testReferenceEqualsItself() {
		$reference = new Reference( [ new PropertyNoValueSnak( 42 ) ] );
		$this->assertTrue( $reference->equals( $reference ) );
	}

	public function testReferenceDoesNotEqualReferenceWithDifferentSnakProperty() {
		$reference0 = new Reference( [ new PropertyNoValueSnak( 42 ) ] );
		$reference1 = new Reference( [ new PropertyNoValueSnak( 1337 ) ] );
		$this->assertFalse( $reference0->equals( $reference1 ) );
	}

	public function testReferenceHashStability() {
		$reference = new Reference( [ new PropertyNoValueSnak( 42 ) ] );
		$this->assertSame( 'f2be45ba65676e69367433547812db03b8c661ef', $reference->getHash() );
	}

	public function testReferenceDoesNotEqualReferenceWithMoreSnaks() {
		$reference0 = new Reference( [ new PropertyNoValueSnak( 42 ) ] );

		$reference1 = new Reference( [
			new PropertyNoValueSnak( 42 ),
			new PropertySomeValueSnak( 42 ),
		] );

		$this->assertFalse( $reference0->equals( $reference1 ) );
	}

	public function testReferenceEqualsReferenceWithDifferentSnakOrder() {
		$reference0 = new Reference( [
			new PropertyNoValueSnak( 1337 ),
			new PropertyNoValueSnak( 42 ),
		] );

		$reference1 = new Reference( [
			new PropertyNoValueSnak( 42 ),
			new PropertyNoValueSnak( 1337 ),
		] );

		$this->assertTrue( $reference0->equals( $reference1 ) );
	}

	public function testReferencesWithDifferentSnakOrderHaveTheSameHash() {
		$reference0 = new Reference( [
			new PropertySomeValueSnak( 1337 ),
			new PropertyNoValueSnak( 1337 ),
			new PropertyNoValueSnak( 42 ),
		] );

		$reference1 = new Reference( [
			new PropertyNoValueSnak( 1337 ),
			new PropertyNoValueSnak( 42 ),
			new PropertySomeValueSnak( 1337 ),
		] );

		$this->assertSame( $reference0->getHash(), $reference1->getHash() );
	}

	public function testCanConstructWithSnakArray() {
		$snaks = [
			new PropertyNoValueSnak( 1 ),
			new PropertyNoValueSnak( 3 ),
			new PropertyNoValueSnak( 2 ),
		];

		$reference = new Reference( $snaks );

		$this->assertEquals(
			new SnakList( $snaks ),
			$reference->getSnaks()
		);
	}

	/**
	 * @dataProvider invalidConstructorArgumentsProvider
	 */
	public function testGivenInvalidConstructorArguments_constructorThrowsException( $snaks ) {
		$this->expectException( InvalidArgumentException::class );
		new Reference( $snaks );
	}

	public function invalidConstructorArgumentsProvider() {
		$id1 = new PropertyId( 'P1' );

		return [
			[ null ],
			[ false ],
			[ 1 ],
			[ 0.1 ],
			[ 'string' ],
			[ $id1 ],
			[ new PropertyNoValueSnak( $id1 ) ],
			[ new PropertyValueSnak( $id1, new StringValue( 'a' ) ) ],
			[ [ new SnakList() ] ],
			[ new Reference() ],
		];
	}

	public function testIsEmpty() {
		$emptyReference = new Reference();
		$this->assertTrue( $emptyReference->isEmpty() );

		$referenceWithSnak = new Reference( [
			new PropertyNoValueSnak( 1 ),
		] );
		$this->assertFalse( $referenceWithSnak->isEmpty() );

		$referenceWithSnaks = new Reference( [
			new PropertyNoValueSnak( 1 ),
			new PropertyNoValueSnak( 2 ),
		] );
		$this->assertFalse( $referenceWithSnaks->isEmpty() );
	}

}


1			<?php
2
3			namespace Wikibase\DataModel\Tests;
4
5			use DataValues\StringValue;
6			use InvalidArgumentException;
7			use Wikibase\DataModel\Entity\PropertyId;
8			use Wikibase\DataModel\Reference;
9			use Wikibase\DataModel\Snak\PropertyNoValueSnak;
10			use Wikibase\DataModel\Snak\PropertySomeValueSnak;
11			use Wikibase\DataModel\Snak\PropertyValueSnak;
12			use Wikibase\DataModel\Snak\SnakList;
13
14			/**
15			* @covers \Wikibase\DataModel\Reference
16			*
17			* @group Wikibase
18			* @group WikibaseDataModel
19			* @group WikibaseReference
20			*
21			* @license GPL-2.0-or-later
22			* @author Jeroen De Dauw < [email protected] >
23			*/
24			class ReferenceTest extends \PHPUnit\Framework\TestCase {
25
26			public function snakListProvider() {
27			$snakLists = [];
28
29			$snakLists[] = new SnakList();
30
31			$snakLists[] = new SnakList(
32			[ new PropertyValueSnak( new PropertyId( 'P1' ), new StringValue( 'a' ) ) ]
33			);
34
35			$snakLists[] = new SnakList( [
36			new PropertyValueSnak( new PropertyId( 'P1' ), new StringValue( 'a' ) ),
37			new PropertySomeValueSnak( new PropertyId( 'P2' ) ),
38			new PropertyNoValueSnak( new PropertyId( 'P3' ) )
39			] );
40
41			$argLists = [];
42
43			foreach ( $snakLists as $snakList ) {
44			$argLists[] = [ $snakList ];
45			}
46
47			return $argLists;
48			}
49
50			public function instanceProvider() {
51			$references = [];
52
53			$references[] = new Reference();
54
55			$references[] = new Reference( [
56			new PropertyValueSnak( new PropertyId( 'P1' ), new StringValue( 'a' ) ),
57			] );
58
59			$references[] = new Reference( [
60			new PropertyValueSnak( new PropertyId( 'P1' ), new StringValue( 'a' ) ),
61			new PropertySomeValueSnak( new PropertyId( 'P2' ) ),
62			] );
63
64			$argLists = [];
65
66			foreach ( $references as $reference ) {
67			$argLists[] = [ $reference ];
68			}
69
70			return $argLists;
71			}
72
73			/**
74			* @dataProvider snakListProvider
75			*/
76			public function testConstructor( SnakList $snaks ) {
77			$omnomnomReference = new Reference( $snaks );
78
79			$this->assertInstanceOf( Reference::class, $omnomnomReference );
80
81			$this->assertEquals( $snaks, $omnomnomReference->getSnaks() );
82			}
83
84			/**
85			* @dataProvider instanceProvider
86			*/
87			public function testGetHashReturnsString( Reference $reference ) {
88			$this->assertIsString( $reference->getHash() );
89			}
90
91			/**
92			* @dataProvider instanceProvider
93			*/
94			public function testGetHashIsStable( Reference $reference ) {
95			$this->assertEquals( $reference->getHash(), $reference->getHash() );
96			}
97
98			/**
99			* @dataProvider instanceProvider
100			*/
101			public function testGetHashIsTheSameForInstanceWithSameValue( Reference $reference ) {
102			$newRef = unserialize( serialize( $reference ) );
103			$this->assertEquals( $newRef->getHash(), $reference->getHash() );
104			}
105
106			/**
107			* @dataProvider instanceProvider
108			*/
109			public function testGetSnaks( Reference $reference ) {
110			$snaks = $reference->getSnaks();
111
112			$this->assertInstanceOf( SnakList::class, $snaks );
113			}
114
115			/**
116			* Provides the same reference with its snak list in an unordered and in the ordered state as it
117			* would result from issuing SnakList::orderByProperty().
118			* @return array
119			*/
120			public function unorderedReferenceProvider() {
121			$ids = [
122			new PropertyId( 'P1' ),
123			new PropertyId( 'P2' ),
124			new PropertyId( 'P3' ),
125			new PropertyId( 'P4' ),
126			];
127
128			$snakListArgs = [
129			[
130			new SnakList( [
131			new PropertyValueSnak( $ids[0], new StringValue( 'a' ) ),
132			new PropertyNoValueSnak( $ids[1] ),
133			new PropertySomeValueSnak( $ids[0] ),
134			] ),
135			new SnakList( [
136			new PropertyValueSnak( $ids[0], new StringValue( 'a' ) ),
137			new PropertySomeValueSnak( $ids[0] ),
138			new PropertyNoValueSnak( $ids[1] ),
139			] )
140			],
141			[
142			new SnakList( [
143			new PropertyNoValueSnak( $ids[1] ),
144			new PropertyNoValueSnak( $ids[0] ),
145			new PropertySomeValueSnak( $ids[1] ),
146			new PropertyNoValueSnak( $ids[2] ),
147			new PropertySomeValueSnak( $ids[0] ),
148			new PropertyNoValueSnak( $ids[3] ),
149			] ),
150			new SnakList( [
151			new PropertyNoValueSnak( $ids[1] ),
152			new PropertySomeValueSnak( $ids[1] ),
153			new PropertyNoValueSnak( $ids[0] ),
154			new PropertySomeValueSnak( $ids[0] ),
155			new PropertyNoValueSnak( $ids[2] ),
156			new PropertyNoValueSnak( $ids[3] ),
157			] ),
158			],
159			];
160
161			$args = [];
162
163			foreach ( $snakListArgs as $snakLists ) {
164			$args[] = [
165			new Reference( $snakLists[0] ),
166			new Reference( $snakLists[1] ),
167			];
168			}
169
170			return $args;
171			}
172
173			/**
174			* @dataProvider unorderedReferenceProvider
175			*/
176			public function testUnorderedReference( Reference $unorderedReference, Reference $orderedReference ) {
177			$this->assertEquals( $unorderedReference->getHash(), $orderedReference->getHash() );
178			}
179
180			public function testReferenceEqualsItself() {
181			$reference = new Reference( [ new PropertyNoValueSnak( 42 ) ] );
182			$this->assertTrue( $reference->equals( $reference ) );
183			}
184
185			public function testReferenceDoesNotEqualReferenceWithDifferentSnakProperty() {
186			$reference0 = new Reference( [ new PropertyNoValueSnak( 42 ) ] );
187			$reference1 = new Reference( [ new PropertyNoValueSnak( 1337 ) ] );
188			$this->assertFalse( $reference0->equals( $reference1 ) );
189			}
190
191			public function testReferenceHashStability() {
192			$reference = new Reference( [ new PropertyNoValueSnak( 42 ) ] );
193			$this->assertSame( 'f2be45ba65676e69367433547812db03b8c661ef', $reference->getHash() );
194			}
195
196			public function testReferenceDoesNotEqualReferenceWithMoreSnaks() {
197			$reference0 = new Reference( [ new PropertyNoValueSnak( 42 ) ] );
198
199			$reference1 = new Reference( [
200			new PropertyNoValueSnak( 42 ),
201			new PropertySomeValueSnak( 42 ),
202			] );
203
204			$this->assertFalse( $reference0->equals( $reference1 ) );
205			}
206
207			public function testReferenceEqualsReferenceWithDifferentSnakOrder() {
208			$reference0 = new Reference( [
209			new PropertyNoValueSnak( 1337 ),
210			new PropertyNoValueSnak( 42 ),
211			] );
212
213			$reference1 = new Reference( [
214			new PropertyNoValueSnak( 42 ),
215			new PropertyNoValueSnak( 1337 ),
216			] );
217
218			$this->assertTrue( $reference0->equals( $reference1 ) );
219			}
220
221			public function testReferencesWithDifferentSnakOrderHaveTheSameHash() {
222			$reference0 = new Reference( [
223			new PropertySomeValueSnak( 1337 ),
224			new PropertyNoValueSnak( 1337 ),
225			new PropertyNoValueSnak( 42 ),
226			] );
227
228			$reference1 = new Reference( [
229			new PropertyNoValueSnak( 1337 ),
230			new PropertyNoValueSnak( 42 ),
231			new PropertySomeValueSnak( 1337 ),
232			] );
233
234			$this->assertSame( $reference0->getHash(), $reference1->getHash() );
235			}
236
237			public function testCanConstructWithSnakArray() {
238			$snaks = [
239			new PropertyNoValueSnak( 1 ),
240			new PropertyNoValueSnak( 3 ),
241			new PropertyNoValueSnak( 2 ),
242			];
243
244			$reference = new Reference( $snaks );
245
246			$this->assertEquals(
247			new SnakList( $snaks ),
248			$reference->getSnaks()
249			);
250			}
251
252			/**
253			* @dataProvider invalidConstructorArgumentsProvider
254			*/
255			public function testGivenInvalidConstructorArguments_constructorThrowsException( $snaks ) {
256			$this->expectException( InvalidArgumentException::class );
257			new Reference( $snaks );
258			}
259
260			public function invalidConstructorArgumentsProvider() {
261			$id1 = new PropertyId( 'P1' );
262
263			return [
264			[ null ],
265			[ false ],
266			[ 1 ],
267			[ 0.1 ],
268			[ 'string' ],
269			[ $id1 ],
270			[ new PropertyNoValueSnak( $id1 ) ],
271			[ new PropertyValueSnak( $id1, new StringValue( 'a' ) ) ],
272			[ [ new SnakList() ] ],
273			[ new Reference() ],
274			];
275			}
276
277			public function testIsEmpty() {
278			$emptyReference = new Reference();
279			$this->assertTrue( $emptyReference->isEmpty() );
280
281			$referenceWithSnak = new Reference( [
282			new PropertyNoValueSnak( 1 ),
283			] );
284			$this->assertFalse( $referenceWithSnak->isEmpty() );
285
286			$referenceWithSnaks = new Reference( [
287			new PropertyNoValueSnak( 1 ),
288			new PropertyNoValueSnak( 2 ),
289			] );
290			$this->assertFalse( $referenceWithSnaks->isEmpty() );
291			}
292
293			}
294

wmde / WikibaseDataModel

Push — master ( cd1faf...671641 )

ReferenceTest::testReferenceHashStability() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like