Issues in StatementTest.php (master) - Issues in master - wmde/WikibaseDataModel - Measure and Improve Code Quality continuously with Scrutinizer

Issues (55)

Security Analysis no request data

Cross-Site Scripting

Cross-Site Scripting enables an attacker to inject code into the response of a web-request that is viewed by other users. It can for example be used to bypass access controls, or even to take over other users' accounts.

File Exposure

File Exposure allows an attacker to gain access to local files that he should not be able to access. These files can for example include database credentials, or other configuration files.

File Manipulation

File Manipulation enables an attacker to write custom data to files. This potentially leads to injection of arbitrary code on the server.

Object Injection

Object Injection enables an attacker to inject an object into PHP code, and can lead to arbitrary code execution, file exposure, or file manipulation attacks.

Code Injection

Code Injection enables an attacker to execute arbitrary code on the server.

Response Splitting

Response Splitting can be used to send arbitrary responses.

File Inclusion

File Inclusion enables an attacker to inject custom files into PHP's file loading mechanism, either explicitly passed to include, or for example via PHP's auto-loading mechanism.

Command Injection

Command Injection enables an attacker to inject a shell command that is execute with the privileges of the web-server. This can be used to expose sensitive data, or gain access of your server.

SQL Injection

SQL Injection enables an attacker to execute arbitrary SQL code on your database server gaining access to user data, or manipulating user data.

XPath Injection

XPath Injection enables an attacker to modify the parts of XML document that are read. If that XML document is for example used for authentication, this can lead to further vulnerabilities similar to SQL Injection.

LDAP Injection

LDAP Injection enables an attacker to inject LDAP statements potentially granting permission to run unauthorized queries, or modify content inside the LDAP tree.

Header Injection

Other Vulnerability

This category comprises other attack vectors such as manipulating the PHP runtime, loading custom extensions, freezing the runtime, or similar.

Regex Injection

Regex Injection enables an attacker to execute arbitrary code in your PHP process.

XML Injection

XML Injection enables an attacker to read files on your local filesystem including configuration files, or can be abused to freeze your web-server process.

Variable Injection

Variable Injection enables an attacker to overwrite program variables with custom data, and can lead to further vulnerabilities.

Unfortunately, the security analysis is currently not available for your project. If you are a non-commercial open-source project, please contact support to gain access.

tests/unit/Statement/StatementTest.php (1 issue)

Labels

Documentation 1

Severity

Minor 1

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php

