StatementListPatcherTest::patchStatementListProvider() - Code Metrics - wmde/WikibaseDataModelServices - Measure and Improve Code Quality continuously with Scrutinizer

patchStatementListProvider() B
last analyzed 2021-06-01 10:00 UTC

↳ Parent: StatementListPatcherTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	69
rs	8.6763
c	0
b	0
f	0
cc	1
nc	1
nop	0

How to fix Long Method

<?php

namespace Wikibase\DataModel\Services\Tests\Diff;

use DataValues\StringValue;
use Diff\DiffOp\Diff\Diff;
use Diff\DiffOp\DiffOpAdd;
use Diff\DiffOp\DiffOpChange;
use Diff\DiffOp\DiffOpRemove;
use PHPUnit\Framework\TestCase;
use Wikibase\DataModel\Services\Diff\StatementListPatcher;
use Wikibase\DataModel\Snak\PropertyNoValueSnak;
use Wikibase\DataModel\Snak\PropertySomeValueSnak;
use Wikibase\DataModel\Snak\PropertyValueSnak;
use Wikibase\DataModel\Statement\Statement;
use Wikibase\DataModel\Statement\StatementList;

/**
 * @covers \Wikibase\DataModel\Services\Diff\StatementListPatcher
 *
 * @license GPL-2.0-or-later
 * @author Jeroen De Dauw < [email protected] >
 * @author Thiemo Kreuz
 */
class StatementListPatcherTest extends TestCase {

	public function patchStatementListProvider() {
		$statement1 = new Statement( new PropertyNoValueSnak( 1 ) );
		$statement2 = new Statement( new PropertyNoValueSnak( 2 ) );

		return [
			// Empty diffs
			[
				new StatementList(),
				new Diff(),
				new StatementList()
			],
			[
				new StatementList( $statement1 ),
				new Diff(),
				new StatementList( $statement1 )
			],

			// Add operations
			[
				new StatementList(),
				new Diff( [ new DiffOpAdd( $statement1 ) ], true ),
				new StatementList( $statement1 )
			],
			[
				new StatementList(),
				new Diff( [ new DiffOpAdd( $statement1 ) ], false ),
				new StatementList( $statement1 )
			],
			[
				new StatementList(),
				new Diff( [ new DiffOpAdd( $statement1 ) ] ),
				new StatementList( $statement1 )
			],

			// Remove operations
			[
				new StatementList( $statement1 ),
				new Diff( [ new DiffOpRemove( $statement1 ) ], true ),
				new StatementList()
			],
			[
				new StatementList( $statement1 ),
				new Diff( [ new DiffOpRemove( $statement1 ) ], false ),
				new StatementList()
			],
			[
				new StatementList( $statement1 ),
				new Diff( [ new DiffOpRemove( $statement1 ) ] ),
				new StatementList()
			],

			// Mixed operations
			[
				new StatementList( $statement1 ),
				new Diff( [
					new DiffOpRemove( $statement1 ),
					new DiffOpAdd( $statement2 ),
				] ),
				new StatementList( $statement2 )
			],
			[
				new StatementList( $statement1 ),
				new Diff( [
					new DiffOpChange( $statement1, $statement2 ),
				] ),
				new StatementList( $statement2 )
			],
		];
	}

	/**
	 * @dataProvider patchStatementListProvider
	 */
	public function testPatchStatementList(
		StatementList $statements,
		Diff $patch,
		StatementList $expected
	) {
		$patcher = new StatementListPatcher();
		$patcher->patchStatementList( $statements, $patch );
		$this->assertEquals( $expected, $statements );
	}

