HookRegistryTest - Code Metrics - Inspection of "Add CI for MW 1.41" - SemanticMediaWiki/SemanticCite - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#136)

by None

created 2024-12-31 15:06 UTC

HookRegistryTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	468
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

Metric	Value
wmc	20
lcom	1
cbo	6
dl	0
loc	468
rs	10
c	0
b	0
f	0

<?php

namespace SCI\Tests;

use SCI\HookRegistry;
use SCI\Options;
use SMW\DataTypeRegistry;
use SMW\DIWikiPage;
use SMW\DIProperty;
use SMW\Tests\PHPUnitCompat;

/**
 * @covers \SCI\HookRegistry
 * @group semantic-cite
 *
 * @license GNU GPL v2+
 * @since 1.0
 *
 * @author mwjames
 */
class HookRegistryTest extends \PHPUnit_Framework_TestCase {

	use PHPUnitCompat;

	public function testCanConstruct() {

		$store = $this->getMockBuilder( '\SMW\Store' )
			->disableOriginalConstructor()
			->getMockForAbstractClass();

		$cache = $this->getMockBuilder( '\Onoi\Cache\Cache' )
			->disableOriginalConstructor()
			->getMockForAbstractClass();

		$options = $this->getMockBuilder( '\SCI\Options' )
			->disableOriginalConstructor()
			->getMock();

		$this->assertInstanceOf(
			'\SCI\HookRegistry',
			new HookRegistry( $store, $cache, $options )
		);
	}

	public function testRegister() {

		$store = $this->getMockBuilder( '\SMW\Store' )
			->disableOriginalConstructor()
			->getMockForAbstractClass();

		$cache = $this->getMockBuilder( '\Onoi\Cache\Cache' )
			->disableOriginalConstructor()
			->getMockForAbstractClass();

		$configuration = [
			'numberOfReferenceListColumns'       => 1,
			'browseLinkToCitationResource'       => false,
			'showTooltipForCitationReference'    => false,
			'tooltipRequestCacheTTL'             => false,
			'citationReferenceCaptionFormat'     => 1,
			'referenceListType'                  => 'ul',
			'enabledStrictParserValidation'      => true,
			'cachePrefix'                        => 'foo',
			'enabledCitationTextChangeUpdateJob' => false,
			'responsiveMonoColumnCharacterBoundLength' => 42
		];

		$instance = new HookRegistry(
			$store,
			$cache,
			new Options( $configuration )
		);

		$this->doTestRegisteredInitPropertiesHandler( $instance );
		$this->doTestRegisteredInitDataTypesHandler( $instance );
		$this->doTestRegisteredBeforeMagicWordsFinderHandler( $instance );
		$this->doTestRegisteredOutputPageParserOutput( $instance );
		$this->doTestRegisteredOutputPageBeforeHTML( $instance );
		$this->doTestRegisteredUpdateDataBefore( $instance );
		$this->doTestRegisteredAddCustomFixedPropertyTables( $instance );
		$this->doTestRegisteredResourceLoaderGetConfigVars( $instance );
		$this->doTestRegisteredParserFirstCallInit( $instance );
		$this->doTestRegisteredBeforePageDisplay( $instance );
		$this->doTestRegisteredBrowseAfterIncomingPropertiesLookupComplete( $instance );
		$this->doTestRegisteredBrowseBeforeIncomingPropertyValuesFurtherLinkCreate( $instance );
		$this->doTestRegisteredAfterDataUpdateComplete( $instance );
		$this->doTestRegisteredAfterDeleteSubjectComplete( $instance );
	}

	public function testInitExtension() {

		$propertyExemptionList = [
			'__sci_cite'
		];

		$config = [
			'smwgFulltextSearchPropertyExemptionList' => [],
			'smwgQueryDependencyPropertyExemptionList' => []
		];

		foreach ( $GLOBALS['wgHooks']['SMW::Config::BeforeCompletion'] as $callback ) {
			call_user_func_array( $callback, [ &$config ] );
		}

		$this->assertEquals(
			[
				'smwgFulltextSearchPropertyExemptionList' => $propertyExemptionList,
				'smwgQueryDependencyPropertyExemptionList' => $propertyExemptionList,
			],
			$config
		);
	}