namespace Wikibase\DataModel\Tests\Statement;

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

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

	public function testMinimalConstructor() {
		$mainSnak = new PropertyNoValueSnak( 1 );
		$statement = new Statement( $mainSnak );
		$this->assertTrue( $mainSnak->equals( $statement->getMainSnak() ) );
	}

	/**
	 * @dataProvider validConstructorArgumentsProvider
	 */
	public function testConstructorWithValidArguments(
		Snak $mainSnak,
		?SnakList $qualifiers,
		?ReferenceList $references,
		$guid
	) {
		$statement = new Statement( $mainSnak, $qualifiers, $references, $guid );
		$this->assertTrue( $statement->getMainSnak()->equals( $mainSnak ) );
		$this->assertTrue( $statement->getQualifiers()->equals( $qualifiers ?: new SnakList() ) );
		$this->assertTrue( $statement->getReferences()->equals( $references ?: new ReferenceList() ) );
		$this->assertSame( $guid, $statement->getGuid() );
	}

	public function validConstructorArgumentsProvider() {
		$snak = new PropertyNoValueSnak( 1 );
		$qualifiers = new SnakList( [ $snak ] );
		$references = new ReferenceList( [ new Reference( [ $snak ] ) ] );

		return [
			[ $snak, null, null, null ],
			[ $snak, null, null, 'guid' ],
			[ $snak, $qualifiers, $references, 'guid' ],
		];
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testSetGuid( Statement $statement ) {
		$statement->setGuid( 'foo-bar-baz' );
		$this->assertSame( 'foo-bar-baz', $statement->getGuid() );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetGuid( Statement $statement ) {
		$guid = $statement->getGuid();
		$this->assertTrue( $guid === null || is_string( $guid ) );
		$this->assertSame( $guid, $statement->getGuid() );

		$statement->setGuid( 'foobar' );
		$this->assertSame( 'foobar', $statement->getGuid() );
	}

	public function testHashStability() {
		$mainSnak = new PropertyNoValueSnak( new PropertyId( 'P42' ) );
		$statement = new Statement( $mainSnak );
		$this->assertSame( '50c73da6759fd31868fb0cc9c218969fa776f62c', $statement->getHash() );
	}

	public function testSetAndGetMainSnak() {
		$mainSnak = new PropertyNoValueSnak( new PropertyId( 'P42' ) );
		$statement = new Statement( $mainSnak );
		$this->assertSame( $mainSnak, $statement->getMainSnak() );
	}

	public function testSetAndGetQualifiers() {
		$qualifiers = new SnakList( [
			new PropertyValueSnak( new PropertyId( 'P42' ), new StringValue( 'a' ) )
		] );

		$statement = new Statement(
			new PropertyNoValueSnak( new PropertyId( 'P42' ) ),
			$qualifiers
		);

		$this->assertSame( $qualifiers, $statement->getQualifiers() );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testSerialize( Statement $statement ) {
		$copy = unserialize( serialize( $statement ) );

		$this->assertSame( $statement->getHash(), $copy->getHash(), 'Serialization roundtrip should not affect hash' );
	}

	public function testGuidDoesNotAffectHash() {
		$statement0 = new Statement( new PropertyNoValueSnak( 42 ) );
		$statement0->setGuid( 'statement0' );

		$statement1 = new Statement( new PropertyNoValueSnak( 42 ) );
		$statement1->setGuid( 'statement1' );

		$this->assertSame( $statement0->getHash(), $statement1->getHash() );
	}

	/**
	 * @dataProvider invalidGuidProvider
	 */
	public function testGivenInvalidGuid_constructorThrowsException( $guid ) {
		$this->expectException( InvalidArgumentException::class );
		new Statement( new PropertyNoValueSnak( 1 ), null, null, $guid );
	}

	/**
	 * @dataProvider invalidGuidProvider
	 */
	public function testGivenInvalidGuid_setGuidThrowsException( $guid ) {
		$this->expectException( InvalidArgumentException::class );
		$statement = new Statement( new PropertyNoValueSnak( 42 ) );
		$statement->setGuid( $guid );
	}

	public function invalidGuidProvider() {
		$snak = new PropertyNoValueSnak( 1 );

		return [
			[ false ],
			[ 1 ],
			[ $snak ],
			[ new Statement( $snak ) ],
		];
	}

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

		$propertyId = new PropertyId( 'P42' );
		$baseInstance = new Statement( new PropertyNoValueSnak( $propertyId ) );

		$instances[] = $baseInstance;

		$instance = clone $baseInstance;
		$instance->setRank( Statement::RANK_PREFERRED );

		$instances[] = $instance;

		$newInstance = clone $instance;

		$instances[] = $newInstance;

		$instance = clone $baseInstance;

		$instance->setReferences( new ReferenceList( [
			new Reference( [
				new PropertyValueSnak( new PropertyId( 'P1' ), new StringValue( 'a' ) )
			] )
		] ) );

		$instances[] = $instance;

		$argLists = [];

		foreach ( $instances as $instance ) {
			$argLists[] = [ $instance ];
		}

		return $argLists;
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetReferences( Statement $statement ) {
		$this->assertInstanceOf( ReferenceList::class, $statement->getReferences() );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testSetReferences( Statement $statement ) {
		$references = new ReferenceList( [
			new Reference( [
				new PropertyValueSnak( new PropertyId( 'P1' ), new StringValue( 'a' ) ),
			] )
		] );

		$statement->setReferences( $references );

		$this->assertSame( $references, $statement->getReferences() );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testAddNewReferenceWithVariableArgumentsSyntax( Statement $statement ) {
		$snak1 = new PropertyNoValueSnak( 256 );
		$snak2 = new PropertySomeValueSnak( 42 );
		$statement->addNewReference( $snak1, $snak2 );

		$expectedSnaks = [ $snak1, $snak2 ];
		$this->assertTrue( $statement->getReferences()->hasReference( new Reference( $expectedSnaks ) ) );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testAddNewReferenceWithAnArrayOfSnaks( Statement $statement ) {
		$snaks = [
			new PropertyNoValueSnak( 256 ),
			new PropertySomeValueSnak( 42 ),
		];
		$statement->addNewReference( $snaks );

		$this->assertTrue( $statement->getReferences()->hasReference( new Reference( $snaks ) ) );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetRank( Statement $statement ) {
		$rank = $statement->getRank();
		$this->assertIsInt( $rank );

		$ranks = [ Statement::RANK_DEPRECATED, Statement::RANK_NORMAL, Statement::RANK_PREFERRED ];
		$this->assertTrue( in_array( $rank, $ranks ), true );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testSetRank( Statement $statement ) {
		$statement->setRank( Statement::RANK_DEPRECATED );
		$this->assertSame( Statement::RANK_DEPRECATED, $statement->getRank() );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testSetInvalidRank( Statement $statement ) {
		$this->expectException( InvalidArgumentException::class );
		$statement->setRank( 9001 );
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetPropertyId( Statement $statement ) {
		$this->assertSame(
			$statement->getMainSnak()->getPropertyId(),
			$statement->getPropertyId()
		);
	}

	/**
	 * @dataProvider instanceProvider
	 */
	public function testGetAllSnaks( Statement $statement ) {
		$snaks = $statement->getAllSnaks();

		$c = count( $statement->getQualifiers() ) + 1;

		/* @var Reference $reference */
		foreach ( $statement->getReferences() as $reference ) {
			$c += count( $reference->getSnaks() );
		}

		$this->assertGreaterThanOrEqual( $c, count( $snaks ), 'At least one snak per Qualifier and Reference' );
	}

	public function testGivenNonStatement_equalsReturnsFalse() {
		$statement = new Statement( new PropertyNoValueSnak( 42 ) );

		$this->assertFalse( $statement->equals( null ) );
		$this->assertFalse( $statement->equals( 42 ) );
		$this->assertFalse( $statement->equals( new \stdClass() ) );
	}

	public function testGivenSameStatement_equalsReturnsTrue() {
		$statement = new Statement(
			new PropertyNoValueSnak( 42 ),
			new SnakList( [
				new PropertyNoValueSnak( 1337 ),
			] ),
			new ReferenceList( [
				new Reference( [ new PropertyNoValueSnak( 1337 ) ] ),
			] )
		);

		$statement->setGuid( 'kittens' );

		$this->assertTrue( $statement->equals( $statement ) );
		$this->assertTrue( $statement->equals( clone $statement ) );
	}

	public function testGivenStatementWithDifferentProperty_equalsReturnsFalse() {
		$statement = new Statement( new PropertyNoValueSnak( 42 ) );
		$this->assertFalse( $statement->equals( new Statement( new PropertyNoValueSnak( 43 ) ) ) );
	}

	public function testGivenStatementWithDifferentSnakType_equalsReturnsFalse() {
		$statement = new Statement( new PropertyNoValueSnak( 42 ) );
		$this->assertFalse( $statement->equals( new Statement( new PropertySomeValueSnak( 42 ) ) ) );
	}

	public function testStatementWithDifferentQualifiers_equalsReturnsFalse() {
		$statement = new Statement(
			new PropertyNoValueSnak( 42 ),
			new SnakList( [
				new PropertyNoValueSnak( 1337 ),
			] )
		);

		$differentStatement = new Statement(
			new PropertyNoValueSnak( 42 ),
			new SnakList( [
				new PropertyNoValueSnak( 32202 ),
			] )
		);

		$this->assertFalse( $statement->equals( $differentStatement ) );
	}

	public function testGivenStatementWithDifferentGuids_equalsReturnsFalse() {
		$statement = new Statement( new PropertyNoValueSnak( 42 ) );

		$differentStatement = new Statement( new PropertyNoValueSnak( 42 ) );
		$differentStatement->setGuid( 'kittens' );

		$this->assertFalse( $statement->equals( $differentStatement ) );
	}

	public function testStatementWithDifferentReferences_equalsReturnsFalse() {
		$statement = new Statement(
			new PropertyNoValueSnak( 42 ),
			new SnakList(),
			new ReferenceList( [
				new Reference( [ new PropertyNoValueSnak( 1337 ) ] ),
			] )
		);

		$differentStatement = new Statement(
			new PropertyNoValueSnak( 42 ),
			new SnakList(),
			new ReferenceList( [
				new Reference( [ new PropertyNoValueSnak( 32202 ) ] ),
			] )
		);

		$this->assertFalse( $statement->equals( $differentStatement ) );
	}

	public function testEquals() {
		$statement = $this->newStatement();
		$target = $this->newStatement();

		$this->assertTrue( $statement->equals( $target ) );
	}

	/**
	 * @dataProvider notEqualsProvider
	 */
	public function testNotEquals( Statement $statement, Statement $target, $message ) {
		$this->assertFalse( $statement->equals( $target ), $message );
	}

	public function notEqualsProvider() {
		$statement = $this->newStatement();

		$statementWithoutQualifiers = $this->newStatement();
		$statementWithoutQualifiers->setQualifiers( new SnakList() );

		$statementWithoutReferences = $this->newStatement();
		$statementWithoutReferences->setReferences( new ReferenceList() );

		$statementWithPreferredRank = $this->newStatement();
		$statementWithPreferredRank->setRank( Statement::RANK_PREFERRED );

		$statementMainSnakNotEqual = $this->newStatement();
		$statementMainSnakNotEqual->setMainSnak( new PropertyNoValueSnak( 9000 ) );

		return [
			[ $statement, $statementWithoutQualifiers, 'qualifiers not equal' ],
			[ $statement, $statementWithoutReferences, 'references not equal' ],
			[ $statement, $statementWithPreferredRank, 'rank not equal' ],
			[ $statement, $statementMainSnakNotEqual, 'main snak not equal' ]
		];
	}

	private function newStatement() {
		$qualifiers = new SnakList( [ new PropertyNoValueSnak( 23 ) ] );

		$statement = new Statement(
			new PropertyNoValueSnak( 42 ),
			$qualifiers,
			new ReferenceList( [
				new Reference( [ new PropertyNoValueSnak( 1337 ) ] ),
			] )
		);

		$statement->setRank( Statement::RANK_NORMAL );

		return $statement;
	}

	public function testHashesOfDifferentStatementsAreNotTheSame() {
		$this->assertNotSame(
			( new Statement( new PropertyNoValueSnak( 1 ) ) )->getHash(),
			( new Statement( new PropertyNoValueSnak( 2 ) ) )->getHash()
		);
	}

	public function testHashesOfEqualStatementsAreTheSame() {
		$this->assertSame(
			( new Statement( new PropertyNoValueSnak( 1 ) ) )->getHash(),
			( new Statement( new PropertyNoValueSnak( 1 ) ) )->getHash()
		);
	}

}


1			<?php
2
3			namespace Wikibase\DataModel\Tests\Statement;
4
5			use DataValues\StringValue;
6			use InvalidArgumentException;
7			use Wikibase\DataModel\Entity\PropertyId;
8			use Wikibase\DataModel\Reference;
9			use Wikibase\DataModel\ReferenceList;
10			use Wikibase\DataModel\Snak\PropertyNoValueSnak;
11			use Wikibase\DataModel\Snak\PropertySomeValueSnak;
12			use Wikibase\DataModel\Snak\PropertyValueSnak;
13			use Wikibase\DataModel\Snak\Snak;
14			use Wikibase\DataModel\Snak\SnakList;
15			use Wikibase\DataModel\Statement\Statement;
16
17			/**
18			* @covers \Wikibase\DataModel\Statement\Statement
19			*
20			* @group Wikibase
21			* @group WikibaseDataModel
22			*
23			* @license GPL-2.0-or-later
24			* @author Jeroen De Dauw < [email protected] >
25			*/
26			class StatementTest extends \PHPUnit\Framework\TestCase {
27
28			public function testMinimalConstructor() {
29			$mainSnak = new PropertyNoValueSnak( 1 );
30			$statement = new Statement( $mainSnak );
31			$this->assertTrue( $mainSnak->equals( $statement->getMainSnak() ) );
32			}
33
34			/**
35			* @dataProvider validConstructorArgumentsProvider
36			*/
37			public function testConstructorWithValidArguments(
38			Snak $mainSnak,
39			?SnakList $qualifiers,
40			?ReferenceList $references,
41			$guid
42			) {
43			$statement = new Statement( $mainSnak, $qualifiers, $references, $guid );
44			$this->assertTrue( $statement->getMainSnak()->equals( $mainSnak ) );
45			$this->assertTrue( $statement->getQualifiers()->equals( $qualifiers ?: new SnakList() ) );
46			$this->assertTrue( $statement->getReferences()->equals( $references ?: new ReferenceList() ) );
47			$this->assertSame( $guid, $statement->getGuid() );
48			}
49
50			public function validConstructorArgumentsProvider() {
51			$snak = new PropertyNoValueSnak( 1 );
52			$qualifiers = new SnakList( [ $snak ] );
53			$references = new ReferenceList( [ new Reference( [ $snak ] ) ] );
54
55			return [
56			[ $snak, null, null, null ],
57			[ $snak, null, null, 'guid' ],
58			[ $snak, $qualifiers, $references, 'guid' ],
59			];
60			}
61
62			/**
63			* @dataProvider instanceProvider
64			*/
65			public function testSetGuid( Statement $statement ) {
66			$statement->setGuid( 'foo-bar-baz' );
67			$this->assertSame( 'foo-bar-baz', $statement->getGuid() );
68			}
69
70			/**
71			* @dataProvider instanceProvider
72			*/
73			public function testGetGuid( Statement $statement ) {
74			$guid = $statement->getGuid();
75			$this->assertTrue( $guid === null \|\| is_string( $guid ) );
76			$this->assertSame( $guid, $statement->getGuid() );
77
78			$statement->setGuid( 'foobar' );
79			$this->assertSame( 'foobar', $statement->getGuid() );
80			}
81
82			public function testHashStability() {
83			$mainSnak = new PropertyNoValueSnak( new PropertyId( 'P42' ) );
84			$statement = new Statement( $mainSnak );
85			$this->assertSame( '50c73da6759fd31868fb0cc9c218969fa776f62c', $statement->getHash() );
86			}
87
88			public function testSetAndGetMainSnak() {
89			$mainSnak = new PropertyNoValueSnak( new PropertyId( 'P42' ) );
90			$statement = new Statement( $mainSnak );
91			$this->assertSame( $mainSnak, $statement->getMainSnak() );
92			}
93
94			public function testSetAndGetQualifiers() {
95			$qualifiers = new SnakList( [
96			new PropertyValueSnak( new PropertyId( 'P42' ), new StringValue( 'a' ) )
97			] );
98
99			$statement = new Statement(
100			new PropertyNoValueSnak( new PropertyId( 'P42' ) ),
101			$qualifiers
102			);
103
104			$this->assertSame( $qualifiers, $statement->getQualifiers() );
105			}
106
107			/**
108			* @dataProvider instanceProvider
109			*/
110			public function testSerialize( Statement $statement ) {
111			$copy = unserialize( serialize( $statement ) );
112
113			$this->assertSame( $statement->getHash(), $copy->getHash(), 'Serialization roundtrip should not affect hash' );
114			}
115
116			public function testGuidDoesNotAffectHash() {
117			$statement0 = new Statement( new PropertyNoValueSnak( 42 ) );
118			$statement0->setGuid( 'statement0' );
119
120			$statement1 = new Statement( new PropertyNoValueSnak( 42 ) );
121			$statement1->setGuid( 'statement1' );
122
123			$this->assertSame( $statement0->getHash(), $statement1->getHash() );
124			}
125
126			/**
127			* @dataProvider invalidGuidProvider
128			*/
129			public function testGivenInvalidGuid_constructorThrowsException( $guid ) {
130			$this->expectException( InvalidArgumentException::class );
131			new Statement( new PropertyNoValueSnak( 1 ), null, null, $guid );
132			}
133
134			/**
135			* @dataProvider invalidGuidProvider
136			*/
137			public function testGivenInvalidGuid_setGuidThrowsException( $guid ) {
138			$this->expectException( InvalidArgumentException::class );
139			$statement = new Statement( new PropertyNoValueSnak( 42 ) );
140			$statement->setGuid( $guid );
141			}
142
143			public function invalidGuidProvider() {
144			$snak = new PropertyNoValueSnak( 1 );
145
146			return [
147			[ false ],
148			[ 1 ],
149			[ $snak ],
150			[ new Statement( $snak ) ],
151			];
152			}
153
154			public function instanceProvider() {
155			$instances = [];
156
157			$propertyId = new PropertyId( 'P42' );
158			$baseInstance = new Statement( new PropertyNoValueSnak( $propertyId ) );
159
160			$instances[] = $baseInstance;
161
162			$instance = clone $baseInstance;
163			$instance->setRank( Statement::RANK_PREFERRED );
164
165			$instances[] = $instance;
166
167			$newInstance = clone $instance;
168
169			$instances[] = $newInstance;
170
171			$instance = clone $baseInstance;
172
173			$instance->setReferences( new ReferenceList( [
174			new Reference( [
175			new PropertyValueSnak( new PropertyId( 'P1' ), new StringValue( 'a' ) )
176			] )
177			] ) );
178
179			$instances[] = $instance;
180
181			$argLists = [];
182
183			foreach ( $instances as $instance ) {
184			$argLists[] = [ $instance ];
185			}
186
187			return $argLists;
188			}
189
190			/**
191			* @dataProvider instanceProvider
192			*/
193			public function testGetReferences( Statement $statement ) {
194			$this->assertInstanceOf( ReferenceList::class, $statement->getReferences() );
195			}
196
197			/**
198			* @dataProvider instanceProvider
199			*/
200			public function testSetReferences( Statement $statement ) {
201			$references = new ReferenceList( [
202			new Reference( [
203			new PropertyValueSnak( new PropertyId( 'P1' ), new StringValue( 'a' ) ),
204			] )
205			] );
206
207			$statement->setReferences( $references );
208
209			$this->assertSame( $references, $statement->getReferences() );
210			}
211
212			/**
213			* @dataProvider instanceProvider
214			*/
215			public function testAddNewReferenceWithVariableArgumentsSyntax( Statement $statement ) {
216			$snak1 = new PropertyNoValueSnak( 256 );
217			$snak2 = new PropertySomeValueSnak( 42 );
218			$statement->addNewReference( $snak1, $snak2 );
219
220			$expectedSnaks = [ $snak1, $snak2 ];
221			$this->assertTrue( $statement->getReferences()->hasReference( new Reference( $expectedSnaks ) ) );
222			}
223
224			/**
225			* @dataProvider instanceProvider
226			*/
227			public function testAddNewReferenceWithAnArrayOfSnaks( Statement $statement ) {
228			$snaks = [
229			new PropertyNoValueSnak( 256 ),
230			new PropertySomeValueSnak( 42 ),
231			];
232			$statement->addNewReference( $snaks );
233
234			$this->assertTrue( $statement->getReferences()->hasReference( new Reference( $snaks ) ) );
235			}
236
237			/**
238			* @dataProvider instanceProvider
239			*/
240			public function testGetRank( Statement $statement ) {
241			$rank = $statement->getRank();
242			$this->assertIsInt( $rank );
243
244			$ranks = [ Statement::RANK_DEPRECATED, Statement::RANK_NORMAL, Statement::RANK_PREFERRED ];
245			$this->assertTrue( in_array( $rank, $ranks ), true );
			0 ignored issues – show Documentation introduced 2020-01-24 17:07 UTC by Report Bug Copy Issue Report Show Similar Issues like this `true` is of type `boolean`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
246			}
247
248			/**
249			* @dataProvider instanceProvider
250			*/
251			public function testSetRank( Statement $statement ) {
252			$statement->setRank( Statement::RANK_DEPRECATED );
253			$this->assertSame( Statement::RANK_DEPRECATED, $statement->getRank() );
254			}
255
256			/**
257			* @dataProvider instanceProvider
258			*/
259			public function testSetInvalidRank( Statement $statement ) {
260			$this->expectException( InvalidArgumentException::class );
261			$statement->setRank( 9001 );
262			}
263
264			/**
265			* @dataProvider instanceProvider
266			*/
267			public function testGetPropertyId( Statement $statement ) {
268			$this->assertSame(
269			$statement->getMainSnak()->getPropertyId(),
270			$statement->getPropertyId()
271			);
272			}
273
274			/**
275			* @dataProvider instanceProvider
276			*/
277			public function testGetAllSnaks( Statement $statement ) {
278			$snaks = $statement->getAllSnaks();
279
280			$c = count( $statement->getQualifiers() ) + 1;
281
282			/* @var Reference $reference */
283			foreach ( $statement->getReferences() as $reference ) {
284			$c += count( $reference->getSnaks() );
285			}
286
287			$this->assertGreaterThanOrEqual( $c, count( $snaks ), 'At least one snak per Qualifier and Reference' );
288			}
289
290			public function testGivenNonStatement_equalsReturnsFalse() {
291			$statement = new Statement( new PropertyNoValueSnak( 42 ) );
292
293			$this->assertFalse( $statement->equals( null ) );
294			$this->assertFalse( $statement->equals( 42 ) );
295			$this->assertFalse( $statement->equals( new \stdClass() ) );
296			}
297
298			public function testGivenSameStatement_equalsReturnsTrue() {
299			$statement = new Statement(
300			new PropertyNoValueSnak( 42 ),
301			new SnakList( [
302			new PropertyNoValueSnak( 1337 ),
303			] ),
304			new ReferenceList( [
305			new Reference( [ new PropertyNoValueSnak( 1337 ) ] ),
306			] )
307			);
308
309			$statement->setGuid( 'kittens' );
310
311			$this->assertTrue( $statement->equals( $statement ) );
312			$this->assertTrue( $statement->equals( clone $statement ) );
313			}
314
315			public function testGivenStatementWithDifferentProperty_equalsReturnsFalse() {
316			$statement = new Statement( new PropertyNoValueSnak( 42 ) );
317			$this->assertFalse( $statement->equals( new Statement( new PropertyNoValueSnak( 43 ) ) ) );
318			}
319
320			public function testGivenStatementWithDifferentSnakType_equalsReturnsFalse() {
321			$statement = new Statement( new PropertyNoValueSnak( 42 ) );
322			$this->assertFalse( $statement->equals( new Statement( new PropertySomeValueSnak( 42 ) ) ) );
323			}
324
325			public function testStatementWithDifferentQualifiers_equalsReturnsFalse() {
326			$statement = new Statement(
327			new PropertyNoValueSnak( 42 ),
328			new SnakList( [
329			new PropertyNoValueSnak( 1337 ),
330			] )
331			);
332
333			$differentStatement = new Statement(
334			new PropertyNoValueSnak( 42 ),
335			new SnakList( [
336			new PropertyNoValueSnak( 32202 ),
337			] )
338			);
339
340			$this->assertFalse( $statement->equals( $differentStatement ) );
341			}
342
343			public function testGivenStatementWithDifferentGuids_equalsReturnsFalse() {
344			$statement = new Statement( new PropertyNoValueSnak( 42 ) );
345
346			$differentStatement = new Statement( new PropertyNoValueSnak( 42 ) );
347			$differentStatement->setGuid( 'kittens' );
348
349			$this->assertFalse( $statement->equals( $differentStatement ) );
350			}
351
352			public function testStatementWithDifferentReferences_equalsReturnsFalse() {
353			$statement = new Statement(
354			new PropertyNoValueSnak( 42 ),
355			new SnakList(),
356			new ReferenceList( [
357			new Reference( [ new PropertyNoValueSnak( 1337 ) ] ),
358			] )
359			);
360
361			$differentStatement = new Statement(
362			new PropertyNoValueSnak( 42 ),
363			new SnakList(),
364			new ReferenceList( [
365			new Reference( [ new PropertyNoValueSnak( 32202 ) ] ),
366			] )
367			);
368
369			$this->assertFalse( $statement->equals( $differentStatement ) );
370			}
371
372			public function testEquals() {
373			$statement = $this->newStatement();
374			$target = $this->newStatement();
375
376			$this->assertTrue( $statement->equals( $target ) );
377			}
378
379			/**
380			* @dataProvider notEqualsProvider
381			*/
382			public function testNotEquals( Statement $statement, Statement $target, $message ) {
383			$this->assertFalse( $statement->equals( $target ), $message );
384			}
385
386			public function notEqualsProvider() {
387			$statement = $this->newStatement();
388
389			$statementWithoutQualifiers = $this->newStatement();
390			$statementWithoutQualifiers->setQualifiers( new SnakList() );
391
392			$statementWithoutReferences = $this->newStatement();
393			$statementWithoutReferences->setReferences( new ReferenceList() );
394
395			$statementWithPreferredRank = $this->newStatement();
396			$statementWithPreferredRank->setRank( Statement::RANK_PREFERRED );
397
398			$statementMainSnakNotEqual = $this->newStatement();
399			$statementMainSnakNotEqual->setMainSnak( new PropertyNoValueSnak( 9000 ) );
400
401			return [
402			[ $statement, $statementWithoutQualifiers, 'qualifiers not equal' ],
403			[ $statement, $statementWithoutReferences, 'references not equal' ],
404			[ $statement, $statementWithPreferredRank, 'rank not equal' ],
405			[ $statement, $statementMainSnakNotEqual, 'main snak not equal' ]
406			];
407			}
408
409			private function newStatement() {
410			$qualifiers = new SnakList( [ new PropertyNoValueSnak( 23 ) ] );
411
412			$statement = new Statement(
413			new PropertyNoValueSnak( 42 ),
414			$qualifiers,
415			new ReferenceList( [
416			new Reference( [ new PropertyNoValueSnak( 1337 ) ] ),
417			] )
418			);
419
420			$statement->setRank( Statement::RANK_NORMAL );
421
422			return $statement;
423			}
424
425			public function testHashesOfDifferentStatementsAreNotTheSame() {
426			$this->assertNotSame(
427			( new Statement( new PropertyNoValueSnak( 1 ) ) )->getHash(),
428			( new Statement( new PropertyNoValueSnak( 2 ) ) )->getHash()
429			);
430			}
431
432			public function testHashesOfEqualStatementsAreTheSame() {
433			$this->assertSame(
434			( new Statement( new PropertyNoValueSnak( 1 ) ) )->getHash(),
435			( new Statement( new PropertyNoValueSnak( 1 ) ) )->getHash()
436			);
437			}
438
439			}
440

wmde / WikibaseDataModel

Issues (55)

Security Analysis no request data

tests/unit/Statement/StatementTest.php (1 issue)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like