HookRegistryTest::assertThatHookIsExcutable() - Code Metrics - Inspection of "Add extension.json support (#62)" - SemanticMediaWiki/SemanticCite - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 1dd58a...87fd77 )

by Karsten

created 2018-10-06 20:15 UTC

HookRegistryTest::assertThatHookIsExcutable() A

↳ Parent: HookRegistryTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace SCI\Tests;

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

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

	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() {

		$vars = [];
		HookRegistry::initExtension( $vars );

		$propertyExemptionList = [
			'__sci_cite'
		];

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

		foreach ( $vars['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();

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

SemanticMediaWiki / SemanticCite

Push — master ( 1dd58a...87fd77 )

HookRegistryTest::assertThatHookIsExcutable() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like