	public function doTestRegisteredInitPropertiesHandler( $instance ) {

		$hook = 'SMW::Property::initProperties';

		$propertyRegistry = $this->getMockBuilder( '\SMW\PropertyRegistry' )
			->disableOriginalConstructor()
			->getMock();

		$this->assertTrue(
			$instance->isRegistered( $hook )
		);

		$this->assertThatHookIsExcutable(
			$instance->getHandlerFor( $hook ),
			[ $propertyRegistry ]
		);
	}

	public function doTestRegisteredInitDataTypesHandler( $instance ) {

		$hook = 'SMW::DataType::initTypes';

		$this->assertTrue(
			$instance->isRegistered( $hook )
		);

		$dataTypeRegistry = DataTypeRegistry::getInstance();

		if ( method_exists( $dataTypeRegistry, 'clearCallables' ) ) {
			 $dataTypeRegistry->clearCallables();
		}

		$this->assertThatHookIsExcutable(
			$instance->getHandlerFor( $hook ),
			[ $dataTypeRegistry ]
		);

		$this->assertEquals(
			'\SCI\DataValues\CitationReferenceValue',
			$dataTypeRegistry->getDataTypeClassById( '_sci_ref' )
		);

		$this->assertEquals(
			'\SCI\DataValues\ResourceIdentifierStringValue',
			$dataTypeRegistry->getDataTypeClassById( '_sci_doi' )
		);

		$this->assertEquals(
			'\SCI\DataValues\ResourceIdentifierStringValue',
			$dataTypeRegistry->getDataTypeClassById( '_sci_pmcid' )
		);

		$this->assertEquals(
			'\SCI\DataValues\ResourceIdentifierStringValue',
			$dataTypeRegistry->getDataTypeClassById( '_sci_pmid' )
		);

		$this->assertEquals(
			'\SCI\DataValues\ResourceIdentifierStringValue',
			$dataTypeRegistry->getDataTypeClassById( '_sci_viaf' )
		);

		$this->assertEquals(
			'\SCI\DataValues\ResourceIdentifierStringValue',
			$dataTypeRegistry->getDataTypeClassById( '_sci_oclc' )
		);

		$this->assertEquals(
			'\SCI\DataValues\ResourceIdentifierStringValue',
			$dataTypeRegistry->getDataTypeClassById( '_sci_olid' )
		);
	}

	public function doTestRegisteredBeforeMagicWordsFinderHandler( $instance ) {

		$hook = 'SMW::Parser::BeforeMagicWordsFinder';

		$this->assertTrue(
			$instance->isRegistered( $hook )
		);

		$magicWords = [];

		$this->assertThatHookIsExcutable(
			$instance->getHandlerFor( $hook ),
			[ &$magicWords ]
		);
	}

	public function doTestRegisteredOutputPageParserOutput( $instance ) {

		$hook = 'OutputPageParserOutput';

		$this->assertTrue(
			$instance->isRegistered( $hook )
		);

		$outputPage = $this->getMockBuilder( '\OutputPage' )
			->disableOriginalConstructor()
			->getMock();

		$parserOutput = $this->getMockBuilder( '\ParserOutput' )
			->disableOriginalConstructor()
			->getMock();

		$this->assertThatHookIsExcutable(
			$instance->getHandlerFor( $hook ),
			[ &$outputPage, $parserOutput ]
		);
	}