	/**
	 * @SuppressWarnings(PHPMD.ExcessiveMethodLength)
	 */
	public function statementOrderProvider() {
		$statement1 = new Statement( new PropertyNoValueSnak( 1 ), null, null, 's1' );
		$statement2 = new Statement( new PropertyNoValueSnak( 2 ), null, null, 's2' );
		$statement3 = new Statement( new PropertyNoValueSnak( 3 ), null, null, 's3' );

		return [
			'Simple associative add' => [
				new StatementList(),
				new Diff( [
					's1' => new DiffOpAdd( $statement1 ),
				], true ),
				[ 's1' ]
			],
			'Simple non-associative add' => [
				new StatementList(),
				new Diff( [
					's1' => new DiffOpAdd( $statement1 ),
				], false ),
				[ 's1' ]
			],
			'Simple associative remove' => [
				new StatementList( $statement1 ),
				new Diff( [
					's1' => new DiffOpRemove( $statement1 ),
				], true ),
				[]
			],
			'Simple non-associative remove' => [
				new StatementList( $statement1 ),
				new Diff( [
					's1' => new DiffOpRemove( $statement1 ),
				], false ),
				[]
			],

			// Change operations
			'Remove and add' => [
				new StatementList( $statement1 ),
				new Diff( [
					's1' => new DiffOpRemove( $statement1 ),
					's2' => new DiffOpAdd( $statement2 ),
				] ),
				[ 's2' ]
			],
			'Add and remove' => [
				new StatementList( $statement1 ),
				new Diff( [
					's2' => new DiffOpAdd( $statement2 ),
					's1' => new DiffOpRemove( $statement1 ),
				] ),
				[ 's2' ]
			],
			'Simple associative replace' => [
				new StatementList( $statement1 ),
				new Diff( [
					's1' => new DiffOpChange( $statement1, $statement2 ),
				], true ),
				[ 's2' ]
			],
			'Simple non-associative replace' => [
				new StatementList( $statement1 ),
				new Diff( [
					's1' => new DiffOpChange( $statement1, $statement2 ),
				], false ),
				[ 's2' ]
			],
			'Replacing first element retains order' => [
				new StatementList( $statement1, $statement2 ),
				new Diff( [
					's1' => new DiffOpChange( $statement1, $statement3 ),
				] ),
				[ 's3', 's2' ]
			],
			'Replacing last element retains order' => [
				new StatementList( $statement1, $statement2 ),
				new Diff( [
					's2' => new DiffOpChange( $statement2, $statement3 ),
				] ),
				[ 's1', 's3' ]
			],

			// No-ops
			'Empty diff' => [
				new StatementList( $statement1 ),
				new Diff(),
				[ 's1' ]
			],
			'Adding existing element is no-op' => [
				new StatementList( $statement1 ),
				new Diff( [
					's1' => new DiffOpAdd( $statement1 ),
				] ),
				[ 's1' ]
			],
			'Removing non-existing element is no-op' => [
				new StatementList( $statement1 ),
				new Diff( [
					's2' => new DiffOpRemove( $statement2 ),
				] ),
				[ 's1' ]
			],
			'Replacing non-existing element is no-op' => [
				new StatementList( $statement1 ),
				new Diff( [
					's2' => new DiffOpChange( $statement2, $statement3 ),
				] ),
				[ 's1' ]
			],
		];
	}

	/**
	 * @dataProvider statementOrderProvider
	 */
	public function testStatementOrder( StatementList $statements, Diff $patch, array $expectedGuids ) {
		$patcher = new StatementListPatcher();
		$patcher->patchStatementList( $statements, $patch );

		$guids = [];
		foreach ( $statements->toArray() as $statement ) {
			$guids[] = $statement->getGuid();
		}
		$this->assertSame( $expectedGuids, $guids );
	}

	public function testGivenEmptyDiff_listIsReturnedAsIs() {
		$statements = new StatementList();

		$this->assertListResultsFromPatch( $statements, $statements, new Diff() );
	}

	private function assertListResultsFromPatch(
		StatementList $expected,
		StatementList $statements,
		Diff $patch
	) {
		$patcher = new StatementListPatcher();
		$patcher->patchStatementList( $statements, $patch );
		$this->assertEquals( $expected, $statements );
	}

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

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

		$statement2 = new Statement( new PropertyValueSnak( 42, new StringValue( 'ohi' ) ) );
		$statement2->setGuid( 's2' );

		$statement3 = new Statement( new PropertyNoValueSnak( 1 ) );
		$statement3->setGuid( 's3' );

		$patch = new Diff( [
			's0' => new DiffOpRemove( $statement0 ),
			's2' => new DiffOpAdd( $statement2 ),
			's3' => new DiffOpAdd( $statement3 )
		] );

		$source = new StatementList();
		$source->addStatement( $statement0 );
		$source->addStatement( $statement1 );

		$expected = new StatementList();
		$expected->addStatement( $statement1 );
		$expected->addStatement( $statement2 );
		$expected->addStatement( $statement3 );

		$this->assertListResultsFromPatch( $expected, $source, $patch );
	}

}


