HookRegistryTest::testOnBeforeConfigCompletion() - Code Metrics - Inspection of "Use `SMW::Config::BeforeCompletion` (#39)" - SemanticMediaWiki/SemanticCite - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 079bf8...76aa3a )

by mw

created 2016-12-18 14:01 UTC

HookRegistryTest::testOnBeforeConfigCompletion() A

↳ Parent: HookRegistryTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	19
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
dl	0
loc	19
rs	9.4285
c	1
b	0
f	0
cc	1
eloc	10
nc	1
nop	0

<?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 = array(
			'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 testOnBeforeConfigCompletion() {

		$config = array(
			'smwgFulltextSearchPropertyExemptionList' => array()
		);

		$propertyExemptionList = array(
			'__sci_cite'
		);

		HookRegistry::onBeforeConfigCompletion( $config );

		$this->assertEquals(
			array(
				'smwgFulltextSearchPropertyExemptionList' => $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 ),
			array( $propertyRegistry )
		);
	}

	public function doTestRegisteredInitDataTypesHandler( $instance ) {

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

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

		$dataTypeRegistry = DataTypeRegistry::getInstance();

		$this->assertThatHookIsExcutable(
			$instance->getHandlerFor( $hook ),
			array( $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 = array();

		$this->assertThatHookIsExcutable(
			$instance->getHandlerFor( $hook ),
			array( &$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 ),
			array( &$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 ),
			array( &$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 ),
			array( $store, $semanticData )
		);
	}

	public function doTestRegisteredAddCustomFixedPropertyTables( $instance ) {

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

		// Contains an extra to ensure previous values are not nullified
		$customFixedProperties = array( '_Foo' );

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

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

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

	public function doTestRegisteredResourceLoaderGetConfigVars( $instance ) {

		$hook = 'ResourceLoaderGetConfigVars';

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

		$vars = array();

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

	public function doTestRegisteredParserFirstCallInit( $instance ) {

		$hook = 'ParserFirstCallInit';

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

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

		$this->assertThatHookIsExcutable(
			$instance->getHandlerFor( $hook ),
			array( &$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 ),
			array( &$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 ),
			array( $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 ),
			array( $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 ),
			array( $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 ),
			array( $store, \Title::newFromText( 'Foo' ) )
		);
	}

	private function assertThatHookIsExcutable( \Closure $handler, $arguments = array() ) {
		$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 = array(
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 testOnBeforeConfigCompletion() {
88
89			$config = array(
90			'smwgFulltextSearchPropertyExemptionList' => array()
91			);
92
93			$propertyExemptionList = array(
94			'__sci_cite'
95			);
96
97			HookRegistry::onBeforeConfigCompletion( $config );
98
99			$this->assertEquals(
100			array(
101			'smwgFulltextSearchPropertyExemptionList' => $propertyExemptionList,
102			),
103			$config
104			);
105			}
106
107			public function doTestRegisteredInitPropertiesHandler( $instance ) {
108
109			$hook = 'SMW::Property::initProperties';
110
111			$propertyRegistry = $this->getMockBuilder( '\SMW\PropertyRegistry' )
112			->disableOriginalConstructor()
113			->getMock();
114
115			$this->assertTrue(
116			$instance->isRegistered( $hook )
117			);
118
119			$this->assertThatHookIsExcutable(
120			$instance->getHandlerFor( $hook ),
121			array( $propertyRegistry )
122			);
123			}
124
125			public function doTestRegisteredInitDataTypesHandler( $instance ) {
126
127			$hook = 'SMW::DataType::initTypes';
128
129			$this->assertTrue(
130			$instance->isRegistered( $hook )
131			);
132
133			$dataTypeRegistry = DataTypeRegistry::getInstance();
134
135			$this->assertThatHookIsExcutable(
136			$instance->getHandlerFor( $hook ),
137			array( $dataTypeRegistry )
138			);
139
140			$this->assertEquals(
141			'\SCI\DataValues\CitationReferenceValue',
142			$dataTypeRegistry->getDataTypeClassById( '_sci_ref' )
143			);
144
145			$this->assertEquals(
146			'\SCI\DataValues\ResourceIdentifierStringValue',
147			$dataTypeRegistry->getDataTypeClassById( '_sci_doi' )
148			);
149
150			$this->assertEquals(
151			'\SCI\DataValues\ResourceIdentifierStringValue',
152			$dataTypeRegistry->getDataTypeClassById( '_sci_pmcid' )
153			);
154
155			$this->assertEquals(
156			'\SCI\DataValues\ResourceIdentifierStringValue',
157			$dataTypeRegistry->getDataTypeClassById( '_sci_pmid' )
158			);
159
160			$this->assertEquals(
161			'\SCI\DataValues\ResourceIdentifierStringValue',
162			$dataTypeRegistry->getDataTypeClassById( '_sci_viaf' )
163			);
164
165			$this->assertEquals(
166			'\SCI\DataValues\ResourceIdentifierStringValue',
167			$dataTypeRegistry->getDataTypeClassById( '_sci_oclc' )
168			);
169
170			$this->assertEquals(
171			'\SCI\DataValues\ResourceIdentifierStringValue',
172			$dataTypeRegistry->getDataTypeClassById( '_sci_olid' )
173			);
174			}
175
176			public function doTestRegisteredBeforeMagicWordsFinderHandler( $instance ) {
177
178			$hook = 'SMW::Parser::BeforeMagicWordsFinder';
179
180			$this->assertTrue(
181			$instance->isRegistered( $hook )
182			);
183
184			$magicWords = array();
185
186			$this->assertThatHookIsExcutable(
187			$instance->getHandlerFor( $hook ),
188			array( &$magicWords )
189			);
190			}
191
192			public function doTestRegisteredOutputPageParserOutput( $instance ) {
193
194			$hook = 'OutputPageParserOutput';
195
196			$this->assertTrue(
197			$instance->isRegistered( $hook )
198			);
199
200			$outputPage = $this->getMockBuilder( '\OutputPage' )
201			->disableOriginalConstructor()
202			->getMock();
203
204			$parserOutput = $this->getMockBuilder( '\ParserOutput' )
205			->disableOriginalConstructor()
206			->getMock();
207
208			$this->assertThatHookIsExcutable(
209			$instance->getHandlerFor( $hook ),
210			array( &$outputPage, $parserOutput )
211			);
212			}
213
214			public function doTestRegisteredOutputPageBeforeHTML( $instance ) {
215
216			$hook = 'OutputPageBeforeHTML';
217
218			$this->assertTrue(
219			$instance->isRegistered( $hook )
220			);
221
222			$webRequest = $this->getMockBuilder( '\WebRequest' )
223			->disableOriginalConstructor()
224			->getMock();
225
226			$language = $this->getMockBuilder( '\Language' )
227			->disableOriginalConstructor()
228			->getMock();
229
230			$requestContext = $this->getMockBuilder( '\RequestContext' )
231			->disableOriginalConstructor()
232			->getMock();
233
234			$requestContext->expects( $this->any() )
235			->method( 'getRequest' )
236			->will( $this->returnValue( $webRequest ) );
237
238			$requestContext->expects( $this->any() )
239			->method( 'getLanguage' )
240			->will( $this->returnValue( $language ) );
241
242			$requestContext->expects( $this->any() )
243			->method( 'getTitle' )
244			->will( $this->returnValue( \Title::newFromText( 'Foo' ) ) );
245
246			$outputPage = $this->getMockBuilder( '\OutputPage' )
247			->disableOriginalConstructor()
248			->getMock();
249
250			$outputPage->expects( $this->any() )
251			->method( 'getContext' )
252			->will( $this->returnValue( $requestContext ) );
253
254			$text = '';
255
256			$this->assertThatHookIsExcutable(
257			$instance->getHandlerFor( $hook ),
258			array( &$outputPage, &$text )
259			);
260			}
261
262			public function doTestRegisteredUpdateDataBefore( $instance ) {
263
264			$hook = 'SMWStore::updateDataBefore';
265
266			$store = $this->getMockBuilder( '\SMW\Store' )
267			->disableOriginalConstructor()
268			->getMockForAbstractClass();
269
270			$semanticData = $this->getMockBuilder( '\SMW\SemanticData' )
271			->disableOriginalConstructor()
272			->getMock();
273
274			$semanticData->expects( $this->any() )
275			->method( 'getSubject' )
276			->will( $this->returnValue( new DIWikiPage( 'Foo', NS_MAIN ) ) );
277
278			$this->assertTrue(
279			$instance->isRegistered( $hook )
280			);
281
282			$this->assertThatHookIsExcutable(
283			$instance->getHandlerFor( $hook ),
284			array( $store, $semanticData )
285			);
286			}
287
288			public function doTestRegisteredAddCustomFixedPropertyTables( $instance ) {
289
290			$hook = 'SMW::SQLStore::AddCustomFixedPropertyTables';
291
292			// Contains an extra to ensure previous values are not nullified
293			$customFixedProperties = array( '_Foo' );
294
295			$this->assertTrue(
296			$instance->isRegistered( $hook )
297			);
298
299			$this->assertThatHookIsExcutable(
300			$instance->getHandlerFor( $hook ),
301			array( &$customFixedProperties )
302			);
303
304			$this->assertCount(
305			11,
306			$customFixedProperties
307			);
308			}
309
310			public function doTestRegisteredResourceLoaderGetConfigVars( $instance ) {
311
312			$hook = 'ResourceLoaderGetConfigVars';
313
314			$this->assertTrue(
315			$instance->isRegistered( $hook )
316			);
317
318			$vars = array();
319
320			$this->assertThatHookIsExcutable(
321			$instance->getHandlerFor( $hook ),
322			array( &$vars )
323			);
324			}
325
326			public function doTestRegisteredParserFirstCallInit( $instance ) {
327
328			$hook = 'ParserFirstCallInit';
329
330			$this->assertTrue(
331			$instance->isRegistered( $hook )
332			);
333
334			$parser = $this->getMockBuilder( '\Parser' )
335			->disableOriginalConstructor()
336			->getMock();
337
338			$this->assertThatHookIsExcutable(
339			$instance->getHandlerFor( $hook ),
340			array( &$parser )
341			);
342			}
343
344			public function doTestRegisteredBeforePageDisplay( $instance ) {
345
346			$hook = 'BeforePageDisplay';
347
348			$this->assertTrue(
349			$instance->isRegistered( $hook )
350			);
351
352			$outputPage = $this->getMockBuilder( '\OutputPage' )
353			->disableOriginalConstructor()
354			->getMock();
355
356			$outputPage->expects( $this->once() )
357			->method( 'getTitle' )
358			->will( $this->returnValue( \Title::newFromText( 'Foo' ) ) );
359
360			$skin = $this->getMockBuilder( '\Skin' )
361			->disableOriginalConstructor()
362			->getMock();
363
364			$this->assertThatHookIsExcutable(
365			$instance->getHandlerFor( $hook ),
366			array( &$outputPage, &$skin )
367			);
368			}
369
370			public function doTestRegisteredBrowseAfterIncomingPropertiesLookupComplete( $instance ) {
371
372			$hook = 'SMW::Browse::AfterIncomingPropertiesLookupComplete';
373
374			$this->assertTrue(
375			$instance->isRegistered( $hook )
376			);
377
378			$semanticData = $this->getMockBuilder( '\SMW\SemanticData' )
379			->disableOriginalConstructor()
380			->getMock();
381
382			$semanticData->expects( $this->once() )
383			->method( 'getSubject' )
384			->will( $this->returnValue( DIWikiPage::newFromText( __METHOD__ ) ) );
385
386			$store = $this->getMockBuilder( '\SMW\Store' )
387			->disableOriginalConstructor()
388			->getMockForAbstractClass();
389
390			$store->expects( $this->once() )
391			->method( 'getSemanticData' )
392			->will( $this->returnValue( $semanticData ) );
393
394			$this->assertThatHookIsExcutable(
395			$instance->getHandlerFor( $hook ),
396			array( $store, $semanticData, null )
397			);
398			}
399
400			public function doTestRegisteredBrowseBeforeIncomingPropertyValuesFurtherLinkCreate( $instance ) {
401
402			$hook = 'SMW::Browse::BeforeIncomingPropertyValuesFurtherLinkCreate';
403
404			$this->assertTrue(
405			$instance->isRegistered( $hook )
406			);
407
408			$property = new DIProperty( 'Foo' );
409			$subject = DIWikiPage::newFromText( __METHOD__ );
410
411			$html = '';
412
413			$this->assertThatHookIsExcutable(
414			$instance->getHandlerFor( $hook ),
415			array( $property, $subject, &$html )
416			);
417			}
418
419			public function doTestRegisteredAfterDataUpdateComplete( $instance ) {
420
421			$hook = 'SMW::SQLStore::AfterDataUpdateComplete';
422
423			$this->assertTrue(
424			$instance->isRegistered( $hook )
425			);
426
427			$semanticData = $this->getMockBuilder( '\SMW\SemanticData' )
428			->disableOriginalConstructor()
429			->getMock();
430
431			$semanticData->expects( $this->once() )
432			->method( 'getSubject' )
433			->will( $this->returnValue( DIWikiPage::newFromText( __METHOD__ ) ) );
434
435			$store = $this->getMockBuilder( '\SMW\SQLStore\SQLStore' )
436			->disableOriginalConstructor()
437			->getMock();
438
439			$compositePropertyTableDiffIterator = $this->getMockBuilder( '\SMW\SQLStore\CompositePropertyTableDiffIterator' )
440			->disableOriginalConstructor()
441			->getMock();
442
443			$this->assertThatHookIsExcutable(
444			$instance->getHandlerFor( $hook ),
445			array( $store, $semanticData, $compositePropertyTableDiffIterator )
446			);
447			}
448
449			public function doTestRegisteredAfterDeleteSubjectComplete( $instance ) {
450
451			$hook = 'SMW::SQLStore::AfterDeleteSubjectComplete';
452
453			$this->assertTrue(
454			$instance->isRegistered( $hook )
455			);
456
457			$store = $this->getMockBuilder( '\SMW\SQLStore\SQLStore' )
458			->disableOriginalConstructor()
459			->getMock();
460
461			$this->assertThatHookIsExcutable(
462			$instance->getHandlerFor( $hook ),
463			array( $store, \Title::newFromText( 'Foo' ) )
464			);
465			}
466
467			private function assertThatHookIsExcutable( \Closure $handler, $arguments = array() ) {
468			$this->assertInternalType(
469			'boolean',
470			call_user_func_array( $handler, $arguments )
471			);
472			}
473
474			}
475

SemanticMediaWiki / SemanticCite

Push — master ( 079bf8...76aa3a )

HookRegistryTest::testOnBeforeConfigCompletion() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like