	public function doTestRegisteredOutputPageBeforeHTML( $instance ) {

		$hook = 'OutputPageBeforeHTML';

		$this->assertTrue(
			$instance->isRegistered( $hook )
		);

		$webRequest = $this->getMockBuilder( '\WebRequest' )
			->disableOriginalConstructor()
			->getMock();

		$language = $this->getMockBuilder( '\Language' )
			->disableOriginalConstructor()
			->getMock();

		$requestContext = $this->getMockBuilder( '\RequestContext' )
			->disableOriginalConstructor()
			->getMock();

		$requestContext->expects( $this->any() )
			->method( 'getRequest' )
			->will( $this->returnValue( $webRequest ) );

		$requestContext->expects( $this->any() )
			->method( 'getLanguage' )
			->will( $this->returnValue( $language ) );

		$requestContext->expects( $this->any() )
			->method( 'getTitle' )
			->will( $this->returnValue( \Title::newFromText( 'Foo' ) ) );

		$outputPage = $this->getMockBuilder( '\OutputPage' )
			->disableOriginalConstructor()
			->getMock();

		$outputPage->expects( $this->any() )
			->method( 'getContext' )
			->will( $this->returnValue( $requestContext ) );

		$text = '';

		$this->assertThatHookIsExcutable(
			$instance->getHandlerFor( $hook ),
			[ &$outputPage, &$text ]
		);
	}

	public function doTestRegisteredUpdateDataBefore( $instance ) {

		$hook = 'SMWStore::updateDataBefore';

		$store = $this->getMockBuilder( '\SMW\Store' )
			->disableOriginalConstructor()
			->getMockForAbstractClass();

		$semanticData = $this->getMockBuilder( '\SMW\SemanticData' )
			->disableOriginalConstructor()
			->getMock();

		$semanticData->expects( $this->any() )
			->method( 'getSubject' )
			->will( $this->returnValue( new DIWikiPage( 'Foo', NS_MAIN ) ) );

		$this->assertTrue(
			$instance->isRegistered( $hook )
		);

		$this->assertThatHookIsExcutable(
			$instance->getHandlerFor( $hook ),
			[ $store, $semanticData ]
		);
	}

	public function doTestRegisteredAddCustomFixedPropertyTables( $instance ) {

		$hook = 'SMW::SQLStore::AddCustomFixedPropertyTables';

		// Contains an extra to ensure previous values are not nullified
		$customFixedProperties = [ '_Foo' ];

		$this->assertTrue(
			$instance->isRegistered( $hook )
		);

		$this->assertThatHookIsExcutable(
			$instance->getHandlerFor( $hook ),
			[ &$customFixedProperties ]
		);

		$this->assertCount(
			11,
			$customFixedProperties
		);
	}

	public function doTestRegisteredResourceLoaderGetConfigVars( $instance ) {

		$hook = 'ResourceLoaderGetConfigVars';

		$this->assertTrue(
			$instance->isRegistered( $hook )
		);

		$vars = [];

		$this->assertThatHookIsExcutable(
			$instance->getHandlerFor( $hook ),
			[ &$vars ]
		);
	}

	public function doTestRegisteredParserFirstCallInit( $instance ) {

		$hook = 'ParserFirstCallInit';

		$this->assertTrue(
			$instance->isRegistered( $hook )
		);

		$parser = $this->getMockBuilder( '\Parser' )
			->disableOriginalConstructor()
			->getMock();

		$this->assertThatHookIsExcutable(
			$instance->getHandlerFor( $hook ),
			[ &$parser ]
		);
	}

	public function doTestRegisteredBeforePageDisplay( $instance ) {

		$hook = 'BeforePageDisplay';

		$this->assertTrue(
			$instance->isRegistered( $hook )
		);

		$outputPage = $this->getMockBuilder( '\OutputPage' )
			->disableOriginalConstructor()
			->getMock();

		$outputPage->expects( $this->once() )
			->method( 'getTitle' )
			->will( $this->returnValue( \Title::newFromText( 'Foo' ) ) );

		$skin = $this->getMockBuilder( '\Skin' )
			->disableOriginalConstructor()
			->getMock();

		$this->assertThatHookIsExcutable(
			$instance->getHandlerFor( $hook ),
			[ &$outputPage, &$skin ]
		);
	}