1			<?php
2
3			namespace Wikibase\DataModel\Services\Tests\Diff;
4
5			use DataValues\StringValue;
6			use Diff\DiffOp\Diff\Diff;
7			use Diff\DiffOp\DiffOpAdd;
8			use Diff\DiffOp\DiffOpChange;
9			use Diff\DiffOp\DiffOpRemove;
10			use PHPUnit\Framework\TestCase;
11			use Wikibase\DataModel\Services\Diff\StatementListPatcher;
12			use Wikibase\DataModel\Snak\PropertyNoValueSnak;
13			use Wikibase\DataModel\Snak\PropertySomeValueSnak;
14			use Wikibase\DataModel\Snak\PropertyValueSnak;
15			use Wikibase\DataModel\Statement\Statement;
16			use Wikibase\DataModel\Statement\StatementList;
17
18			/**
19			* @covers \Wikibase\DataModel\Services\Diff\StatementListPatcher
20			*
21			* @license GPL-2.0-or-later
22			* @author Jeroen De Dauw < [email protected] >
23			* @author Thiemo Kreuz
24			*/
25			class StatementListPatcherTest extends TestCase {
26
27			public function patchStatementListProvider() {
28			$statement1 = new Statement( new PropertyNoValueSnak( 1 ) );
29			$statement2 = new Statement( new PropertyNoValueSnak( 2 ) );
30
31			return [
32			// Empty diffs
33			[
34			new StatementList(),
35			new Diff(),
36			new StatementList()
37			],
38			[
39			new StatementList( $statement1 ),
40			new Diff(),
41			new StatementList( $statement1 )
42			],
43
44			// Add operations
45			[
46			new StatementList(),
47			new Diff( [ new DiffOpAdd( $statement1 ) ], true ),
48			new StatementList( $statement1 )
49			],
50			[
51			new StatementList(),
52			new Diff( [ new DiffOpAdd( $statement1 ) ], false ),
53			new StatementList( $statement1 )
54			],
55			[
56			new StatementList(),
57			new Diff( [ new DiffOpAdd( $statement1 ) ] ),
58			new StatementList( $statement1 )
59			],
60
61			// Remove operations
62			[
63			new StatementList( $statement1 ),
64			new Diff( [ new DiffOpRemove( $statement1 ) ], true ),
65			new StatementList()
66			],
67			[
68			new StatementList( $statement1 ),
69			new Diff( [ new DiffOpRemove( $statement1 ) ], false ),
70			new StatementList()
71			],
72			[
73			new StatementList( $statement1 ),
74			new Diff( [ new DiffOpRemove( $statement1 ) ] ),
75			new StatementList()
76			],
77
78			// Mixed operations
79			[
80			new StatementList( $statement1 ),
81			new Diff( [
82			new DiffOpRemove( $statement1 ),
83			new DiffOpAdd( $statement2 ),
84			] ),
85			new StatementList( $statement2 )
86			],
87			[
88			new StatementList( $statement1 ),
89			new Diff( [
90			new DiffOpChange( $statement1, $statement2 ),
91			] ),
92			new StatementList( $statement2 )
93			],
94			];
95			}
96
97			/**
98			* @dataProvider patchStatementListProvider
99			*/
100			public function testPatchStatementList(
101			StatementList $statements,
102			Diff $patch,
103			StatementList $expected
104			) {
105			$patcher = new StatementListPatcher();
106			$patcher->patchStatementList( $statements, $patch );
107			$this->assertEquals( $expected, $statements );
108			}
109
110			/**
111			* @SuppressWarnings(PHPMD.ExcessiveMethodLength)
112			*/
113			public function statementOrderProvider() {
114			$statement1 = new Statement( new PropertyNoValueSnak( 1 ), null, null, 's1' );
115			$statement2 = new Statement( new PropertyNoValueSnak( 2 ), null, null, 's2' );
116			$statement3 = new Statement( new PropertyNoValueSnak( 3 ), null, null, 's3' );
117
118			return [
119			'Simple associative add' => [
120			new StatementList(),
121			new Diff( [
122			's1' => new DiffOpAdd( $statement1 ),
123			], true ),
124			[ 's1' ]
125			],
126			'Simple non-associative add' => [
127			new StatementList(),
128			new Diff( [
129			's1' => new DiffOpAdd( $statement1 ),
130			], false ),
131			[ 's1' ]
132			],
133			'Simple associative remove' => [
134			new StatementList( $statement1 ),
135			new Diff( [
136			's1' => new DiffOpRemove( $statement1 ),
137			], true ),
138			[]
139			],
140			'Simple non-associative remove' => [
141			new StatementList( $statement1 ),
142			new Diff( [
143			's1' => new DiffOpRemove( $statement1 ),
144			], false ),
145			[]
146			],
147
148			// Change operations
149			'Remove and add' => [
150			new StatementList( $statement1 ),
151			new Diff( [
152			's1' => new DiffOpRemove( $statement1 ),
153			's2' => new DiffOpAdd( $statement2 ),
154			] ),
155			[ 's2' ]
156			],
157			'Add and remove' => [
158			new StatementList( $statement1 ),
159			new Diff( [
160			's2' => new DiffOpAdd( $statement2 ),
161			's1' => new DiffOpRemove( $statement1 ),
162			] ),
163			[ 's2' ]
164			],
165			'Simple associative replace' => [
166			new StatementList( $statement1 ),
167			new Diff( [
168			's1' => new DiffOpChange( $statement1, $statement2 ),
169			], true ),
170			[ 's2' ]
171			],
172			'Simple non-associative replace' => [
173			new StatementList( $statement1 ),
174			new Diff( [
175			's1' => new DiffOpChange( $statement1, $statement2 ),
176			], false ),
177			[ 's2' ]
178			],
179			'Replacing first element retains order' => [
180			new StatementList( $statement1, $statement2 ),
181			new Diff( [
182			's1' => new DiffOpChange( $statement1, $statement3 ),
183			] ),
184			[ 's3', 's2' ]
185			],
186			'Replacing last element retains order' => [
187			new StatementList( $statement1, $statement2 ),
188			new Diff( [
189			's2' => new DiffOpChange( $statement2, $statement3 ),
190			] ),
191			[ 's1', 's3' ]
192			],
193
194			// No-ops
195			'Empty diff' => [
196			new StatementList( $statement1 ),
197			new Diff(),
198			[ 's1' ]
199			],
200			'Adding existing element is no-op' => [
201			new StatementList( $statement1 ),
202			new Diff( [
203			's1' => new DiffOpAdd( $statement1 ),
204			] ),
205			[ 's1' ]
206			],
207			'Removing non-existing element is no-op' => [
208			new StatementList( $statement1 ),
209			new Diff( [
210			's2' => new DiffOpRemove( $statement2 ),
211			] ),
212			[ 's1' ]
213			],
214			'Replacing non-existing element is no-op' => [
215			new StatementList( $statement1 ),
216			new Diff( [
217			's2' => new DiffOpChange( $statement2, $statement3 ),
218			] ),
219			[ 's1' ]
220			],
221			];
222			}
223
224			/**
225			* @dataProvider statementOrderProvider
226			*/
227			public function testStatementOrder( StatementList $statements, Diff $patch, array $expectedGuids ) {
228			$patcher = new StatementListPatcher();
229			$patcher->patchStatementList( $statements, $patch );
230
231			$guids = [];
232			foreach ( $statements->toArray() as $statement ) {
233			$guids[] = $statement->getGuid();
234			}
235			$this->assertSame( $expectedGuids, $guids );
236			}
237
238			public function testGivenEmptyDiff_listIsReturnedAsIs() {
239			$statements = new StatementList();
240
241			$this->assertListResultsFromPatch( $statements, $statements, new Diff() );
242			}
243
244			private function assertListResultsFromPatch(
245			StatementList $expected,
246			StatementList $statements,
247			Diff $patch
248			) {
249			$patcher = new StatementListPatcher();
250			$patcher->patchStatementList( $statements, $patch );
251			$this->assertEquals( $expected, $statements );
252			}
253
254			public function testFoo() {
255			$statement0 = new Statement( new PropertyNoValueSnak( 42 ) );
256			$statement0->setGuid( 's0' );
257
258			$statement1 = new Statement( new PropertySomeValueSnak( 42 ) );
259			$statement1->setGuid( 's1' );
260
261			$statement2 = new Statement( new PropertyValueSnak( 42, new StringValue( 'ohi' ) ) );
262			$statement2->setGuid( 's2' );
263
264			$statement3 = new Statement( new PropertyNoValueSnak( 1 ) );
265			$statement3->setGuid( 's3' );
266
267			$patch = new Diff( [
268			's0' => new DiffOpRemove( $statement0 ),
269			's2' => new DiffOpAdd( $statement2 ),
270			's3' => new DiffOpAdd( $statement3 )
271			] );
272
273			$source = new StatementList();
274			$source->addStatement( $statement0 );
275			$source->addStatement( $statement1 );
276
277			$expected = new StatementList();
278			$expected->addStatement( $statement1 );
279			$expected->addStatement( $statement2 );
280			$expected->addStatement( $statement3 );
281
282			$this->assertListResultsFromPatch( $expected, $source, $patch );
283			}
284
285			}
286

wmde / WikibaseDataModelServices

patchStatementListProvider() B last analyzed 2021-06-01 10:00 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

patchStatementListProvider() B
last analyzed 2021-06-01 10:00 UTC