	public function doTestRegisteredBrowseAfterIncomingPropertiesLookupComplete( $instance ) {

		$hook = 'SMW::Browse::AfterIncomingPropertiesLookupComplete';

		$this->assertTrue(
			$instance->isRegistered( $hook )
		);

		$semanticData = $this->getMockBuilder( '\SMW\SemanticData' )
			->disableOriginalConstructor()
			->getMock();

		$semanticData->expects( $this->once() )
			->method( 'getSubject' )
			->will( $this->returnValue( DIWikiPage::newFromText( __METHOD__ ) ) );

		$store = $this->getMockBuilder( '\SMW\Store' )
			->disableOriginalConstructor()
			->getMockForAbstractClass();

		$store->expects( $this->once() )
			->method( 'getSemanticData' )
			->will( $this->returnValue( $semanticData ) );

		$this->assertThatHookIsExcutable(
			$instance->getHandlerFor( $hook ),
			[ $store, $semanticData, null ]
		);
	}

	public function doTestRegisteredBrowseBeforeIncomingPropertyValuesFurtherLinkCreate( $instance ) {

		$hook = 'SMW::Browse::BeforeIncomingPropertyValuesFurtherLinkCreate';

		$this->assertTrue(
			$instance->isRegistered( $hook )
		);

		$property = new DIProperty( 'Foo' );
		$subject = DIWikiPage::newFromText( __METHOD__ );

		$html = '';

		$this->assertThatHookIsExcutable(
			$instance->getHandlerFor( $hook ),
			[ $property, $subject, &$html ]
		);
	}

	public function doTestRegisteredAfterDataUpdateComplete( $instance ) {

		$hook = 'SMW::SQLStore::AfterDataUpdateComplete';

		$this->assertTrue(
			$instance->isRegistered( $hook )
		);

		$semanticData = $this->getMockBuilder( '\SMW\SemanticData' )
			->disableOriginalConstructor()
			->getMock();

		$semanticData->expects( $this->once() )
			->method( 'getSubject' )
			->will( $this->returnValue( DIWikiPage::newFromText( __METHOD__ ) ) );

		$store = $this->getMockBuilder( '\SMW\SQLStore\SQLStore' )
			->disableOriginalConstructor()
			->getMock();

		$compositePropertyTableDiffIterator = $this->getMockBuilder( '\SMW\SQLStore\CompositePropertyTableDiffIterator' )
			->disableOriginalConstructor()
			->getMock();

		$this->assertThatHookIsExcutable(
			$instance->getHandlerFor( $hook ),
			[ $store, $semanticData, $compositePropertyTableDiffIterator ]
		);
	}

	public function doTestRegisteredAfterDeleteSubjectComplete( $instance ) {

		$hook = 'SMW::SQLStore::AfterDeleteSubjectComplete';

		$this->assertTrue(
			$instance->isRegistered( $hook )
		);

		$store = $this->getMockBuilder( '\SMW\SQLStore\SQLStore' )
			->disableOriginalConstructor()
			->getMock();

		$this->assertThatHookIsExcutable(
			$instance->getHandlerFor( $hook ),
			[ $store, \Title::newFromText( 'Foo' ) ]
		);
	}

	private function assertThatHookIsExcutable( callable $handler, $arguments = [] ) {
		$this->assertInternalType(
			'boolean',
			call_user_func_array( $handler, $arguments )
		);
	}

}


1			<?php
2
3			namespace SCI\Tests;
4
5			use SCI\HookRegistry;
6			use SCI\Options;
7			use SMW\DataTypeRegistry;
8			use SMW\DIWikiPage;
9			use SMW\DIProperty;
10			use SMW\Tests\PHPUnitCompat;
11
12			/**
13			* @covers \SCI\HookRegistry
14			* @group semantic-cite
15			*
16			* @license GNU GPL v2+
17			* @since 1.0
18			*
19			* @author mwjames
20			*/
21			class HookRegistryTest extends \PHPUnit_Framework_TestCase {
22
23			use PHPUnitCompat;
24
25			public function testCanConstruct() {
26
27			$store = $this->getMockBuilder( '\SMW\Store' )
28			->disableOriginalConstructor()
29			->getMockForAbstractClass();
30
31			$cache = $this->getMockBuilder( '\Onoi\Cache\Cache' )
32			->disableOriginalConstructor()
33			->getMockForAbstractClass();
34
35			$options = $this->getMockBuilder( '\SCI\Options' )
36			->disableOriginalConstructor()
37			->getMock();
38
39			$this->assertInstanceOf(
40			'\SCI\HookRegistry',
41			new HookRegistry( $store, $cache, $options )
42			);
43			}
44
45			public function testRegister() {
46
47			$store = $this->getMockBuilder( '\SMW\Store' )
48			->disableOriginalConstructor()
49			->getMockForAbstractClass();
50
51			$cache = $this->getMockBuilder( '\Onoi\Cache\Cache' )
52			->disableOriginalConstructor()
53			->getMockForAbstractClass();
54
55			$configuration = [
56			'numberOfReferenceListColumns' => 1,
57			'browseLinkToCitationResource' => false,
58			'showTooltipForCitationReference' => false,
59			'tooltipRequestCacheTTL' => false,
60			'citationReferenceCaptionFormat' => 1,
61			'referenceListType' => 'ul',
62			'enabledStrictParserValidation' => true,
63			'cachePrefix' => 'foo',
64			'enabledCitationTextChangeUpdateJob' => false,
65			'responsiveMonoColumnCharacterBoundLength' => 42
66			];
67
68			$instance = new HookRegistry(
69			$store,
70			$cache,
71			new Options( $configuration )
72			);
73
74			$this->doTestRegisteredInitPropertiesHandler( $instance );
75			$this->doTestRegisteredInitDataTypesHandler( $instance );
76			$this->doTestRegisteredBeforeMagicWordsFinderHandler( $instance );
77			$this->doTestRegisteredOutputPageParserOutput( $instance );
78			$this->doTestRegisteredOutputPageBeforeHTML( $instance );
79			$this->doTestRegisteredUpdateDataBefore( $instance );
80			$this->doTestRegisteredAddCustomFixedPropertyTables( $instance );
81			$this->doTestRegisteredResourceLoaderGetConfigVars( $instance );
82			$this->doTestRegisteredParserFirstCallInit( $instance );
83			$this->doTestRegisteredBeforePageDisplay( $instance );
84			$this->doTestRegisteredBrowseAfterIncomingPropertiesLookupComplete( $instance );
85			$this->doTestRegisteredBrowseBeforeIncomingPropertyValuesFurtherLinkCreate( $instance );
86			$this->doTestRegisteredAfterDataUpdateComplete( $instance );
87			$this->doTestRegisteredAfterDeleteSubjectComplete( $instance );
88			}
89
90			public function testInitExtension() {
91
92			$propertyExemptionList = [
93			'__sci_cite'
94			];
95
96			$config = [
97			'smwgFulltextSearchPropertyExemptionList' => [],
98			'smwgQueryDependencyPropertyExemptionList' => []
99			];
100
101			foreach ( $GLOBALS['wgHooks']['SMW::Config::BeforeCompletion'] as $callback ) {
102			call_user_func_array( $callback, [ &$config ] );
103			}
104
105			$this->assertEquals(
106			[
107			'smwgFulltextSearchPropertyExemptionList' => $propertyExemptionList,
108			'smwgQueryDependencyPropertyExemptionList' => $propertyExemptionList,
109			],
110			$config
111			);
112			}
113
114			public function doTestRegisteredInitPropertiesHandler( $instance ) {
115
116			$hook = 'SMW::Property::initProperties';
117
118			$propertyRegistry = $this->getMockBuilder( '\SMW\PropertyRegistry' )
119			->disableOriginalConstructor()
120			->getMock();
121
122			$this->assertTrue(
123			$instance->isRegistered( $hook )
124			);
125
126			$this->assertThatHookIsExcutable(
127			$instance->getHandlerFor( $hook ),
128			[ $propertyRegistry ]
129			);
130			}
131
132			public function doTestRegisteredInitDataTypesHandler( $instance ) {
133
134			$hook = 'SMW::DataType::initTypes';
135
136			$this->assertTrue(
137			$instance->isRegistered( $hook )
138			);
139
140			$dataTypeRegistry = DataTypeRegistry::getInstance();
141
142			if ( method_exists( $dataTypeRegistry, 'clearCallables' ) ) {
143			$dataTypeRegistry->clearCallables();
144			}
145
146			$this->assertThatHookIsExcutable(
147			$instance->getHandlerFor( $hook ),
148			[ $dataTypeRegistry ]
149			);
150
151			$this->assertEquals(
152			'\SCI\DataValues\CitationReferenceValue',
153			$dataTypeRegistry->getDataTypeClassById( '_sci_ref' )
154			);
155
156			$this->assertEquals(
157			'\SCI\DataValues\ResourceIdentifierStringValue',
158			$dataTypeRegistry->getDataTypeClassById( '_sci_doi' )
159			);
160
161			$this->assertEquals(
162			'\SCI\DataValues\ResourceIdentifierStringValue',
163			$dataTypeRegistry->getDataTypeClassById( '_sci_pmcid' )
164			);
165
166			$this->assertEquals(
167			'\SCI\DataValues\ResourceIdentifierStringValue',
168			$dataTypeRegistry->getDataTypeClassById( '_sci_pmid' )
169			);
170
171			$this->assertEquals(
172			'\SCI\DataValues\ResourceIdentifierStringValue',
173			$dataTypeRegistry->getDataTypeClassById( '_sci_viaf' )
174			);
175
176			$this->assertEquals(
177			'\SCI\DataValues\ResourceIdentifierStringValue',
178			$dataTypeRegistry->getDataTypeClassById( '_sci_oclc' )
179			);
180
181			$this->assertEquals(
182			'\SCI\DataValues\ResourceIdentifierStringValue',
183			$dataTypeRegistry->getDataTypeClassById( '_sci_olid' )
184			);
185			}
186
187			public function doTestRegisteredBeforeMagicWordsFinderHandler( $instance ) {
188
189			$hook = 'SMW::Parser::BeforeMagicWordsFinder';
190
191			$this->assertTrue(
192			$instance->isRegistered( $hook )
193			);
194
195			$magicWords = [];
196
197			$this->assertThatHookIsExcutable(
198			$instance->getHandlerFor( $hook ),
199			[ &$magicWords ]
200			);
201			}
202
203			public function doTestRegisteredOutputPageParserOutput( $instance ) {
204
205			$hook = 'OutputPageParserOutput';
206
207			$this->assertTrue(
208			$instance->isRegistered( $hook )
209			);
210
211			$outputPage = $this->getMockBuilder( '\OutputPage' )
212			->disableOriginalConstructor()
213			->getMock();
214
215			$parserOutput = $this->getMockBuilder( '\ParserOutput' )
216			->disableOriginalConstructor()
217			->getMock();
218
219			$this->assertThatHookIsExcutable(
220			$instance->getHandlerFor( $hook ),
221			[ &$outputPage, $parserOutput ]
222			);
223			}
224
225			public function doTestRegisteredOutputPageBeforeHTML( $instance ) {
226
227			$hook = 'OutputPageBeforeHTML';
228
229			$this->assertTrue(
230			$instance->isRegistered( $hook )
231			);
232
233			$webRequest = $this->getMockBuilder( '\WebRequest' )
234			->disableOriginalConstructor()
235			->getMock();
236
237			$language = $this->getMockBuilder( '\Language' )
238			->disableOriginalConstructor()
239			->getMock();
240
241			$requestContext = $this->getMockBuilder( '\RequestContext' )
242			->disableOriginalConstructor()
243			->getMock();
244
245			$requestContext->expects( $this->any() )
246			->method( 'getRequest' )
247			->will( $this->returnValue( $webRequest ) );
248
249			$requestContext->expects( $this->any() )
250			->method( 'getLanguage' )
251			->will( $this->returnValue( $language ) );
252
253			$requestContext->expects( $this->any() )
254			->method( 'getTitle' )
255			->will( $this->returnValue( \Title::newFromText( 'Foo' ) ) );
256
257			$outputPage = $this->getMockBuilder( '\OutputPage' )
258			->disableOriginalConstructor()
259			->getMock();
260
261			$outputPage->expects( $this->any() )
262			->method( 'getContext' )
263			->will( $this->returnValue( $requestContext ) );
264
265			$text = '';
266
267			$this->assertThatHookIsExcutable(
268			$instance->getHandlerFor( $hook ),
269			[ &$outputPage, &$text ]
270			);
271			}
272
273			public function doTestRegisteredUpdateDataBefore( $instance ) {
274
275			$hook = 'SMWStore::updateDataBefore';
276
277			$store = $this->getMockBuilder( '\SMW\Store' )
278			->disableOriginalConstructor()
279			->getMockForAbstractClass();
280
281			$semanticData = $this->getMockBuilder( '\SMW\SemanticData' )
282			->disableOriginalConstructor()
283			->getMock();
284
285			$semanticData->expects( $this->any() )
286			->method( 'getSubject' )
287			->will( $this->returnValue( new DIWikiPage( 'Foo', NS_MAIN ) ) );
288
289			$this->assertTrue(
290			$instance->isRegistered( $hook )
291			);
292
293			$this->assertThatHookIsExcutable(
294			$instance->getHandlerFor( $hook ),
295			[ $store, $semanticData ]
296			);
297			}
298
299			public function doTestRegisteredAddCustomFixedPropertyTables( $instance ) {
300
301			$hook = 'SMW::SQLStore::AddCustomFixedPropertyTables';
302
303			// Contains an extra to ensure previous values are not nullified
304			$customFixedProperties = [ '_Foo' ];
305
306			$this->assertTrue(
307			$instance->isRegistered( $hook )
308			);
309
310			$this->assertThatHookIsExcutable(
311			$instance->getHandlerFor( $hook ),
312			[ &$customFixedProperties ]
313			);
314
315			$this->assertCount(
316			11,
317			$customFixedProperties
318			);
319			}
320
321			public function doTestRegisteredResourceLoaderGetConfigVars( $instance ) {
322
323			$hook = 'ResourceLoaderGetConfigVars';
324
325			$this->assertTrue(
326			$instance->isRegistered( $hook )
327			);
328
329			$vars = [];
330
331			$this->assertThatHookIsExcutable(
332			$instance->getHandlerFor( $hook ),
333			[ &$vars ]
334			);
335			}
336
337			public function doTestRegisteredParserFirstCallInit( $instance ) {
338
339			$hook = 'ParserFirstCallInit';
340
341			$this->assertTrue(
342			$instance->isRegistered( $hook )
343			);
344
345			$parser = $this->getMockBuilder( '\Parser' )
346			->disableOriginalConstructor()
347			->getMock();
348
349			$this->assertThatHookIsExcutable(
350			$instance->getHandlerFor( $hook ),
351			[ &$parser ]
352			);
353			}
354
355			public function doTestRegisteredBeforePageDisplay( $instance ) {
356
357			$hook = 'BeforePageDisplay';
358
359			$this->assertTrue(
360			$instance->isRegistered( $hook )
361			);
362
363			$outputPage = $this->getMockBuilder( '\OutputPage' )
364			->disableOriginalConstructor()
365			->getMock();
366
367			$outputPage->expects( $this->once() )
368			->method( 'getTitle' )
369			->will( $this->returnValue( \Title::newFromText( 'Foo' ) ) );
370
371			$skin = $this->getMockBuilder( '\Skin' )
372			->disableOriginalConstructor()
373			->getMock();
374
375			$this->assertThatHookIsExcutable(
376			$instance->getHandlerFor( $hook ),
377			[ &$outputPage, &$skin ]
378			);
379			}
380
381			public function doTestRegisteredBrowseAfterIncomingPropertiesLookupComplete( $instance ) {
382
383			$hook = 'SMW::Browse::AfterIncomingPropertiesLookupComplete';
384
385			$this->assertTrue(
386			$instance->isRegistered( $hook )
387			);
388
389			$semanticData = $this->getMockBuilder( '\SMW\SemanticData' )
390			->disableOriginalConstructor()
391			->getMock();
392
393			$semanticData->expects( $this->once() )
394			->method( 'getSubject' )
395			->will( $this->returnValue( DIWikiPage::newFromText( __METHOD__ ) ) );
396
397			$store = $this->getMockBuilder( '\SMW\Store' )
398			->disableOriginalConstructor()
399			->getMockForAbstractClass();
400
401			$store->expects( $this->once() )
402			->method( 'getSemanticData' )
403			->will( $this->returnValue( $semanticData ) );
404
405			$this->assertThatHookIsExcutable(
406			$instance->getHandlerFor( $hook ),
407			[ $store, $semanticData, null ]
408			);
409			}
410
411			public function doTestRegisteredBrowseBeforeIncomingPropertyValuesFurtherLinkCreate( $instance ) {
412
413			$hook = 'SMW::Browse::BeforeIncomingPropertyValuesFurtherLinkCreate';
414
415			$this->assertTrue(
416			$instance->isRegistered( $hook )
417			);
418
419			$property = new DIProperty( 'Foo' );
420			$subject = DIWikiPage::newFromText( __METHOD__ );
421
422			$html = '';
423
424			$this->assertThatHookIsExcutable(
425			$instance->getHandlerFor( $hook ),
426			[ $property, $subject, &$html ]
427			);
428			}
429
430			public function doTestRegisteredAfterDataUpdateComplete( $instance ) {
431
432			$hook = 'SMW::SQLStore::AfterDataUpdateComplete';
433
434			$this->assertTrue(
435			$instance->isRegistered( $hook )
436			);
437
438			$semanticData = $this->getMockBuilder( '\SMW\SemanticData' )
439			->disableOriginalConstructor()
440			->getMock();
441
442			$semanticData->expects( $this->once() )
443			->method( 'getSubject' )
444			->will( $this->returnValue( DIWikiPage::newFromText( __METHOD__ ) ) );
445
446			$store = $this->getMockBuilder( '\SMW\SQLStore\SQLStore' )
447			->disableOriginalConstructor()
448			->getMock();
449
450			$compositePropertyTableDiffIterator = $this->getMockBuilder( '\SMW\SQLStore\CompositePropertyTableDiffIterator' )
451			->disableOriginalConstructor()
452			->getMock();
453
454			$this->assertThatHookIsExcutable(
455			$instance->getHandlerFor( $hook ),
456			[ $store, $semanticData, $compositePropertyTableDiffIterator ]
457			);
458			}
459
460			public function doTestRegisteredAfterDeleteSubjectComplete( $instance ) {
461
462			$hook = 'SMW::SQLStore::AfterDeleteSubjectComplete';
463
464			$this->assertTrue(
465			$instance->isRegistered( $hook )
466			);
467
468			$store = $this->getMockBuilder( '\SMW\SQLStore\SQLStore' )
469			->disableOriginalConstructor()
470			->getMock();
471
472			$this->assertThatHookIsExcutable(
473			$instance->getHandlerFor( $hook ),
474			[ $store, \Title::newFromText( 'Foo' ) ]
475			);
476			}
477
478			private function assertThatHookIsExcutable( callable $handler, $arguments = [] ) {
479			$this->assertInternalType(
480			'boolean',
481			call_user_func_array( $handler, $arguments )
482			);
483			}
484
485			}
486

SemanticMediaWiki / SemanticCite

Pull Request — master (#136)

HookRegistryTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

Duplication Side-by-Side

Filter issues like