dépôts / lhc / web / wiklou.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Add some missing @covers tags
[lhc/web/wiklou.git] / tests / phpunit / includes / OutputPageTest.php
1 <?php
2
3 use Wikimedia\TestingAccessWrapper;
4
5 /**
6 * @author Matthew Flaschen
7 *
8 * @group Database
9 * @group Output
10 */
11 class OutputPageTest extends MediaWikiTestCase {
12 const SCREEN_MEDIA_QUERY = 'screen and (min-width: 982px)';
13 const SCREEN_ONLY_MEDIA_QUERY = 'only screen and (min-width: 982px)';
14
15 // Ensure that we don't affect the global ResourceLoader state.
16 protected function setUp() {
17 parent::setUp();
18 ResourceLoader::clearCache();
19 }
20 protected function tearDown() {
21 parent::tearDown();
22 ResourceLoader::clearCache();
23 }
24
25 /**
26 * @dataProvider provideRedirect
27 *
28 * @covers OutputPage::__construct
29 * @covers OutputPage::redirect
30 * @covers OutputPage::getRedirect
31 */
32 public function testRedirect( $url, $code = null ) {
33 $op = $this->newInstance();
34 if ( isset( $code ) ) {
35 $op->redirect( $url, $code );
36 } else {
37 $op->redirect( $url );
38 }
39 $expectedUrl = str_replace( "\n", '', $url );
40 $this->assertSame( $expectedUrl, $op->getRedirect() );
41 $this->assertSame( $expectedUrl, $op->mRedirect );
42 $this->assertSame( $code ?? '302', $op->mRedirectCode );
43 }
44
45 public function provideRedirect() {
46 return [
47 [ 'http://example.com' ],
48 [ 'http://example.com', '400' ],
49 [ 'http://example.com', 'squirrels!!!' ],
50 [ "a\nb" ],
51 ];
52 }
53
54 /**
55 * @covers OutputPage::setCopyrightUrl
56 * @covers OutputPage::getHeadLinksArray
57 */
58 public function testSetCopyrightUrl() {
59 $op = $this->newInstance();
60 $op->setCopyrightUrl( 'http://example.com' );
61
62 $this->assertSame(
63 Html::element( 'link', [ 'rel' => 'license', 'href' => 'http://example.com' ] ),
64 $op->getHeadLinksArray()['copyright']
65 );
66 }
67
68 // @todo How to test setStatusCode?
69
70 /**
71 * @covers OutputPage::addMeta
72 * @covers OutputPage::getMetaTags
73 * @covers OutputPage::getHeadLinksArray
74 */
75 public function testMetaTags() {
76 $op = $this->newInstance();
77 $op->addMeta( 'http:expires', '0' );
78 $op->addMeta( 'keywords', 'first' );
79 $op->addMeta( 'keywords', 'second' );
80 $op->addMeta( 'og:title', 'Ta-duh' );
81
82 $expected = [
83 [ 'http:expires', '0' ],
84 [ 'keywords', 'first' ],
85 [ 'keywords', 'second' ],
86 [ 'og:title', 'Ta-duh' ],
87 ];
88 $this->assertSame( $expected, $op->getMetaTags() );
89
90 $links = $op->getHeadLinksArray();
91 $this->assertContains( '<meta http-equiv="expires" content="0"/>', $links );
92 $this->assertContains( '<meta name="keywords" content="first"/>', $links );
93 $this->assertContains( '<meta name="keywords" content="second"/>', $links );
94 $this->assertContains( '<meta property="og:title" content="Ta-duh"/>', $links );
95 $this->assertArrayNotHasKey( 'meta-robots', $links );
96 }
97
98 /**
99 * @covers OutputPage::addLink
100 * @covers OutputPage::getLinkTags
101 * @covers OutputPage::getHeadLinksArray
102 */
103 public function testAddLink() {
104 $op = $this->newInstance();
105
106 $links = [
107 [],
108 [ 'rel' => 'foo', 'href' => 'http://example.com' ],
109 ];
110
111 foreach ( $links as $link ) {
112 $op->addLink( $link );
113 }
114
115 $this->assertSame( $links, $op->getLinkTags() );
116
117 $result = $op->getHeadLinksArray();
118
119 foreach ( $links as $link ) {
120 $this->assertContains( Html::element( 'link', $link ), $result );
121 }
122 }
123
124 /**
125 * @covers OutputPage::setCanonicalUrl
126 * @covers OutputPage::getCanonicalUrl
127 * @covers OutputPage::getHeadLinksArray
128 */
129 public function testSetCanonicalUrl() {
130 $op = $this->newInstance();
131 $op->setCanonicalUrl( 'http://example.comm' );
132 $op->setCanonicalUrl( 'http://example.com' );
133
134 $this->assertSame( 'http://example.com', $op->getCanonicalUrl() );
135
136 $headLinks = $op->getHeadLinksArray();
137
138 $this->assertContains( Html::element( 'link', [
139 'rel' => 'canonical', 'href' => 'http://example.com'
140 ] ), $headLinks );
141
142 $this->assertNotContains( Html::element( 'link', [
143 'rel' => 'canonical', 'href' => 'http://example.comm'
144 ] ), $headLinks );
145 }
146
147 /**
148 * @covers OutputPage::addScript
149 */
150 public function testAddScript() {
151 $op = $this->newInstance();
152 $op->addScript( 'some random string' );
153
154 $this->assertContains( "\nsome random string\n", "\n" . $op->getBottomScripts() . "\n" );
155 }
156
157 /**
158 * @covers OutputPage::addScriptFile
159 */
160 public function testAddScriptFile() {
161 $op = $this->newInstance();
162 $op->addScriptFile( '/somescript.js' );
163 $op->addScriptFile( '//example.com/somescript.js' );
164
165 $this->assertContains(
166 "\n" . Html::linkedScript( '/somescript.js', $op->getCSPNonce() ) .
167 Html::linkedScript( '//example.com/somescript.js', $op->getCSPNonce() ) . "\n",
168 "\n" . $op->getBottomScripts() . "\n"
169 );
170 }
171
172 /**
173 * Test that addScriptFile() throws due to deprecation.
174 *
175 * @covers OutputPage::addScriptFile
176 */
177 public function testAddDeprecatedScriptFileWarning() {
178 $this->setExpectedException( PHPUnit_Framework_Error_Deprecated::class,
179 'Use of OutputPage::addScriptFile was deprecated in MediaWiki 1.24.' );
180
181 $op = $this->newInstance();
182 $op->addScriptFile( 'ignored-script.js' );
183 }
184
185 /**
186 * Test the actual behavior of the method (in the case where it doesn't throw, e.g., in
187 * production).
188 *
189 * @covers OutputPage::addScriptFile
190 */
191 public function testAddDeprecatedScriptFileNoOp() {
192 $this->hideDeprecated( 'OutputPage::addScriptFile' );
193 $op = $this->newInstance();
194 $op->addScriptFile( 'ignored-script.js' );
195
196 $this->assertNotContains( 'ignored-script.js', '' . $op->getBottomScripts() );
197 }
198
199 /**
200 * @covers OutputPage::addInlineScript
201 */
202 public function testAddInlineScript() {
203 $op = $this->newInstance();
204 $op->addInlineScript( 'let foo = "bar";' );
205 $op->addInlineScript( 'alert( foo );' );
206
207 $this->assertContains(
208 "\n" . Html::inlineScript( "\nlet foo = \"bar\";\n", $op->getCSPNonce() ) . "\n" .
209 Html::inlineScript( "\nalert( foo );\n", $op->getCSPNonce() ) . "\n",
210 "\n" . $op->getBottomScripts() . "\n"
211 );
212 }
213
214 // @todo How to test filterModules(), warnModuleTargetFilter(), getModules(), etc.?
215
216 /**
217 * @covers OutputPage::getTarget
218 * @covers OutputPage::setTarget
219 */
220 public function testSetTarget() {
221 $op = $this->newInstance();
222 $op->setTarget( 'foo' );
223
224 $this->assertSame( 'foo', $op->getTarget() );
225 // @todo What else? Test some actual effect?
226 }
227
228 // @todo How to test addContentOverride(Callback)?
229
230 /**
231 * @covers OutputPage::getHeadItemsArray
232 * @covers OutputPage::addHeadItem
233 * @covers OutputPage::addHeadItems
234 * @covers OutputPage::hasHeadItem
235 */
236 public function testHeadItems() {
237 $op = $this->newInstance();
238 $op->addHeadItem( 'a', 'b' );
239 $op->addHeadItems( [ 'c' => '<d>&amp;', 'e' => 'f', 'a' => 'q' ] );
240 $op->addHeadItem( 'e', 'g' );
241 $op->addHeadItems( 'x' );
242
243 $this->assertSame( [ 'a' => 'q', 'c' => '<d>&amp;', 'e' => 'g', 'x' ],
244 $op->getHeadItemsArray() );
245
246 $this->assertTrue( $op->hasHeadItem( 'a' ) );
247 $this->assertTrue( $op->hasHeadItem( 'c' ) );
248 $this->assertTrue( $op->hasHeadItem( 'e' ) );
249 $this->assertTrue( $op->hasHeadItem( '0' ) );
250
251 $this->assertContains( "\nq\n<d>&amp;\ng\nx\n",
252 '' . $op->headElement( $op->getContext()->getSkin() ) );
253 }
254
255 /**
256 * @covers OutputPage::getHeadItemsArray
257 * @covers OutputPage::addParserOutputMetadata
258 * @covers OutputPage::addParserOutput
259 */
260 public function testHeadItemsParserOutput() {
261 $op = $this->newInstance();
262 $stubPO1 = $this->createParserOutputStub( 'getHeadItems', [ 'a' => 'b' ] );
263 $op->addParserOutputMetadata( $stubPO1 );
264 $stubPO2 = $this->createParserOutputStub( 'getHeadItems',
265 [ 'c' => '<d>&amp;', 'e' => 'f', 'a' => 'q' ] );
266 $op->addParserOutputMetadata( $stubPO2 );
267 $stubPO3 = $this->createParserOutputStub( 'getHeadItems', [ 'e' => 'g' ] );
268 $op->addParserOutput( $stubPO3 );
269 $stubPO4 = $this->createParserOutputStub( 'getHeadItems', [ 'x' ] );
270 $op->addParserOutputMetadata( $stubPO4 );
271
272 $this->assertSame( [ 'a' => 'q', 'c' => '<d>&amp;', 'e' => 'g', 'x' ],
273 $op->getHeadItemsArray() );
274
275 $this->assertTrue( $op->hasHeadItem( 'a' ) );
276 $this->assertTrue( $op->hasHeadItem( 'c' ) );
277 $this->assertTrue( $op->hasHeadItem( 'e' ) );
278 $this->assertTrue( $op->hasHeadItem( '0' ) );
279 $this->assertFalse( $op->hasHeadItem( 'b' ) );
280
281 $this->assertContains( "\nq\n<d>&amp;\ng\nx\n",
282 '' . $op->headElement( $op->getContext()->getSkin() ) );
283 }
284
285 /**
286 * @covers OutputPage::addBodyClasses
287 */
288 public function testAddBodyClasses() {
289 $op = $this->newInstance();
290 $op->addBodyClasses( 'a' );
291 $op->addBodyClasses( 'mediawiki' );
292 $op->addBodyClasses( 'b c' );
293 $op->addBodyClasses( [ 'd', 'e' ] );
294 $op->addBodyClasses( 'a' );
295
296 $this->assertContains( '"a mediawiki b c d e ltr',
297 '' . $op->headElement( $op->getContext()->getSkin() ) );
298 }
299
300 /**
301 * @covers OutputPage::setArticleBodyOnly
302 * @covers OutputPage::getArticleBodyOnly
303 */
304 public function testArticleBodyOnly() {
305 $op = $this->newInstance();
306 $this->assertFalse( $op->getArticleBodyOnly() );
307
308 $op->setArticleBodyOnly( true );
309 $this->assertTrue( $op->getArticleBodyOnly() );
310
311 $op->addHTML( '<b>a</b>' );
312
313 $this->assertSame( '<b>a</b>', $op->output( true ) );
314 }
315
316 /**
317 * @covers OutputPage::setProperty
318 * @covers OutputPage::getProperty
319 */
320 public function testProperties() {
321 $op = $this->newInstance();
322
323 $this->assertNull( $op->getProperty( 'foo' ) );
324
325 $op->setProperty( 'foo', 'bar' );
326 $op->setProperty( 'baz', 'quz' );
327
328 $this->assertSame( 'bar', $op->getProperty( 'foo' ) );
329 $this->assertSame( 'quz', $op->getProperty( 'baz' ) );
330 }
331
332 /**
333 * @dataProvider provideCheckLastModified
334 *
335 * @covers OutputPage::checkLastModified
336 * @covers OutputPage::getCdnCacheEpoch
337 */
338 public function testCheckLastModified(
339 $timestamp, $ifModifiedSince, $expected, $config = [], $callback = null
340 ) {
341 $request = new FauxRequest();
342 if ( $ifModifiedSince ) {
343 if ( is_numeric( $ifModifiedSince ) ) {
344 // Unix timestamp
345 $ifModifiedSince = date( 'D, d M Y H:i:s', $ifModifiedSince ) . ' GMT';
346 }
347 $request->setHeader( 'If-Modified-Since', $ifModifiedSince );
348 }
349
350 if ( !isset( $config['CacheEpoch'] ) ) {
351 // Make sure it's not too recent
352 $config['CacheEpoch'] = '20000101000000';
353 }
354
355 $op = $this->newInstance( $config, $request );
356
357 if ( $callback ) {
358 $callback( $op, $this );
359 }
360
361 // Avoid a complaint about not being able to disable compression
362 Wikimedia\suppressWarnings();
363 try {
364 $this->assertEquals( $expected, $op->checkLastModified( $timestamp ) );
365 } finally {
366 Wikimedia\restoreWarnings();
367 }
368 }
369
370 public function provideCheckLastModified() {
371 $lastModified = time() - 3600;
372 return [
373 'Timestamp 0' =>
374 [ '0', $lastModified, false ],
375 'Timestamp Unix epoch' =>
376 [ '19700101000000', $lastModified, false ],
377 'Timestamp same as If-Modified-Since' =>
378 [ $lastModified, $lastModified, true ],
379 'Timestamp one second after If-Modified-Since' =>
380 [ $lastModified + 1, $lastModified, false ],
381 'No If-Modified-Since' =>
382 [ $lastModified + 1, null, false ],
383 'Malformed If-Modified-Since' =>
384 [ $lastModified + 1, 'GIBBERING WOMBATS !!!', false ],
385 'Non-standard IE-style If-Modified-Since' =>
386 [ $lastModified, date( 'D, d M Y H:i:s', $lastModified ) . ' GMT; length=5202',
387 true ],
388 // @todo Should we fix this behavior to match the spec? Probably no reason to.
389 'If-Modified-Since not per spec but we accept it anyway because strtotime does' =>
390 [ $lastModified, "@$lastModified", true ],
391 '$wgCachePages = false' =>
392 [ $lastModified, $lastModified, false, [ 'CachePages' => false ] ],
393 '$wgCacheEpoch' =>
394 [ $lastModified, $lastModified, false,
395 [ 'CacheEpoch' => wfTimestamp( TS_MW, $lastModified + 1 ) ] ],
396 'Recently-touched user' =>
397 [ $lastModified, $lastModified, false, [],
398 function ( $op ) {
399 $op->getContext()->setUser( $this->getTestUser()->getUser() );
400 } ],
401 'After Squid expiry' =>
402 [ $lastModified, $lastModified, false,
403 [ 'UseSquid' => true, 'SquidMaxage' => 3599 ] ],
404 'Hook allows cache use' =>
405 [ $lastModified + 1, $lastModified, true, [],
406 function ( $op, $that ) {
407 $that->setTemporaryHook( 'OutputPageCheckLastModified',
408 function ( &$modifiedTimes ) {
409 $modifiedTimes = [ 1 ];
410 }
411 );
412 } ],
413 'Hooks prohibits cache use' =>
414 [ $lastModified, $lastModified, false, [],
415 function ( $op, $that ) {
416 $that->setTemporaryHook( 'OutputPageCheckLastModified',
417 function ( &$modifiedTimes ) {
418 $modifiedTimes = [ max( $modifiedTimes ) + 1 ];
419 }
420 );
421 } ],
422 ];
423 }
424
425 /**
426 * @dataProvider provideCdnCacheEpoch
427 *
428 * @covers OutputPage::getCdnCacheEpoch
429 */
430 public function testCdnCacheEpoch( $params ) {
431 $out = TestingAccessWrapper::newFromObject( $this->newInstance() );
432 $reqTime = strtotime( $params['reqTime'] );
433 $pageTime = strtotime( $params['pageTime'] );
434 $actual = max( $pageTime, $out->getCdnCacheEpoch( $reqTime, $params['maxAge'] ) );
435
436 $this->assertEquals(
437 $params['expect'],
438 gmdate( DateTime::ATOM, $actual ),
439 'cdn epoch'
440 );
441 }
442
443 public static function provideCdnCacheEpoch() {
444 $base = [
445 'pageTime' => '2011-04-01T12:00:00+00:00',
446 'maxAge' => 24 * 3600,
447 ];
448 return [
449 'after 1s' => [ $base + [
450 'reqTime' => '2011-04-01T12:00:01+00:00',
451 'expect' => '2011-04-01T12:00:00+00:00',
452 ] ],
453 'after 23h' => [ $base + [
454 'reqTime' => '2011-04-02T11:00:00+00:00',
455 'expect' => '2011-04-01T12:00:00+00:00',
456 ] ],
457 'after 24h and a bit' => [ $base + [
458 'reqTime' => '2011-04-02T12:34:56+00:00',
459 'expect' => '2011-04-01T12:34:56+00:00',
460 ] ],
461 'after a year' => [ $base + [
462 'reqTime' => '2012-05-06T00:12:07+00:00',
463 'expect' => '2012-05-05T00:12:07+00:00',
464 ] ],
465 ];
466 }
467
468 // @todo How to test setLastModified?
469
470 /**
471 * @covers OutputPage::setRobotPolicy
472 * @covers OutputPage::getHeadLinksArray
473 */
474 public function testSetRobotPolicy() {
475 $op = $this->newInstance();
476 $op->setRobotPolicy( 'noindex, nofollow' );
477
478 $links = $op->getHeadLinksArray();
479 $this->assertContains( '<meta name="robots" content="noindex,nofollow"/>', $links );
480 }
481
482 /**
483 * @covers OutputPage::setIndexPolicy
484 * @covers OutputPage::setFollowPolicy
485 * @covers OutputPage::getHeadLinksArray
486 */
487 public function testSetIndexFollowPolicies() {
488 $op = $this->newInstance();
489 $op->setIndexPolicy( 'noindex' );
490 $op->setFollowPolicy( 'nofollow' );
491
492 $links = $op->getHeadLinksArray();
493 $this->assertContains( '<meta name="robots" content="noindex,nofollow"/>', $links );
494 }
495
496 private function extractHTMLTitle( OutputPage $op ) {
497 $html = $op->headElement( $op->getContext()->getSkin() );
498
499 // OutputPage should always output the title in a nice format such that regexes will work
500 // fine. If it doesn't, we'll fail the tests.
501 preg_match_all( '!<title>(.*?)</title>!', $html, $matches );
502
503 $this->assertLessThanOrEqual( 1, count( $matches[1] ), 'More than one <title>!' );
504
505 if ( !count( $matches[1] ) ) {
506 return null;
507 }
508
509 return $matches[1][0];
510 }
511
512 /**
513 * Shorthand for getting the text of a message, in content language.
514 */
515 private static function getMsgText( $op, ...$msgParams ) {
516 return $op->msg( ...$msgParams )->inContentLanguage()->text();
517 }
518
519 /**
520 * @covers OutputPage::setHTMLTitle
521 * @covers OutputPage::getHTMLTitle
522 */
523 public function testHTMLTitle() {
524 $op = $this->newInstance();
525
526 // Default
527 $this->assertSame( '', $op->getHTMLTitle() );
528 $this->assertSame( '', $op->getPageTitle() );
529 $this->assertSame(
530 $this->getMsgText( $op, 'pagetitle', '' ),
531 $this->extractHTMLTitle( $op )
532 );
533
534 // Set to string
535 $op->setHTMLTitle( 'Potatoes will eat me' );
536
537 $this->assertSame( 'Potatoes will eat me', $op->getHTMLTitle() );
538 $this->assertSame( 'Potatoes will eat me', $this->extractHTMLTitle( $op ) );
539 // Shouldn't have changed the page title
540 $this->assertSame( '', $op->getPageTitle() );
541
542 // Set to message
543 $msg = $op->msg( 'mainpage' );
544
545 $op->setHTMLTitle( $msg );
546 $this->assertSame( $msg->text(), $op->getHTMLTitle() );
547 $this->assertSame( $msg->text(), $this->extractHTMLTitle( $op ) );
548 $this->assertSame( '', $op->getPageTitle() );
549 }
550
551 /**
552 * @covers OutputPage::setRedirectedFrom
553 */
554 public function testSetRedirectedFrom() {
555 $op = $this->newInstance();
556
557 $op->setRedirectedFrom( Title::newFromText( 'Talk:Some page' ) );
558 $this->assertSame( 'Talk:Some_page', $op->getJSVars()['wgRedirectedFrom'] );
559 }
560
561 /**
562 * @covers OutputPage::setPageTitle
563 * @covers OutputPage::getPageTitle
564 */
565 public function testPageTitle() {
566 // We don't test the actual HTML output anywhere, because that's up to the skin.
567 $op = $this->newInstance();
568
569 // Test default
570 $this->assertSame( '', $op->getPageTitle() );
571 $this->assertSame( '', $op->getHTMLTitle() );
572
573 // Test set to plain text
574 $op->setPageTitle( 'foobar' );
575
576 $this->assertSame( 'foobar', $op->getPageTitle() );
577 // HTML title should change as well
578 $this->assertSame( $this->getMsgText( $op, 'pagetitle', 'foobar' ), $op->getHTMLTitle() );
579
580 // Test set to text with good and bad HTML. We don't try to be comprehensive here, that
581 // belongs in Sanitizer tests.
582 $op->setPageTitle( '<script>a</script>&amp;<i>b</i>' );
583
584 $this->assertSame( '&lt;script&gt;a&lt;/script&gt;&amp;<i>b</i>', $op->getPageTitle() );
585 $this->assertSame(
586 $this->getMsgText( $op, 'pagetitle', '<script>a</script>&b' ),
587 $op->getHTMLTitle()
588 );
589
590 // Test set to message
591 $text = $this->getMsgText( $op, 'mainpage' );
592
593 $op->setPageTitle( $op->msg( 'mainpage' )->inContentLanguage() );
594 $this->assertSame( $text, $op->getPageTitle() );
595 $this->assertSame( $this->getMsgText( $op, 'pagetitle', $text ), $op->getHTMLTitle() );
596 }
597
598 /**
599 * @covers OutputPage::setTitle
600 */
601 public function testSetTitle() {
602 $op = $this->newInstance();
603
604 $this->assertSame( 'My test page', $op->getTitle()->getPrefixedText() );
605
606 $op->setTitle( Title::newFromText( 'Another test page' ) );
607
608 $this->assertSame( 'Another test page', $op->getTitle()->getPrefixedText() );
609 }
610
611 /**
612 * @covers OutputPage::setSubtitle
613 * @covers OutputPage::clearSubtitle
614 * @covers OutputPage::addSubtitle
615 * @covers OutputPage::getSubtitle
616 */
617 public function testSubtitle() {
618 $op = $this->newInstance();
619
620 $this->assertSame( '', $op->getSubtitle() );
621
622 $op->addSubtitle( '<b>foo</b>' );
623
624 $this->assertSame( '<b>foo</b>', $op->getSubtitle() );
625
626 $op->addSubtitle( $op->msg( 'mainpage' )->inContentLanguage() );
627
628 $this->assertSame(
629 "<b>foo</b><br />\n\t\t\t\t" . $this->getMsgText( $op, 'mainpage' ),
630 $op->getSubtitle()
631 );
632
633 $op->setSubtitle( 'There can be only one' );
634
635 $this->assertSame( 'There can be only one', $op->getSubtitle() );
636
637 $op->clearSubtitle();
638
639 $this->assertSame( '', $op->getSubtitle() );
640 }
641
642 /**
643 * @dataProvider provideBacklinkSubtitle
644 *
645 * @covers OutputPage::buildBacklinkSubtitle
646 */
647 public function testBuildBacklinkSubtitle( $titles, $queries, $contains, $notContains ) {
648 if ( count( $titles ) > 1 ) {
649 // Not applicable
650 $this->assertTrue( true );
651 return;
652 }
653
654 $title = Title::newFromText( $titles[0] );
655 $query = $queries[0];
656
657 $this->editPage( 'Page 1', '' );
658 $this->editPage( 'Page 2', '#REDIRECT [[Page 1]]' );
659
660 $str = OutputPage::buildBacklinkSubtitle( $title, $query )->text();
661
662 foreach ( $contains as $substr ) {
663 $this->assertContains( $substr, $str );
664 }
665
666 foreach ( $notContains as $substr ) {
667 $this->assertNotContains( $substr, $str );
668 }
669 }
670
671 /**
672 * @dataProvider provideBacklinkSubtitle
673 *
674 * @covers OutputPage::addBacklinkSubtitle
675 * @covers OutputPage::getSubtitle
676 */
677 public function testAddBacklinkSubtitle( $titles, $queries, $contains, $notContains ) {
678 $this->editPage( 'Page 1', '' );
679 $this->editPage( 'Page 2', '#REDIRECT [[Page 1]]' );
680
681 $op = $this->newInstance();
682 foreach ( $titles as $i => $unused ) {
683 $op->addBacklinkSubtitle( Title::newFromText( $titles[$i] ), $queries[$i] );
684 }
685
686 $str = $op->getSubtitle();
687
688 foreach ( $contains as $substr ) {
689 $this->assertContains( $substr, $str );
690 }
691
692 foreach ( $notContains as $substr ) {
693 $this->assertNotContains( $substr, $str );
694 }
695 }
696
697 public function provideBacklinkSubtitle() {
698 return [
699 [
700 [ 'Page 1' ],
701 [ [] ],
702 [ 'Page 1' ],
703 [ 'redirect', 'Page 2' ],
704 ],
705 [
706 [ 'Page 2' ],
707 [ [] ],
708 [ 'redirect=no' ],
709 [ 'Page 1' ],
710 ],
711 [
712 [ 'Page 1' ],
713 [ [ 'action' => 'edit' ] ],
714 [ 'action=edit' ],
715 [],
716 ],
717 [
718 [ 'Page 1', 'Page 2' ],
719 [ [], [] ],
720 [ 'Page 1', 'Page 2', "<br />\n\t\t\t\t" ],
721 [],
722 ],
723 // @todo Anything else to test?
724 ];
725 }
726
727 /**
728 * @covers OutputPage::setPrintable
729 * @covers OutputPage::isPrintable
730 */
731 public function testPrintable() {
732 $op = $this->newInstance();
733
734 $this->assertFalse( $op->isPrintable() );
735
736 $op->setPrintable();
737
738 $this->assertTrue( $op->isPrintable() );
739 }
740
741 /**
742 * @covers OutputPage::disable
743 * @covers OutputPage::isDisabled
744 */
745 public function testDisable() {
746 $op = $this->newInstance();
747
748 $this->assertFalse( $op->isDisabled() );
749 $this->assertNotSame( '', $op->output( true ) );
750
751 $op->disable();
752
753 $this->assertTrue( $op->isDisabled() );
754 $this->assertSame( '', $op->output( true ) );
755 }
756
757 /**
758 * @covers OutputPage::showNewSectionLink
759 * @covers OutputPage::addParserOutputMetadata
760 * @covers OutputPage::addParserOutput
761 */
762 public function testShowNewSectionLink() {
763 $op = $this->newInstance();
764
765 $this->assertFalse( $op->showNewSectionLink() );
766
767 $pOut1 = $this->createParserOutputStub( 'getNewSection', true );
768 $op->addParserOutputMetadata( $pOut1 );
769 $this->assertTrue( $op->showNewSectionLink() );
770
771 $pOut2 = $this->createParserOutputStub( 'getNewSection', false );
772 $op->addParserOutput( $pOut2 );
773 $this->assertFalse( $op->showNewSectionLink() );
774 }
775
776 /**
777 * @covers OutputPage::forceHideNewSectionLink
778 * @covers OutputPage::addParserOutputMetadata
779 * @covers OutputPage::addParserOutput
780 */
781 public function testForceHideNewSectionLink() {
782 $op = $this->newInstance();
783
784 $this->assertFalse( $op->forceHideNewSectionLink() );
785
786 $pOut1 = $this->createParserOutputStub( 'getHideNewSection', true );
787 $op->addParserOutputMetadata( $pOut1 );
788 $this->assertTrue( $op->forceHideNewSectionLink() );
789
790 $pOut2 = $this->createParserOutputStub( 'getHideNewSection', false );
791 $op->addParserOutput( $pOut2 );
792 $this->assertFalse( $op->forceHideNewSectionLink() );
793 }
794
795 /**
796 * @covers OutputPage::setSyndicated
797 * @covers OutputPage::isSyndicated
798 */
799 public function testSetSyndicated() {
800 $op = $this->newInstance();
801 $this->assertFalse( $op->isSyndicated() );
802
803 $op->setSyndicated();
804 $this->assertTrue( $op->isSyndicated() );
805
806 $op->setSyndicated( false );
807 $this->assertFalse( $op->isSyndicated() );
808 }
809
810 /**
811 * @covers OutputPage::isSyndicated
812 * @covers OutputPage::setFeedAppendQuery
813 * @covers OutputPage::addFeedLink
814 * @covers OutputPage::getSyndicationLinks()
815 */
816 public function testFeedLinks() {
817 $op = $this->newInstance();
818 $this->assertSame( [], $op->getSyndicationLinks() );
819
820 $op->addFeedLink( 'not a supported format', 'abc' );
821 $this->assertFalse( $op->isSyndicated() );
822 $this->assertSame( [], $op->getSyndicationLinks() );
823
824 $feedTypes = $op->getConfig()->get( 'AdvertisedFeedTypes' );
825
826 $op->addFeedLink( $feedTypes[0], 'def' );
827 $this->assertTrue( $op->isSyndicated() );
828 $this->assertSame( [ $feedTypes[0] => 'def' ], $op->getSyndicationLinks() );
829
830 $op->setFeedAppendQuery( false );
831 $expected = [];
832 foreach ( $feedTypes as $type ) {
833 $expected[$type] = $op->getTitle()->getLocalURL( "feed=$type" );
834 }
835 $this->assertSame( $expected, $op->getSyndicationLinks() );
836
837 $op->setFeedAppendQuery( 'apples=oranges' );
838 foreach ( $feedTypes as $type ) {
839 $expected[$type] = $op->getTitle()->getLocalURL( "feed=$type&apples=oranges" );
840 }
841 $this->assertSame( $expected, $op->getSyndicationLinks() );
842 }
843
844 /**
845 * @covers OutputPage::setArticleFlag
846 * @covers OutputPage::isArticle
847 * @covers OutputPage::setArticleRelated
848 * @covers OutputPage::isArticleRelated
849 */
850 function testArticleFlags() {
851 $op = $this->newInstance();
852 $this->assertFalse( $op->isArticle() );
853 $this->assertTrue( $op->isArticleRelated() );
854
855 $op->setArticleRelated( false );
856 $this->assertFalse( $op->isArticle() );
857 $this->assertFalse( $op->isArticleRelated() );
858
859 $op->setArticleFlag( true );
860 $this->assertTrue( $op->isArticle() );
861 $this->assertTrue( $op->isArticleRelated() );
862
863 $op->setArticleFlag( false );
864 $this->assertFalse( $op->isArticle() );
865 $this->assertTrue( $op->isArticleRelated() );
866
867 $op->setArticleFlag( true );
868 $op->setArticleRelated( false );
869 $this->assertFalse( $op->isArticle() );
870 $this->assertFalse( $op->isArticleRelated() );
871 }
872
873 /**
874 * @covers OutputPage::addLanguageLinks
875 * @covers OutputPage::setLanguageLinks
876 * @covers OutputPage::getLanguageLinks
877 * @covers OutputPage::addParserOutputMetadata
878 * @covers OutputPage::addParserOutput
879 */
880 function testLanguageLinks() {
881 $op = $this->newInstance();
882 $this->assertSame( [], $op->getLanguageLinks() );
883
884 $op->addLanguageLinks( [ 'fr:A', 'it:B' ] );
885 $this->assertSame( [ 'fr:A', 'it:B' ], $op->getLanguageLinks() );
886
887 $op->addLanguageLinks( [ 'de:C', 'es:D' ] );
888 $this->assertSame( [ 'fr:A', 'it:B', 'de:C', 'es:D' ], $op->getLanguageLinks() );
889
890 $op->setLanguageLinks( [ 'pt:E' ] );
891 $this->assertSame( [ 'pt:E' ], $op->getLanguageLinks() );
892
893 $pOut1 = $this->createParserOutputStub( 'getLanguageLinks', [ 'he:F', 'ar:G' ] );
894 $op->addParserOutputMetadata( $pOut1 );
895 $this->assertSame( [ 'pt:E', 'he:F', 'ar:G' ], $op->getLanguageLinks() );
896
897 $pOut2 = $this->createParserOutputStub( 'getLanguageLinks', [ 'pt:H' ] );
898 $op->addParserOutput( $pOut2 );
899 $this->assertSame( [ 'pt:E', 'he:F', 'ar:G', 'pt:H' ], $op->getLanguageLinks() );
900 }
901
902 // @todo Are these category links tests too abstract and complicated for what they test? Would
903 // it make sense to just write out all the tests by hand with maybe some copy-and-paste?
904
905 /**
906 * @dataProvider provideGetCategories
907 *
908 * @covers OutputPage::addCategoryLinks
909 * @covers OutputPage::getCategories
910 * @covers OutputPage::getCategoryLinks
911 *
912 * @param array $args Array of form [ category name => sort key ]
913 * @param array $fakeResults Array of form [ category name => value to return from mocked
914 * LinkBatch ]
915 * @param callback $variantLinkCallback Callback to replace findVariantLink() call
916 * @param array $expectedNormal Expected return value of getCategoryLinks['normal']
917 * @param array $expectedHidden Expected return value of getCategoryLinks['hidden']
918 */
919 public function testAddCategoryLinks(
920 array $args, array $fakeResults, callable $variantLinkCallback = null,
921 array $expectedNormal, array $expectedHidden
922 ) {
923 $expectedNormal = $this->extractExpectedCategories( $expectedNormal, 'add' );
924 $expectedHidden = $this->extractExpectedCategories( $expectedHidden, 'add' );
925
926 $op = $this->setupCategoryTests( $fakeResults, $variantLinkCallback );
927
928 $op->addCategoryLinks( $args );
929
930 $this->doCategoryAsserts( $op, $expectedNormal, $expectedHidden );
931 $this->doCategoryLinkAsserts( $op, $expectedNormal, $expectedHidden );
932 }
933
934 /**
935 * @dataProvider provideGetCategories
936 *
937 * @covers OutputPage::addCategoryLinks
938 * @covers OutputPage::getCategories
939 * @covers OutputPage::getCategoryLinks
940 */
941 public function testAddCategoryLinksOneByOne(
942 array $args, array $fakeResults, callable $variantLinkCallback = null,
943 array $expectedNormal, array $expectedHidden
944 ) {
945 if ( count( $args ) <= 1 ) {
946 // @todo Should this be skipped instead of passed?
947 $this->assertTrue( true );
948 return;
949 }
950
951 $expectedNormal = $this->extractExpectedCategories( $expectedNormal, 'onebyone' );
952 $expectedHidden = $this->extractExpectedCategories( $expectedHidden, 'onebyone' );
953
954 $op = $this->setupCategoryTests( $fakeResults, $variantLinkCallback );
955
956 foreach ( $args as $key => $val ) {
957 $op->addCategoryLinks( [ $key => $val ] );
958 }
959
960 $this->doCategoryAsserts( $op, $expectedNormal, $expectedHidden );
961 $this->doCategoryLinkAsserts( $op, $expectedNormal, $expectedHidden );
962 }
963
964 /**
965 * @dataProvider provideGetCategories
966 *
967 * @covers OutputPage::setCategoryLinks
968 * @covers OutputPage::getCategories
969 * @covers OutputPage::getCategoryLinks
970 */
971 public function testSetCategoryLinks(
972 array $args, array $fakeResults, callable $variantLinkCallback = null,
973 array $expectedNormal, array $expectedHidden
974 ) {
975 $expectedNormal = $this->extractExpectedCategories( $expectedNormal, 'set' );
976 $expectedHidden = $this->extractExpectedCategories( $expectedHidden, 'set' );
977
978 $op = $this->setupCategoryTests( $fakeResults, $variantLinkCallback );
979
980 $op->setCategoryLinks( [ 'Initial page' => 'Initial page' ] );
981 $op->setCategoryLinks( $args );
982
983 // We don't reset the categories, for some reason, only the links
984 $expectedNormalCats = array_merge( [ 'Initial page' ], $expectedNormal );
985 $expectedCats = array_merge( $expectedHidden, $expectedNormalCats );
986
987 $this->doCategoryAsserts( $op, $expectedNormalCats, $expectedHidden );
988 $this->doCategoryLinkAsserts( $op, $expectedNormal, $expectedHidden );
989 }
990
991 /**
992 * @dataProvider provideGetCategories
993 *
994 * @covers OutputPage::addParserOutputMetadata
995 * @covers OutputPage::addParserOutput
996 * @covers OutputPage::getCategories
997 * @covers OutputPage::getCategoryLinks
998 */
999 public function testParserOutputCategoryLinks(
1000 array $args, array $fakeResults, callable $variantLinkCallback = null,
1001 array $expectedNormal, array $expectedHidden
1002 ) {
1003 $expectedNormal = $this->extractExpectedCategories( $expectedNormal, 'pout' );
1004 $expectedHidden = $this->extractExpectedCategories( $expectedHidden, 'pout' );
1005
1006 $op = $this->setupCategoryTests( $fakeResults, $variantLinkCallback );
1007
1008 $stubPO = $this->createParserOutputStub( 'getCategories', $args );
1009
1010 // addParserOutput and addParserOutputMetadata should behave identically for us, so
1011 // alternate to get coverage for both without adding extra tests
1012 static $idx = 0;
1013 $idx++;
1014 $method = [ 'addParserOutputMetadata', 'addParserOutput' ][$idx % 2];
1015 $op->$method( $stubPO );
1016
1017 $this->doCategoryAsserts( $op, $expectedNormal, $expectedHidden );
1018 $this->doCategoryLinkAsserts( $op, $expectedNormal, $expectedHidden );
1019 }
1020
1021 /**
1022 * We allow different expectations for different tests as an associative array, like
1023 * [ 'set' => [ ... ], 'default' => [ ... ] ] if setCategoryLinks() will give a different
1024 * result.
1025 */
1026 private function extractExpectedCategories( array $expected, $key ) {
1027 if ( !$expected || isset( $expected[0] ) ) {
1028 return $expected;
1029 }
1030 return $expected[$key] ?? $expected['default'];
1031 }
1032
1033 private function setupCategoryTests(
1034 array $fakeResults, callable $variantLinkCallback = null
1035 ) : OutputPage {
1036 $this->setMwGlobals( 'wgUsePigLatinVariant', true );
1037
1038 $op = $this->getMockBuilder( OutputPage::class )
1039 ->setConstructorArgs( [ new RequestContext() ] )
1040 ->setMethods( [ 'addCategoryLinksToLBAndGetResult', 'getTitle' ] )
1041 ->getMock();
1042
1043 $title = Title::newFromText( 'My test page' );
1044 $op->expects( $this->any() )
1045 ->method( 'getTitle' )
1046 ->will( $this->returnValue( $title ) );
1047
1048 $op->expects( $this->any() )
1049 ->method( 'addCategoryLinksToLBAndGetResult' )
1050 ->will( $this->returnCallback( function ( array $categories ) use ( $fakeResults ) {
1051 $return = [];
1052 foreach ( $categories as $category => $unused ) {
1053 if ( isset( $fakeResults[$category] ) ) {
1054 $return[] = $fakeResults[$category];
1055 }
1056 }
1057 return new FakeResultWrapper( $return );
1058 } ) );
1059
1060 if ( $variantLinkCallback ) {
1061 $mockContLang = $this->getMockBuilder( Language::class )
1062 ->setConstructorArgs( [ 'en' ] )
1063 ->setMethods( [ 'findVariantLink' ] )
1064 ->getMock();
1065 $mockContLang->expects( $this->any() )
1066 ->method( 'findVariantLink' )
1067 ->will( $this->returnCallback( $variantLinkCallback ) );
1068 $this->setContentLang( $mockContLang );
1069 }
1070
1071 $this->assertSame( [], $op->getCategories() );
1072
1073 return $op;
1074 }
1075
1076 private function doCategoryAsserts( $op, $expectedNormal, $expectedHidden ) {
1077 $this->assertSame( array_merge( $expectedHidden, $expectedNormal ), $op->getCategories() );
1078 $this->assertSame( $expectedNormal, $op->getCategories( 'normal' ) );
1079 $this->assertSame( $expectedHidden, $op->getCategories( 'hidden' ) );
1080 }
1081
1082 private function doCategoryLinkAsserts( $op, $expectedNormal, $expectedHidden ) {
1083 $catLinks = $op->getCategoryLinks();
1084 $this->assertSame( (bool)$expectedNormal + (bool)$expectedHidden, count( $catLinks ) );
1085 if ( $expectedNormal ) {
1086 $this->assertSame( count( $expectedNormal ), count( $catLinks['normal'] ) );
1087 }
1088 if ( $expectedHidden ) {
1089 $this->assertSame( count( $expectedHidden ), count( $catLinks['hidden'] ) );
1090 }
1091
1092 foreach ( $expectedNormal as $i => $name ) {
1093 $this->assertContains( $name, $catLinks['normal'][$i] );
1094 }
1095 foreach ( $expectedHidden as $i => $name ) {
1096 $this->assertContains( $name, $catLinks['hidden'][$i] );
1097 }
1098 }
1099
1100 public function provideGetCategories() {
1101 return [
1102 'No categories' => [ [], [], null, [], [] ],
1103 'Simple test' => [
1104 [ 'Test1' => 'Some sortkey', 'Test2' => 'A different sortkey' ],
1105 [ 'Test1' => (object)[ 'pp_value' => 1, 'page_title' => 'Test1' ],
1106 'Test2' => (object)[ 'page_title' => 'Test2' ] ],
1107 null,
1108 [ 'Test2' ],
1109 [ 'Test1' ],
1110 ],
1111 'Invalid title' => [
1112 [ '[' => '[', 'Test' => 'Test' ],
1113 [ 'Test' => (object)[ 'page_title' => 'Test' ] ],
1114 null,
1115 [ 'Test' ],
1116 [],
1117 ],
1118 'Variant link' => [
1119 [ 'Test' => 'Test', 'Estay' => 'Estay' ],
1120 [ 'Test' => (object)[ 'page_title' => 'Test' ] ],
1121 function ( &$link, &$title ) {
1122 if ( $link === 'Estay' ) {
1123 $link = 'Test';
1124 $title = Title::makeTitleSafe( NS_CATEGORY, $link );
1125 }
1126 },
1127 // For adding one by one, the variant gets added as well as the original category,
1128 // but if you add them all together the second time gets skipped.
1129 [ 'onebyone' => [ 'Test', 'Test' ], 'default' => [ 'Test' ] ],
1130 [],
1131 ],
1132 ];
1133 }
1134
1135 /**
1136 * @covers OutputPage::getCategories
1137 */
1138 public function testGetCategoriesInvalid() {
1139 $this->setExpectedException( InvalidArgumentException::class,
1140 'Invalid category type given: hiddne' );
1141
1142 $op = $this->newInstance();
1143 $op->getCategories( 'hiddne' );
1144 }
1145
1146 // @todo Should we test addCategoryLinksToLBAndGetResult? If so, how? Insert some test rows in
1147 // the DB?
1148
1149 /**
1150 * @covers OutputPage::setIndicators
1151 * @covers OutputPage::getIndicators
1152 * @covers OutputPage::addParserOutputMetadata
1153 * @covers OutputPage::addParserOutput
1154 */
1155 public function testIndicators() {
1156 $op = $this->newInstance();
1157 $this->assertSame( [], $op->getIndicators() );
1158
1159 $op->setIndicators( [] );
1160 $this->assertSame( [], $op->getIndicators() );
1161
1162 // Test sorting alphabetically
1163 $op->setIndicators( [ 'b' => 'x', 'a' => 'y' ] );
1164 $this->assertSame( [ 'a' => 'y', 'b' => 'x' ], $op->getIndicators() );
1165
1166 // Test overwriting existing keys
1167 $op->setIndicators( [ 'c' => 'z', 'a' => 'w' ] );
1168 $this->assertSame( [ 'a' => 'w', 'b' => 'x', 'c' => 'z' ], $op->getIndicators() );
1169
1170 // Test with addParserOutputMetadata
1171 $pOut1 = $this->createParserOutputStub( 'getIndicators', [ 'c' => 'u', 'd' => 'v' ] );
1172 $op->addParserOutputMetadata( $pOut1 );
1173 $this->assertSame( [ 'a' => 'w', 'b' => 'x', 'c' => 'u', 'd' => 'v' ],
1174 $op->getIndicators() );
1175
1176 // Test with addParserOutput
1177 $pOut2 = $this->createParserOutputStub( 'getIndicators', [ 'a' => '!!!' ] );
1178 $op->addParserOutput( $pOut2 );
1179 $this->assertSame( [ 'a' => '!!!', 'b' => 'x', 'c' => 'u', 'd' => 'v' ],
1180 $op->getIndicators() );
1181 }
1182
1183 /**
1184 * @covers OutputPage::addHelpLink
1185 * @covers OutputPage::getIndicators
1186 */
1187 public function testAddHelpLink() {
1188 $op = $this->newInstance();
1189
1190 $op->addHelpLink( 'Manual:PHP unit testing' );
1191 $indicators = $op->getIndicators();
1192 $this->assertSame( [ 'mw-helplink' ], array_keys( $indicators ) );
1193 $this->assertContains( 'Manual:PHP_unit_testing', $indicators['mw-helplink'] );
1194
1195 $op->addHelpLink( 'https://phpunit.de', true );
1196 $indicators = $op->getIndicators();
1197 $this->assertSame( [ 'mw-helplink' ], array_keys( $indicators ) );
1198 $this->assertContains( 'https://phpunit.de', $indicators['mw-helplink'] );
1199 $this->assertNotContains( 'mediawiki', $indicators['mw-helplink'] );
1200 $this->assertNotContains( 'Manual:PHP', $indicators['mw-helplink'] );
1201 }
1202
1203 /**
1204 * @covers OutputPage::prependHTML
1205 * @covers OutputPage::addHTML
1206 * @covers OutputPage::addElement
1207 * @covers OutputPage::clearHTML
1208 * @covers OutputPage::getHTML
1209 */
1210 public function testBodyHTML() {
1211 $op = $this->newInstance();
1212 $this->assertSame( '', $op->getHTML() );
1213
1214 $op->addHTML( 'a' );
1215 $this->assertSame( 'a', $op->getHTML() );
1216
1217 $op->addHTML( 'b' );
1218 $this->assertSame( 'ab', $op->getHTML() );
1219
1220 $op->prependHTML( 'c' );
1221 $this->assertSame( 'cab', $op->getHTML() );
1222
1223 $op->addElement( 'p', [ 'id' => 'foo' ], 'd' );
1224 $this->assertSame( 'cab<p id="foo">d</p>', $op->getHTML() );
1225
1226 $op->clearHTML();
1227 $this->assertSame( '', $op->getHTML() );
1228 }
1229
1230 /**
1231 * @dataProvider provideRevisionId
1232 * @covers OutputPage::setRevisionId
1233 * @covers OutputPage::getRevisionId
1234 */
1235 public function testRevisionId( $newVal, $expected ) {
1236 $op = $this->newInstance();
1237
1238 $this->assertNull( $op->setRevisionId( $newVal ) );
1239 $this->assertSame( $expected, $op->getRevisionId() );
1240 $this->assertSame( $expected, $op->setRevisionId( null ) );
1241 $this->assertNull( $op->getRevisionId() );
1242 }
1243
1244 public function provideRevisionId() {
1245 return [
1246 [ null, null ],
1247 [ 7, 7 ],
1248 [ -1, -1 ],
1249 [ 3.2, 3 ],
1250 [ '0', 0 ],
1251 [ '32% finished', 32 ],
1252 [ false, 0 ],
1253 ];
1254 }
1255
1256 /**
1257 * @covers OutputPage::setRevisionTimestamp
1258 * @covers OutputPage::getRevisionTimestamp
1259 */
1260 public function testRevisionTimestamp() {
1261 $op = $this->newInstance();
1262 $this->assertNull( $op->getRevisionTimestamp() );
1263
1264 $this->assertNull( $op->setRevisionTimestamp( 'abc' ) );
1265 $this->assertSame( 'abc', $op->getRevisionTimestamp() );
1266 $this->assertSame( 'abc', $op->setRevisionTimestamp( null ) );
1267 $this->assertNull( $op->getRevisionTimestamp() );
1268 }
1269
1270 /**
1271 * @covers OutputPage::setFileVersion
1272 * @covers OutputPage::getFileVersion
1273 */
1274 public function testFileVersion() {
1275 $op = $this->newInstance();
1276 $this->assertNull( $op->getFileVersion() );
1277
1278 $stubFile = $this->createMock( File::class );
1279 $stubFile->method( 'exists' )->willReturn( true );
1280 $stubFile->method( 'getTimestamp' )->willReturn( '12211221123321' );
1281 $stubFile->method( 'getSha1' )->willReturn( 'bf3ffa7047dc080f5855377a4f83cd18887e3b05' );
1282
1283 $op->setFileVersion( $stubFile );
1284
1285 $this->assertEquals(
1286 [ 'time' => '12211221123321', 'sha1' => 'bf3ffa7047dc080f5855377a4f83cd18887e3b05' ],
1287 $op->getFileVersion()
1288 );
1289
1290 $stubMissingFile = $this->createMock( File::class );
1291 $stubMissingFile->method( 'exists' )->willReturn( false );
1292
1293 $op->setFileVersion( $stubMissingFile );
1294 $this->assertNull( $op->getFileVersion() );
1295
1296 $op->setFileVersion( $stubFile );
1297 $this->assertNotNull( $op->getFileVersion() );
1298
1299 $op->setFileVersion( null );
1300 $this->assertNull( $op->getFileVersion() );
1301 }
1302
1303 /**
1304 * Call either with arguments $methodName, $returnValue; or an array
1305 * [ $methodName => $returnValue, $methodName => $returnValue, ... ]
1306 */
1307 private function createParserOutputStub( ...$args ) {
1308 if ( count( $args ) === 0 ) {
1309 $retVals = [];
1310 } elseif ( count( $args ) === 1 ) {
1311 $retVals = $args[0];
1312 } elseif ( count( $args ) === 2 ) {
1313 $retVals = [ $args[0] => $args[1] ];
1314 }
1315 $pOut = $this->getMock( ParserOutput::class );
1316 foreach ( $retVals as $method => $retVal ) {
1317 $pOut->method( $method )->willReturn( $retVal );
1318 }
1319
1320 $arrayReturningMethods = [
1321 'getCategories',
1322 'getFileSearchOptions',
1323 'getHeadItems',
1324 'getIndicators',
1325 'getLanguageLinks',
1326 'getOutputHooks',
1327 'getTemplateIds',
1328 ];
1329
1330 foreach ( $arrayReturningMethods as $method ) {
1331 $pOut->method( $method )->willReturn( [] );
1332 }
1333
1334 return $pOut;
1335 }
1336
1337 /**
1338 * @covers OutputPage::getTemplateIds
1339 * @covers OutputPage::addParserOutputMetadata
1340 * @covers OutputPage::addParserOutput
1341 */
1342 public function testTemplateIds() {
1343 $op = $this->newInstance();
1344 $this->assertSame( [], $op->getTemplateIds() );
1345
1346 // Test with no template id's
1347 $stubPOEmpty = $this->createParserOutputStub();
1348 $op->addParserOutputMetadata( $stubPOEmpty );
1349 $this->assertSame( [], $op->getTemplateIds() );
1350
1351 // Test with some arbitrary template id's
1352 $ids = [
1353 NS_MAIN => [ 'A' => 3, 'B' => 17 ],
1354 NS_TALK => [ 'C' => 31 ],
1355 NS_MEDIA => [ 'D' => -1 ],
1356 ];
1357
1358 $stubPO1 = $this->createParserOutputStub( 'getTemplateIds', $ids );
1359
1360 $op->addParserOutputMetadata( $stubPO1 );
1361 $this->assertSame( $ids, $op->getTemplateIds() );
1362
1363 // Test merging with a second set of id's
1364 $stubPO2 = $this->createParserOutputStub( 'getTemplateIds', [
1365 NS_MAIN => [ 'E' => 1234 ],
1366 NS_PROJECT => [ 'F' => 5678 ],
1367 ] );
1368
1369 $finalIds = [
1370 NS_MAIN => [ 'E' => 1234, 'A' => 3, 'B' => 17 ],
1371 NS_TALK => [ 'C' => 31 ],
1372 NS_MEDIA => [ 'D' => -1 ],
1373 NS_PROJECT => [ 'F' => 5678 ],
1374 ];
1375
1376 $op->addParserOutput( $stubPO2 );
1377 $this->assertSame( $finalIds, $op->getTemplateIds() );
1378
1379 // Test merging with an empty set of id's
1380 $op->addParserOutputMetadata( $stubPOEmpty );
1381 $this->assertSame( $finalIds, $op->getTemplateIds() );
1382 }
1383
1384 /**
1385 * @covers OutputPage::getFileSearchOptions
1386 * @covers OutputPage::addParserOutputMetadata
1387 * @covers OutputPage::addParserOutput
1388 */
1389 public function testFileSearchOptions() {
1390 $op = $this->newInstance();
1391 $this->assertSame( [], $op->getFileSearchOptions() );
1392
1393 // Test with no files
1394 $stubPOEmpty = $this->createParserOutputStub();
1395
1396 $op->addParserOutputMetadata( $stubPOEmpty );
1397 $this->assertSame( [], $op->getFileSearchOptions() );
1398
1399 // Test with some arbitrary files
1400 $files1 = [
1401 'A' => [ 'time' => null, 'sha1' => '' ],
1402 'B' => [
1403 'time' => '12211221123321',
1404 'sha1' => 'bf3ffa7047dc080f5855377a4f83cd18887e3b05',
1405 ],
1406 ];
1407
1408 $stubPO1 = $this->createParserOutputStub( 'getFileSearchOptions', $files1 );
1409
1410 $op->addParserOutput( $stubPO1 );
1411 $this->assertSame( $files1, $op->getFileSearchOptions() );
1412
1413 // Test merging with a second set of files
1414 $files2 = [
1415 'C' => [ 'time' => null, 'sha1' => '' ],
1416 'B' => [ 'time' => null, 'sha1' => '' ],
1417 ];
1418
1419 $stubPO2 = $this->createParserOutputStub( 'getFileSearchOptions', $files2 );
1420
1421 $op->addParserOutputMetadata( $stubPO2 );
1422 $this->assertSame( array_merge( $files1, $files2 ), $op->getFileSearchOptions() );
1423
1424 // Test merging with an empty set of files
1425 $op->addParserOutput( $stubPOEmpty );
1426 $this->assertSame( array_merge( $files1, $files2 ), $op->getFileSearchOptions() );
1427 }
1428
1429 /**
1430 * @dataProvider provideAddWikiText
1431 * @covers OutputPage::addWikiText
1432 * @covers OutputPage::addWikiTextAsInterface
1433 * @covers OutputPage::wrapWikiTextAsInterface
1434 * @covers OutputPage::addWikiTextAsContent
1435 * @covers OutputPage::addWikiTextWithTitle
1436 * @covers OutputPage::addWikiTextTitle
1437 * @covers OutputPage::addWikiTextTidy
1438 * @covers OutputPage::addWikiTextTitleTidy
1439 * @covers OutputPage::getHTML
1440 */
1441 public function testAddWikiText( $method, array $args, $expected ) {
1442 $op = $this->newInstance();
1443 $this->assertSame( '', $op->getHTML() );
1444
1445 $this->hideDeprecated( 'OutputPage::addWikiText' );
1446 $this->hideDeprecated( 'OutputPage::addWikiTextTitle' );
1447 $this->hideDeprecated( 'OutputPage::addWikiTextWithTitle' );
1448 $this->hideDeprecated( 'OutputPage::addWikiTextTidy' );
1449 $this->hideDeprecated( 'OutputPage::addWikiTextTitleTidy' );
1450 $this->hideDeprecated( 'disabling tidy' );
1451
1452 if ( in_array(
1453 $method,
1454 [ 'addWikiTextWithTitle', 'addWikiTextTitleTidy', 'addWikiTextTitle' ]
1455 ) && count( $args ) >= 2 && $args[1] === null ) {
1456 // Special placeholder because we can't get the actual title in the provider
1457 $args[1] = $op->getTitle();
1458 }
1459 if ( in_array(
1460 $method,
1461 [ 'addWikiTextAsInterface', 'addWikiTextAsContent' ]
1462 ) && count( $args ) >= 3 && $args[2] === null ) {
1463 // Special placeholder because we can't get the actual title in the provider
1464 $args[2] = $op->getTitle();
1465 }
1466
1467 $op->$method( ...$args );
1468 $this->assertSame( $expected, $op->getHTML() );
1469 }
1470
1471 public function provideAddWikiText() {
1472 $tests = [
1473 'addWikiText' => [
1474 // Not tidied; this API is deprecated.
1475 'Simple wikitext' => [
1476 [ "'''Bold'''" ],
1477 "<p><b>Bold</b>\n</p>",
1478 ], 'List at start' => [
1479 [ '* List' ],
1480 "<ul><li>List</li></ul>\n",
1481 ], 'List not at start' => [
1482 [ '* Not a list', false ],
1483 '* Not a list',
1484 ], 'Non-interface' => [
1485 [ "'''Bold'''", true, false ],
1486 "<p><b>Bold</b>\n</p>",
1487 ], 'No section edit links' => [
1488 [ '== Title ==' ],
1489 "<h2><span class=\"mw-headline\" id=\"Title\">Title</span></h2>\n",
1490 ],
1491 ],
1492 'addWikiTextWithTitle' => [
1493 // Untidied; this API is deprecated
1494 'With title at start' => [
1495 [ '* {{PAGENAME}}', Title::newFromText( 'Talk:Some page' ) ],
1496 "<ul><li>Some page</li></ul>\n",
1497 ], 'With title at start' => [
1498 [ '* {{PAGENAME}}', Title::newFromText( 'Talk:Some page' ), false ],
1499 "* Some page",
1500 ],
1501 ],
1502 'addWikiTextAsInterface' => [
1503 // Preferred interface: output is tidied
1504 'Simple wikitext' => [
1505 [ "'''Bold'''" ],
1506 "<p><b>Bold</b>\n</p>",
1507 ], 'Untidy wikitext' => [
1508 [ "<b>Bold" ],
1509 "<p><b>Bold\n</b></p>",
1510 ], 'List at start' => [
1511 [ '* List' ],
1512 "<ul><li>List</li></ul>\n",
1513 ], 'List not at start' => [
1514 [ '* Not a list', false ],
1515 '<p>* Not a list</p>',
1516 ], 'No section edit links' => [
1517 [ '== Title ==' ],
1518 "<h2><span class=\"mw-headline\" id=\"Title\">Title</span></h2>\n",
1519 ], 'With title at start' => [
1520 [ '* {{PAGENAME}}', true, Title::newFromText( 'Talk:Some page' ) ],
1521 "<ul><li>Some page</li></ul>\n",
1522 ], 'With title at start' => [
1523 [ '* {{PAGENAME}}', false, Title::newFromText( 'Talk:Some page' ), false ],
1524 "<p>* Some page</p>",
1525 ], 'Untidy input' => [
1526 [ '<b>{{PAGENAME}}', true, Title::newFromText( 'Talk:Some page' ) ],
1527 "<p><b>Some page\n</b></p>",
1528 ],
1529 ],
1530 'addWikiTextAsContent' => [
1531 // Preferred interface: output is tidied
1532 'SpecialNewimages' => [
1533 [ "<p lang='en' dir='ltr'>\nMy message" ],
1534 '<p lang="en" dir="ltr">' . "\nMy message\n</p>"
1535 ], 'List at start' => [
1536 [ '* List' ],
1537 "<ul><li>List</li></ul>\n",
1538 ], 'List not at start' => [
1539 [ '* <b>Not a list', false ],
1540 '<p>* <b>Not a list</b></p>',
1541 ], 'With title at start' => [
1542 [ '* {{PAGENAME}}', true, Title::newFromText( 'Talk:Some page' ) ],
1543 "<ul><li>Some page</li></ul>\n",
1544 ], 'With title at start' => [
1545 [ '* {{PAGENAME}}', false, Title::newFromText( 'Talk:Some page' ), false ],
1546 "<p>* Some page</p>",
1547 ], 'EditPage' => [
1548 [ "<div class='mw-editintro'>{{PAGENAME}}", true, Title::newFromText( 'Talk:Some page' ) ],
1549 '<div class="mw-editintro">' . "Some page\n</div>"
1550 ],
1551 ],
1552 'wrapWikiTextAsInterface' => [
1553 'Simple' => [
1554 [ 'wrapperClass', 'text' ],
1555 "<div class=\"wrapperClass\"><p>text\n</p></div>"
1556 ], 'Spurious </div>' => [
1557 [ 'wrapperClass', 'text</div><div>more' ],
1558 "<div class=\"wrapperClass\"><p>text</p><div>more\n</div></div>"
1559 ], 'Extra newlines would break <p> wrappers' => [
1560 [ 'two classes', "1\n\n2\n\n3" ],
1561 "<div class=\"two classes\"><p>1\n</p><p>2\n</p><p>3\n</p></div>"
1562 ], 'Other unclosed tags' => [
1563 [ 'error', 'a<b>c<i>d' ],
1564 "<div class=\"error\"><p>a<b>c<i>d\n</i></b></p></div>"
1565 ],
1566 ],
1567 ];
1568
1569 // Test all the others on addWikiTextTitle as well
1570 foreach ( $tests['addWikiText'] as $key => $val ) {
1571 $args = [ $val[0][0], null, $val[0][1] ?? true, false, $val[0][2] ?? true ];
1572 $tests['addWikiTextTitle']["$key (addWikiTextTitle)"] =
1573 array_merge( [ $args ], array_slice( $val, 1 ) );
1574 }
1575 foreach ( $tests['addWikiTextWithTitle'] as $key => $val ) {
1576 $args = [ $val[0][0], $val[0][1], $val[0][2] ?? true ];
1577 $tests['addWikiTextTitle']["$key (addWikiTextTitle)"] =
1578 array_merge( [ $args ], array_slice( $val, 1 ) );
1579 }
1580 foreach ( $tests['addWikiTextAsInterface'] as $key => $val ) {
1581 $args = [ $val[0][0], $val[0][2] ?? null, $val[0][1] ?? true, true, true ];
1582 $tests['addWikiTextTitle']["$key (addWikiTextTitle)"] =
1583 array_merge( [ $args ], array_slice( $val, 1 ) );
1584 }
1585 foreach ( $tests['addWikiTextAsContent'] as $key => $val ) {
1586 $args = [ $val[0][0], $val[0][2] ?? null, $val[0][1] ?? true, true, false ];
1587 $tests['addWikiTextTitle']["$key (addWikiTextTitle)"] =
1588 array_merge( [ $args ], array_slice( $val, 1 ) );
1589 }
1590 // addWikiTextTidy / addWikiTextTitleTidy were old aliases of
1591 // addWikiTextAsContent
1592 foreach ( $tests['addWikiTextAsContent'] as $key => $val ) {
1593 if ( count( $val[0] ) > 2 ) {
1594 $args = [ $val[0][0], $val[0][2], $val[0][1] ?? true ];
1595 $tests['addWikiTextTitleTidy']["$key (addWikiTextTitleTidy)"] =
1596 array_merge( [ $args ], array_slice( $val, 1 ) );
1597 } else {
1598 $args = [ $val[0][0], $val[0][1] ?? true ];
1599 $tests['addWikiTextTidy']["$key (addWikiTextTidy)"] =
1600 array_merge( [ $args ], array_slice( $val, 1 ) );
1601 }
1602 }
1603
1604 // We have to reformat our array to match what PHPUnit wants
1605 $ret = [];
1606 foreach ( $tests as $key => $subarray ) {
1607 foreach ( $subarray as $subkey => $val ) {
1608 $val = array_merge( [ $key ], $val );
1609 $ret[$subkey] = $val;
1610 }
1611 }
1612
1613 return $ret;
1614 }
1615
1616 /**
1617 * @covers OutputPage::addWikiText
1618 */
1619 public function testAddWikiTextNoTitle() {
1620 $this->hideDeprecated( 'OutputPage::addWikiText' );
1621 $this->setExpectedException( MWException::class, 'Title is null' );
1622
1623 $op = $this->newInstance( [], null, 'notitle' );
1624 $op->addWikiText( 'a' );
1625 }
1626
1627 /**
1628 * @covers OutputPage::addWikiTextAsInterface
1629 */
1630 public function testAddWikiTextAsInterfaceNoTitle() {
1631 $this->setExpectedException( MWException::class, 'Title is null' );
1632
1633 $op = $this->newInstance( [], null, 'notitle' );
1634 $op->addWikiTextAsInterface( 'a' );
1635 }
1636
1637 /**
1638 * @covers OutputPage::addWikiTextAsContent
1639 */
1640 public function testAddWikiTextAsContentNoTitle() {
1641 $this->setExpectedException( MWException::class, 'Title is null' );
1642
1643 $op = $this->newInstance( [], null, 'notitle' );
1644 $op->addWikiTextAsContent( 'a' );
1645 }
1646
1647 /**
1648 * @covers OutputPage::addWikiMsg
1649 */
1650 public function testAddWikiMsg() {
1651 $msg = wfMessage( 'parentheses' );
1652 $this->assertSame( '(a)', $msg->rawParams( 'a' )->plain() );
1653
1654 $op = $this->newInstance();
1655 $this->assertSame( '', $op->getHTML() );
1656 $op->addWikiMsg( 'parentheses', "<b>a" );
1657 // The input is bad unbalanced HTML, but the output is tidied
1658 $this->assertSame( "<p>(<b>a)\n</b></p>", $op->getHTML() );
1659 }
1660
1661 /**
1662 * @covers OutputPage::wrapWikiMsg
1663 */
1664 public function testWrapWikiMsg() {
1665 $msg = wfMessage( 'parentheses' );
1666 $this->assertSame( '(a)', $msg->rawParams( 'a' )->plain() );
1667
1668 $op = $this->newInstance();
1669 $this->assertSame( '', $op->getHTML() );
1670 $op->wrapWikiMsg( '[$1]', [ 'parentheses', "<b>a" ] );
1671 // The input is bad unbalanced HTML, but the output is tidied
1672 $this->assertSame( "<p>[(<b>a)]\n</b></p>", $op->getHTML() );
1673 }
1674
1675 /**
1676 * @covers OutputPage::addParserOutputMetadata
1677 * @covers OutputPage::addParserOutput
1678 */
1679 public function testNoGallery() {
1680 $op = $this->newInstance();
1681 $this->assertFalse( $op->mNoGallery );
1682
1683 $stubPO1 = $this->createParserOutputStub( 'getNoGallery', true );
1684 $op->addParserOutputMetadata( $stubPO1 );
1685 $this->assertTrue( $op->mNoGallery );
1686
1687 $stubPO2 = $this->createParserOutputStub( 'getNoGallery', false );
1688 $op->addParserOutput( $stubPO2 );
1689 $this->assertFalse( $op->mNoGallery );
1690 }
1691
1692 private static $parserOutputHookCalled;
1693
1694 /**
1695 * @covers OutputPage::addParserOutputMetadata
1696 */
1697 public function testParserOutputHooks() {
1698 $op = $this->newInstance();
1699 $pOut = $this->createParserOutputStub( 'getOutputHooks', [
1700 [ 'myhook', 'banana' ],
1701 [ 'yourhook', 'kumquat' ],
1702 [ 'theirhook', 'hippopotamus' ],
1703 ] );
1704
1705 self::$parserOutputHookCalled = [];
1706
1707 $this->setMwGlobals( 'wgParserOutputHooks', [
1708 'myhook' => function ( OutputPage $innerOp, ParserOutput $innerPOut, $data )
1709 use ( $op, $pOut ) {
1710 $this->assertSame( $op, $innerOp );
1711 $this->assertSame( $pOut, $innerPOut );
1712 $this->assertSame( 'banana', $data );
1713 self::$parserOutputHookCalled[] = 'closure';
1714 },
1715 'yourhook' => [ $this, 'parserOutputHookCallback' ],
1716 'theirhook' => [ __CLASS__, 'parserOutputHookCallbackStatic' ],
1717 'uncalled' => function () {
1718 $this->assertTrue( false );
1719 },
1720 ] );
1721
1722 $op->addParserOutputMetadata( $pOut );
1723
1724 $this->assertSame( [ 'closure', 'callback', 'static' ], self::$parserOutputHookCalled );
1725 }
1726
1727 public function parserOutputHookCallback(
1728 OutputPage $op, ParserOutput $pOut, $data
1729 ) {
1730 $this->assertSame( 'kumquat', $data );
1731
1732 self::$parserOutputHookCalled[] = 'callback';
1733 }
1734
1735 public static function parserOutputHookCallbackStatic(
1736 OutputPage $op, ParserOutput $pOut, $data
1737 ) {
1738 // All the assert methods are actually static, who knew!
1739 self::assertSame( 'hippopotamus', $data );
1740
1741 self::$parserOutputHookCalled[] = 'static';
1742 }
1743
1744 // @todo Make sure to test the following in addParserOutputMetadata() as well when we add tests
1745 // for them:
1746 // * addModules()
1747 // * addModuleScripts()
1748 // * addModuleStyles()
1749 // * addJsConfigVars()
1750 // * enableOOUI()
1751 // Otherwise those lines of addParserOutputMetadata() will be reported as covered, but we won't
1752 // be testing they actually work.
1753
1754 /**
1755 * @covers OutputPage::addParserOutputText
1756 */
1757 public function testAddParserOutputText() {
1758 $op = $this->newInstance();
1759 $this->assertSame( '', $op->getHTML() );
1760
1761 $pOut = $this->createParserOutputStub( 'getText', '<some text>' );
1762
1763 $op->addParserOutputMetadata( $pOut );
1764 $this->assertSame( '', $op->getHTML() );
1765
1766 $op->addParserOutputText( $pOut );
1767 $this->assertSame( '<some text>', $op->getHTML() );
1768 }
1769
1770 /**
1771 * @covers OutputPage::addParserOutput
1772 */
1773 public function testAddParserOutput() {
1774 $op = $this->newInstance();
1775 $this->assertSame( '', $op->getHTML() );
1776 $this->assertFalse( $op->showNewSectionLink() );
1777
1778 $pOut = $this->createParserOutputStub( [
1779 'getText' => '<some text>',
1780 'getNewSection' => true,
1781 ] );
1782
1783 $op->addParserOutput( $pOut );
1784 $this->assertSame( '<some text>', $op->getHTML() );
1785 $this->assertTrue( $op->showNewSectionLink() );
1786 }
1787
1788 /**
1789 * @covers OutputPage::addTemplate
1790 */
1791 public function testAddTemplate() {
1792 $template = $this->getMock( QuickTemplate::class );
1793 $template->method( 'getHTML' )->willReturn( '<abc>&def;' );
1794
1795 $op = $this->newInstance();
1796 $op->addTemplate( $template );
1797
1798 $this->assertSame( '<abc>&def;', $op->getHTML() );
1799 }
1800
1801 /**
1802 * @dataProvider provideParse
1803 * @covers OutputPage::parse
1804 * @param array $args To pass to parse()
1805 * @param string $expectedHTML Expected return value for parse()
1806 * @param string $expectedHTML Expected return value for parseInline(), if different
1807 */
1808 public function testParse( array $args, $expectedHTML ) {
1809 $this->hideDeprecated( 'OutputPage::parse' );
1810 $op = $this->newInstance();
1811 $this->assertSame( $expectedHTML, $op->parse( ...$args ) );
1812 }
1813
1814 /**
1815 * @dataProvider provideParse
1816 * @covers OutputPage::parseInline
1817 */
1818 public function testParseInline( array $args, $expectedHTML, $expectedHTMLInline = null ) {
1819 if ( count( $args ) > 3 ) {
1820 // $language param not supported
1821 $this->assertTrue( true );
1822 return;
1823 }
1824 $this->hideDeprecated( 'OutputPage::parseInline' );
1825 $op = $this->newInstance();
1826 $this->assertSame( $expectedHTMLInline ?? $expectedHTML, $op->parseInline( ...$args ) );
1827 }
1828
1829 public function provideParse() {
1830 return [
1831 'List at start of line (content)' => [
1832 [ '* List', true, false ],
1833 "<div class=\"mw-parser-output\"><ul><li>List</li></ul>\n</div>",
1834 "<ul><li>List</li></ul>\n",
1835 ],
1836 'List at start of line (interface)' => [
1837 [ '* List', true, true ],
1838 "<ul><li>List</li></ul>\n",
1839 ],
1840 'List not at start (content)' => [
1841 [ "* ''Not'' list", false, false ],
1842 '<div class="mw-parser-output">* <i>Not</i> list</div>',
1843 '* <i>Not</i> list',
1844 ],
1845 'List not at start (interface)' => [
1846 [ "* ''Not'' list", false, true ],
1847 '* <i>Not</i> list',
1848 ],
1849 'Interface message' => [
1850 [ "''Italic''", true, true ],
1851 "<p><i>Italic</i>\n</p>",
1852 '<i>Italic</i>',
1853 ],
1854 'formatnum (content)' => [
1855 [ '{{formatnum:123456.789}}', true, false ],
1856 "<div class=\"mw-parser-output\"><p>123,456.789\n</p></div>",
1857 "123,456.789",
1858 ],
1859 'formatnum (interface)' => [
1860 [ '{{formatnum:123456.789}}', true, true ],
1861 "<p>123,456.789\n</p>",
1862 "123,456.789",
1863 ],
1864 'Language (content)' => [
1865 [ '{{formatnum:123456.789}}', true, false, Language::factory( 'is' ) ],
1866 "<div class=\"mw-parser-output\"><p>123.456,789\n</p></div>",
1867 ],
1868 'Language (interface)' => [
1869 [ '{{formatnum:123456.789}}', true, true, Language::factory( 'is' ) ],
1870 "<p>123.456,789\n</p>",
1871 '123.456,789',
1872 ],
1873 'No section edit links' => [
1874 [ '== Header ==' ],
1875 '<div class="mw-parser-output"><h2><span class="mw-headline" id="Header">' .
1876 "Header</span></h2>\n</div>",
1877 '<h2><span class="mw-headline" id="Header">Header</span></h2>' .
1878 "\n",
1879 ]
1880 ];
1881 }
1882
1883 /**
1884 * @dataProvider provideParseAs
1885 * @covers OutputPage::parseAsContent
1886 * @param array $args To pass to parse()
1887 * @param string $expectedHTML Expected return value for parseAsContent()
1888 * @param string $expectedHTML Expected return value for parseInlineAsInterface(), if different
1889 */
1890 public function testParseAsContent(
1891 array $args, $expectedHTML, $expectedHTMLInline = null
1892 ) {
1893 $op = $this->newInstance();
1894 $this->assertSame( $expectedHTML, $op->parseAsContent( ...$args ) );
1895 }
1896
1897 /**
1898 * @dataProvider provideParseAs
1899 * @covers OutputPage::parseAsInterface
1900 * @param array $args To pass to parse()
1901 * @param string $expectedHTML Expected return value for parseAsInterface()
1902 * @param string $expectedHTML Expected return value for parseInlineAsInterface(), if different
1903 */
1904 public function testParseAsInterface(
1905 array $args, $expectedHTML, $expectedHTMLInline = null
1906 ) {
1907 $op = $this->newInstance();
1908 $this->assertSame( $expectedHTML, $op->parseAsInterface( ...$args ) );
1909 }
1910
1911 /**
1912 * @dataProvider provideParseAs
1913 * @covers OutputPage::parseInlineAsInterface
1914 */
1915 public function testParseInlineAsInterface(
1916 array $args, $expectedHTML, $expectedHTMLInline = null
1917 ) {
1918 $op = $this->newInstance();
1919 $this->assertSame(
1920 $expectedHTMLInline ?? $expectedHTML,
1921 $op->parseInlineAsInterface( ...$args )
1922 );
1923 }
1924
1925 public function provideParseAs() {
1926 return [
1927 'List at start of line' => [
1928 [ '* List', true ],
1929 "<ul><li>List</li></ul>\n",
1930 ],
1931 'List not at start' => [
1932 [ "* ''Not'' list", false ],
1933 '<p>* <i>Not</i> list</p>',
1934 '* <i>Not</i> list',
1935 ],
1936 'Italics' => [
1937 [ "''Italic''", true ],
1938 "<p><i>Italic</i>\n</p>",
1939 '<i>Italic</i>',
1940 ],
1941 'formatnum' => [
1942 [ '{{formatnum:123456.789}}', true ],
1943 "<p>123,456.789\n</p>",
1944 "123,456.789",
1945 ],
1946 'No section edit links' => [
1947 [ '== Header ==' ],
1948 '<h2><span class="mw-headline" id="Header">Header</span></h2>' .
1949 "\n",
1950 ]
1951 ];
1952 }
1953
1954 /**
1955 * @covers OutputPage::parse
1956 */
1957 public function testParseNullTitle() {
1958 $this->hideDeprecated( 'OutputPage::parse' );
1959 $this->setExpectedException( MWException::class, 'Empty $mTitle in OutputPage::parseInternal' );
1960 $op = $this->newInstance( [], null, 'notitle' );
1961 $op->parse( '' );
1962 }
1963
1964 /**
1965 * @covers OutputPage::parseInline
1966 */
1967 public function testParseInlineNullTitle() {
1968 $this->hideDeprecated( 'OutputPage::parseInline' );
1969 $this->setExpectedException( MWException::class, 'Empty $mTitle in OutputPage::parseInternal' );
1970 $op = $this->newInstance( [], null, 'notitle' );
1971 $op->parseInline( '' );
1972 }
1973
1974 /**
1975 * @covers OutputPage::parseAsContent
1976 */
1977 public function testParseAsContentNullTitle() {
1978 $this->setExpectedException( MWException::class, 'Empty $mTitle in OutputPage::parseInternal' );
1979 $op = $this->newInstance( [], null, 'notitle' );
1980 $op->parseAsContent( '' );
1981 }
1982
1983 /**
1984 * @covers OutputPage::parseAsInterface
1985 */
1986 public function testParseAsInterfaceNullTitle() {
1987 $this->setExpectedException( MWException::class, 'Empty $mTitle in OutputPage::parseInternal' );
1988 $op = $this->newInstance( [], null, 'notitle' );
1989 $op->parseAsInterface( '' );
1990 }
1991
1992 /**
1993 * @covers OutputPage::parseInlineAsInterface
1994 */
1995 public function testParseInlineAsInterfaceNullTitle() {
1996 $this->setExpectedException( MWException::class, 'Empty $mTitle in OutputPage::parseInternal' );
1997 $op = $this->newInstance( [], null, 'notitle' );
1998 $op->parseInlineAsInterface( '' );
1999 }
2000
2001 /**
2002 * @covers OutputPage::setCdnMaxage
2003 * @covers OutputPage::lowerCdnMaxage
2004 */
2005 public function testCdnMaxage() {
2006 $op = $this->newInstance();
2007 $wrapper = TestingAccessWrapper::newFromObject( $op );
2008 $this->assertSame( 0, $wrapper->mCdnMaxage );
2009
2010 $op->setCdnMaxage( -1 );
2011 $this->assertSame( -1, $wrapper->mCdnMaxage );
2012
2013 $op->setCdnMaxage( 120 );
2014 $this->assertSame( 120, $wrapper->mCdnMaxage );
2015
2016 $op->setCdnMaxage( 60 );
2017 $this->assertSame( 60, $wrapper->mCdnMaxage );
2018
2019 $op->setCdnMaxage( 180 );
2020 $this->assertSame( 180, $wrapper->mCdnMaxage );
2021
2022 $op->lowerCdnMaxage( 240 );
2023 $this->assertSame( 180, $wrapper->mCdnMaxage );
2024
2025 $op->setCdnMaxage( 300 );
2026 $this->assertSame( 240, $wrapper->mCdnMaxage );
2027
2028 $op->lowerCdnMaxage( 120 );
2029 $this->assertSame( 120, $wrapper->mCdnMaxage );
2030
2031 $op->setCdnMaxage( 180 );
2032 $this->assertSame( 120, $wrapper->mCdnMaxage );
2033
2034 $op->setCdnMaxage( 60 );
2035 $this->assertSame( 60, $wrapper->mCdnMaxage );
2036
2037 $op->setCdnMaxage( 240 );
2038 $this->assertSame( 120, $wrapper->mCdnMaxage );
2039 }
2040
2041 /** @var int Faked time to set for tests that need it */
2042 private static $fakeTime;
2043
2044 /**
2045 * @dataProvider provideAdaptCdnTTL
2046 * @covers OutputPage::adaptCdnTTL
2047 * @param array $args To pass to adaptCdnTTL()
2048 * @param int $expected Expected new value of mCdnMaxageLimit
2049 * @param array $options Associative array:
2050 * initialMaxage => Maxage to set before calling adaptCdnTTL() (default 86400)
2051 */
2052 public function testAdaptCdnTTL( array $args, $expected, array $options = [] ) {
2053 try {
2054 MWTimestamp::setFakeTime( self::$fakeTime );
2055
2056 $op = $this->newInstance();
2057 // Set a high maxage so that it will get reduced by adaptCdnTTL(). The default maxage
2058 // is 0, so adaptCdnTTL() won't mutate the object at all.
2059 $initial = $options['initialMaxage'] ?? 86400;
2060 $op->setCdnMaxage( $initial );
2061
2062 $op->adaptCdnTTL( ...$args );
2063 } finally {
2064 MWTimestamp::setFakeTime( false );
2065 }
2066
2067 $wrapper = TestingAccessWrapper::newFromObject( $op );
2068
2069 // Special rules for false/null
2070 if ( $args[0] === null || $args[0] === false ) {
2071 $this->assertSame( $initial, $wrapper->mCdnMaxage, 'member value' );
2072 $op->setCdnMaxage( $expected + 1 );
2073 $this->assertSame( $expected + 1, $wrapper->mCdnMaxage, 'member value after new set' );
2074 return;
2075 }
2076
2077 $this->assertSame( $expected, $wrapper->mCdnMaxageLimit, 'limit value' );
2078
2079 if ( $initial >= $expected ) {
2080 $this->assertSame( $expected, $wrapper->mCdnMaxage, 'member value' );
2081 } else {
2082 $this->assertSame( $initial, $wrapper->mCdnMaxage, 'member value' );
2083 }
2084
2085 $op->setCdnMaxage( $expected + 1 );
2086 $this->assertSame( $expected, $wrapper->mCdnMaxage, 'member value after new set' );
2087 }
2088
2089 public function provideAdaptCdnTTL() {
2090 global $wgSquidMaxage;
2091 $now = time();
2092 self::$fakeTime = $now;
2093 return [
2094 'Five minutes ago' => [ [ $now - 300 ], 270 ],
2095 'Now' => [ [ +0 ], IExpiringStore::TTL_MINUTE ],
2096 'Five minutes from now' => [ [ $now + 300 ], IExpiringStore::TTL_MINUTE ],
2097 'Five minutes ago, initial maxage four minutes' =>
2098 [ [ $now - 300 ], 270, [ 'initialMaxage' => 240 ] ],
2099 'A very long time ago' => [ [ $now - 1000000000 ], $wgSquidMaxage ],
2100 'Initial maxage zero' => [ [ $now - 300 ], 270, [ 'initialMaxage' => 0 ] ],
2101
2102 'false' => [ [ false ], IExpiringStore::TTL_MINUTE ],
2103 'null' => [ [ null ], IExpiringStore::TTL_MINUTE ],
2104 "'0'" => [ [ '0' ], IExpiringStore::TTL_MINUTE ],
2105 'Empty string' => [ [ '' ], IExpiringStore::TTL_MINUTE ],
2106 // @todo These give incorrect results due to timezones, how to test?
2107 //"'now'" => [ [ 'now' ], IExpiringStore::TTL_MINUTE ],
2108 //"'parse error'" => [ [ 'parse error' ], IExpiringStore::TTL_MINUTE ],
2109
2110 'Now, minTTL 0' => [ [ $now, 0 ], IExpiringStore::TTL_MINUTE ],
2111 'Now, minTTL 0.000001' => [ [ $now, 0.000001 ], 0 ],
2112 'A very long time ago, maxTTL even longer' =>
2113 [ [ $now - 1000000000, 0, 1000000001 ], 900000000 ],
2114 ];
2115 }
2116
2117 /**
2118 * @covers OutputPage::enableClientCache
2119 * @covers OutputPage::addParserOutputMetadata
2120 * @covers OutputPage::addParserOutput
2121 */
2122 public function testClientCache() {
2123 $op = $this->newInstance();
2124
2125 // Test initial value
2126 $this->assertSame( true, $op->enableClientCache( null ) );
2127 // Test that calling with null doesn't change the value
2128 $this->assertSame( true, $op->enableClientCache( null ) );
2129
2130 // Test setting to false
2131 $this->assertSame( true, $op->enableClientCache( false ) );
2132 $this->assertSame( false, $op->enableClientCache( null ) );
2133 // Test that calling with null doesn't change the value
2134 $this->assertSame( false, $op->enableClientCache( null ) );
2135
2136 // Test that a cacheable ParserOutput doesn't set to true
2137 $pOutCacheable = $this->createParserOutputStub( 'isCacheable', true );
2138 $op->addParserOutputMetadata( $pOutCacheable );
2139 $this->assertSame( false, $op->enableClientCache( null ) );
2140
2141 // Test setting back to true
2142 $this->assertSame( false, $op->enableClientCache( true ) );
2143 $this->assertSame( true, $op->enableClientCache( null ) );
2144
2145 // Test that an uncacheable ParserOutput does set to false
2146 $pOutUncacheable = $this->createParserOutputStub( 'isCacheable', false );
2147 $op->addParserOutput( $pOutUncacheable );
2148 $this->assertSame( false, $op->enableClientCache( null ) );
2149 }
2150
2151 /**
2152 * @covers OutputPage::getCacheVaryCookies
2153 */
2154 public function testGetCacheVaryCookies() {
2155 global $wgCookiePrefix, $wgDBname;
2156 $op = $this->newInstance();
2157 $prefix = $wgCookiePrefix !== false ? $wgCookiePrefix : $wgDBname;
2158 $expectedCookies = [
2159 "{$prefix}Token",
2160 "{$prefix}LoggedOut",
2161 "{$prefix}_session",
2162 'forceHTTPS',
2163 'cookie1',
2164 'cookie2',
2165 ];
2166
2167 // We have to reset the cookies because getCacheVaryCookies may have already been called
2168 TestingAccessWrapper::newFromClass( OutputPage::class )->cacheVaryCookies = null;
2169
2170 $this->setMwGlobals( 'wgCacheVaryCookies', [ 'cookie1' ] );
2171 $this->setTemporaryHook( 'GetCacheVaryCookies',
2172 function ( $innerOP, &$cookies ) use ( $op, $expectedCookies ) {
2173 $this->assertSame( $op, $innerOP );
2174 $cookies[] = 'cookie2';
2175 $this->assertSame( $expectedCookies, $cookies );
2176 }
2177 );
2178
2179 $this->assertSame( $expectedCookies, $op->getCacheVaryCookies() );
2180 }
2181
2182 /**
2183 * @covers OutputPage::haveCacheVaryCookies
2184 */
2185 public function testHaveCacheVaryCookies() {
2186 $request = new FauxRequest();
2187 $op = $this->newInstance( [], $request );
2188
2189 // No cookies are set.
2190 $this->assertFalse( $op->haveCacheVaryCookies() );
2191
2192 // 'Token' is present but empty, so it shouldn't count.
2193 $request->setCookie( 'Token', '' );
2194 $this->assertFalse( $op->haveCacheVaryCookies() );
2195
2196 // 'Token' present and nonempty.
2197 $request->setCookie( 'Token', '123' );
2198 $this->assertTrue( $op->haveCacheVaryCookies() );
2199 }
2200
2201 /**
2202 * @dataProvider provideVaryHeaders
2203 *
2204 * @covers OutputPage::addVaryHeader
2205 * @covers OutputPage::getVaryHeader
2206 * @covers OutputPage::getKeyHeader
2207 *
2208 * @param array[] $calls For each array, call addVaryHeader() with those arguments
2209 * @param string[] $cookies Array of cookie names to vary on
2210 * @param string $vary Text of expected Vary header (including the 'Vary: ')
2211 * @param string $key Text of expected Key header (including the 'Key: ')
2212 */
2213 public function testVaryHeaders( array $calls, array $cookies, $vary, $key ) {
2214 // Get rid of default Vary fields
2215 $op = $this->getMockBuilder( OutputPage::class )
2216 ->setConstructorArgs( [ new RequestContext() ] )
2217 ->setMethods( [ 'getCacheVaryCookies' ] )
2218 ->getMock();
2219 $op->expects( $this->any() )
2220 ->method( 'getCacheVaryCookies' )
2221 ->will( $this->returnValue( $cookies ) );
2222 TestingAccessWrapper::newFromObject( $op )->mVaryHeader = [];
2223
2224 $this->hideDeprecated( '$wgUseKeyHeader' );
2225 foreach ( $calls as $call ) {
2226 $op->addVaryHeader( ...$call );
2227 }
2228 $this->assertEquals( $vary, $op->getVaryHeader(), 'Vary:' );
2229 $this->assertEquals( $key, $op->getKeyHeader(), 'Key:' );
2230 }
2231
2232 public function provideVaryHeaders() {
2233 // note: getKeyHeader() automatically adds Vary: Cookie
2234 return [
2235 'No header' => [
2236 [],
2237 [],
2238 'Vary: ',
2239 'Key: Cookie',
2240 ],
2241 'Single header' => [
2242 [
2243 [ 'Cookie' ],
2244 ],
2245 [],
2246 'Vary: Cookie',
2247 'Key: Cookie',
2248 ],
2249 'Non-unique headers' => [
2250 [
2251 [ 'Cookie' ],
2252 [ 'Accept-Language' ],
2253 [ 'Cookie' ],
2254 ],
2255 [],
2256 'Vary: Cookie, Accept-Language',
2257 'Key: Cookie,Accept-Language',
2258 ],
2259 'Two headers with single options' => [
2260 [
2261 [ 'Cookie', [ 'param=phpsessid' ] ],
2262 [ 'Accept-Language', [ 'substr=en' ] ],
2263 ],
2264 [],
2265 'Vary: Cookie, Accept-Language',
2266 'Key: Cookie;param=phpsessid,Accept-Language;substr=en',
2267 ],
2268 'One header with multiple options' => [
2269 [
2270 [ 'Cookie', [ 'param=phpsessid', 'param=userId' ] ],
2271 ],
2272 [],
2273 'Vary: Cookie',
2274 'Key: Cookie;param=phpsessid;param=userId',
2275 ],
2276 'Duplicate option' => [
2277 [
2278 [ 'Cookie', [ 'param=phpsessid' ] ],
2279 [ 'Cookie', [ 'param=phpsessid' ] ],
2280 [ 'Accept-Language', [ 'substr=en', 'substr=en' ] ],
2281 ],
2282 [],
2283 'Vary: Cookie, Accept-Language',
2284 'Key: Cookie;param=phpsessid,Accept-Language;substr=en',
2285 ],
2286 'Same header, different options' => [
2287 [
2288 [ 'Cookie', [ 'param=phpsessid' ] ],
2289 [ 'Cookie', [ 'param=userId' ] ],
2290 ],
2291 [],
2292 'Vary: Cookie',
2293 'Key: Cookie;param=phpsessid;param=userId',
2294 ],
2295 'No header, vary cookies' => [
2296 [],
2297 [ 'cookie1', 'cookie2' ],
2298 'Vary: Cookie',
2299 'Key: Cookie;param=cookie1;param=cookie2',
2300 ],
2301 'Cookie header with option plus vary cookies' => [
2302 [
2303 [ 'Cookie', [ 'param=cookie1' ] ],
2304 ],
2305 [ 'cookie2', 'cookie3' ],
2306 'Vary: Cookie',
2307 'Key: Cookie;param=cookie1;param=cookie2;param=cookie3',
2308 ],
2309 'Non-cookie header plus vary cookies' => [
2310 [
2311 [ 'Accept-Language' ],
2312 ],
2313 [ 'cookie' ],
2314 'Vary: Accept-Language, Cookie',
2315 'Key: Accept-Language,Cookie;param=cookie',
2316 ],
2317 'Cookie and non-cookie headers plus vary cookies' => [
2318 [
2319 [ 'Cookie', [ 'param=cookie1' ] ],
2320 [ 'Accept-Language' ],
2321 ],
2322 [ 'cookie2' ],
2323 'Vary: Cookie, Accept-Language',
2324 'Key: Cookie;param=cookie1;param=cookie2,Accept-Language',
2325 ],
2326 ];
2327 }
2328
2329 /**
2330 * @covers OutputPage::getVaryHeader
2331 */
2332 public function testVaryHeaderDefault() {
2333 $op = $this->newInstance();
2334 $this->assertSame( 'Vary: Accept-Encoding, Cookie', $op->getVaryHeader() );
2335 }
2336
2337 /**
2338 * @dataProvider provideLinkHeaders
2339 *
2340 * @covers OutputPage::addLinkHeader
2341 * @covers OutputPage::getLinkHeader
2342 */
2343 public function testLinkHeaders( array $headers, $result ) {
2344 $op = $this->newInstance();
2345
2346 foreach ( $headers as $header ) {
2347 $op->addLinkHeader( $header );
2348 }
2349
2350 $this->assertEquals( $result, $op->getLinkHeader() );
2351 }
2352
2353 public function provideLinkHeaders() {
2354 return [
2355 [
2356 [],
2357 false
2358 ],
2359 [
2360 [ '<https://foo/bar.jpg>;rel=preload;as=image' ],
2361 'Link: <https://foo/bar.jpg>;rel=preload;as=image',
2362 ],
2363 [
2364 [
2365 '<https://foo/bar.jpg>;rel=preload;as=image',
2366 '<https://foo/baz.jpg>;rel=preload;as=image'
2367 ],
2368 'Link: <https://foo/bar.jpg>;rel=preload;as=image,<https://foo/baz.jpg>;' .
2369 'rel=preload;as=image',
2370 ],
2371 ];
2372 }
2373
2374 /**
2375 * @dataProvider provideAddAcceptLanguage
2376 * @covers OutputPage::addAcceptLanguage
2377 * @covers OutputPage::getKeyHeader
2378 */
2379 public function testAddAcceptLanguage(
2380 $code, array $variants, array $expected, array $options = []
2381 ) {
2382 $req = new FauxRequest( in_array( 'varianturl', $options ) ? [ 'variant' => 'x' ] : [] );
2383 $op = $this->newInstance( [], $req, in_array( 'notitle', $options ) ? 'notitle' : null );
2384
2385 if ( !in_array( 'notitle', $options ) ) {
2386 $mockLang = $this->getMock( Language::class );
2387
2388 if ( in_array( 'varianturl', $options ) ) {
2389 $mockLang->expects( $this->never() )->method( $this->anything() );
2390 } else {
2391 $mockLang->method( 'hasVariants' )->willReturn( count( $variants ) > 1 );
2392 $mockLang->method( 'getVariants' )->willReturn( $variants );
2393 $mockLang->method( 'getCode' )->willReturn( $code );
2394 }
2395
2396 $mockTitle = $this->getMock( Title::class );
2397 $mockTitle->method( 'getPageLanguage' )->willReturn( $mockLang );
2398
2399 $op->setTitle( $mockTitle );
2400 }
2401
2402 // This will run addAcceptLanguage()
2403 $op->sendCacheControl();
2404
2405 $this->hideDeprecated( '$wgUseKeyHeader' );
2406 $keyHeader = $op->getKeyHeader();
2407
2408 if ( !$expected ) {
2409 $this->assertFalse( strpos( 'Accept-Language', $keyHeader ) );
2410 return;
2411 }
2412
2413 $keyHeader = explode( ' ', $keyHeader, 2 )[1];
2414 $keyHeader = explode( ',', $keyHeader );
2415
2416 $acceptLanguage = null;
2417 foreach ( $keyHeader as $item ) {
2418 if ( strpos( $item, 'Accept-Language;' ) === 0 ) {
2419 $acceptLanguage = $item;
2420 break;
2421 }
2422 }
2423
2424 $expectedString = 'Accept-Language;substr=' . implode( ';substr=', $expected );
2425 $this->assertSame( $expectedString, $acceptLanguage );
2426 }
2427
2428 public function provideAddAcceptLanguage() {
2429 return [
2430 'No variants' => [ 'en', [ 'en' ], [] ],
2431 'One simple variant' => [ 'en', [ 'en', 'en-x-piglatin' ], [ 'en-x-piglatin' ] ],
2432 'Multiple variants with BCP47 alternatives' => [
2433 'zh',
2434 [ 'zh', 'zh-hans', 'zh-cn', 'zh-tw' ],
2435 [ 'zh-hans', 'zh-Hans', 'zh-cn', 'zh-Hans-CN', 'zh-tw', 'zh-Hant-TW' ],
2436 ],
2437 'No title' => [ 'en', [ 'en', 'en-x-piglatin' ], [], [ 'notitle' ] ],
2438 'Variant in URL' => [ 'en', [ 'en', 'en-x-piglatin' ], [], [ 'varianturl' ] ],
2439 ];
2440 }
2441
2442 /**
2443 * @covers OutputPage::preventClickjacking
2444 * @covers OutputPage::allowClickjacking
2445 * @covers OutputPage::getPreventClickjacking
2446 * @covers OutputPage::addParserOutputMetadata
2447 * @covers OutputPage::addParserOutput
2448 */
2449 public function testClickjacking() {
2450 $op = $this->newInstance();
2451 $this->assertTrue( $op->getPreventClickjacking() );
2452
2453 $op->allowClickjacking();
2454 $this->assertFalse( $op->getPreventClickjacking() );
2455
2456 $op->preventClickjacking();
2457 $this->assertTrue( $op->getPreventClickjacking() );
2458
2459 $op->preventClickjacking( false );
2460 $this->assertFalse( $op->getPreventClickjacking() );
2461
2462 $pOut1 = $this->createParserOutputStub( 'preventClickjacking', true );
2463 $op->addParserOutputMetadata( $pOut1 );
2464 $this->assertTrue( $op->getPreventClickjacking() );
2465
2466 // The ParserOutput can't allow, only prevent
2467 $pOut2 = $this->createParserOutputStub( 'preventClickjacking', false );
2468 $op->addParserOutputMetadata( $pOut2 );
2469 $this->assertTrue( $op->getPreventClickjacking() );
2470
2471 // Reset to test with addParserOutput()
2472 $op->allowClickjacking();
2473 $this->assertFalse( $op->getPreventClickjacking() );
2474
2475 $op->addParserOutput( $pOut1 );
2476 $this->assertTrue( $op->getPreventClickjacking() );
2477
2478 $op->addParserOutput( $pOut2 );
2479 $this->assertTrue( $op->getPreventClickjacking() );
2480 }
2481
2482 /**
2483 * @dataProvider provideGetFrameOptions
2484 * @covers OutputPage::getFrameOptions
2485 * @covers OutputPage::preventClickjacking
2486 */
2487 public function testGetFrameOptions(
2488 $breakFrames, $preventClickjacking, $editPageFrameOptions, $expected
2489 ) {
2490 $op = $this->newInstance( [
2491 'BreakFrames' => $breakFrames,
2492 'EditPageFrameOptions' => $editPageFrameOptions,
2493 ] );
2494 $op->preventClickjacking( $preventClickjacking );
2495
2496 $this->assertSame( $expected, $op->getFrameOptions() );
2497 }
2498
2499 public function provideGetFrameOptions() {
2500 return [
2501 'BreakFrames true' => [ true, false, false, 'DENY' ],
2502 'Allow clickjacking locally' => [ false, false, 'DENY', false ],
2503 'Allow clickjacking globally' => [ false, true, false, false ],
2504 'DENY globally' => [ false, true, 'DENY', 'DENY' ],
2505 'SAMEORIGIN' => [ false, true, 'SAMEORIGIN', 'SAMEORIGIN' ],
2506 'BreakFrames with SAMEORIGIN' => [ true, true, 'SAMEORIGIN', 'DENY' ],
2507 ];
2508 }
2509
2510 /**
2511 * See ResourceLoaderClientHtmlTest for full coverage.
2512 *
2513 * @dataProvider provideMakeResourceLoaderLink
2514 *
2515 * @covers OutputPage::makeResourceLoaderLink
2516 */
2517 public function testMakeResourceLoaderLink( $args, $expectedHtml ) {
2518 $this->setMwGlobals( [
2519 'wgResourceLoaderDebug' => false,
2520 'wgLoadScript' => 'http://127.0.0.1:8080/w/load.php',
2521 'wgCSPReportOnlyHeader' => true,
2522 ] );
2523 $class = new ReflectionClass( OutputPage::class );
2524 $method = $class->getMethod( 'makeResourceLoaderLink' );
2525 $method->setAccessible( true );
2526 $ctx = new RequestContext();
2527 $ctx->setSkin( SkinFactory::getDefaultInstance()->makeSkin( 'fallback' ) );
2528 $ctx->setLanguage( 'en' );
2529 $out = new OutputPage( $ctx );
2530 $nonce = $class->getProperty( 'CSPNonce' );
2531 $nonce->setAccessible( true );
2532 $nonce->setValue( $out, 'secret' );
2533 $rl = $out->getResourceLoader();
2534 $rl->setMessageBlobStore( new NullMessageBlobStore() );
2535 $rl->register( [
2536 'test.foo' => new ResourceLoaderTestModule( [
2537 'script' => 'mw.test.foo( { a: true } );',
2538 'styles' => '.mw-test-foo { content: "style"; }',
2539 ] ),
2540 'test.bar' => new ResourceLoaderTestModule( [
2541 'script' => 'mw.test.bar( { a: true } );',
2542 'styles' => '.mw-test-bar { content: "style"; }',
2543 ] ),
2544 'test.baz' => new ResourceLoaderTestModule( [
2545 'script' => 'mw.test.baz( { a: true } );',
2546 'styles' => '.mw-test-baz { content: "style"; }',
2547 ] ),
2548 'test.quux' => new ResourceLoaderTestModule( [
2549 'script' => 'mw.test.baz( { token: 123 } );',
2550 'styles' => '/* pref-animate=off */ .mw-icon { transition: none; }',
2551 'group' => 'private',
2552 ] ),
2553 'test.noscript' => new ResourceLoaderTestModule( [
2554 'styles' => '.stuff { color: red; }',
2555 'group' => 'noscript',
2556 ] ),
2557 'test.group.foo' => new ResourceLoaderTestModule( [
2558 'script' => 'mw.doStuff( "foo" );',
2559 'group' => 'foo',
2560 ] ),
2561 'test.group.bar' => new ResourceLoaderTestModule( [
2562 'script' => 'mw.doStuff( "bar" );',
2563 'group' => 'bar',
2564 ] ),
2565 ] );
2566 $links = $method->invokeArgs( $out, $args );
2567 $actualHtml = strval( $links );
2568 $this->assertEquals( $expectedHtml, $actualHtml );
2569 }
2570
2571 public static function provideMakeResourceLoaderLink() {
2572 // phpcs:disable Generic.Files.LineLength
2573 return [
2574 // Single only=scripts load
2575 [
2576 [ 'test.foo', ResourceLoaderModule::TYPE_SCRIPTS ],
2577 "<script nonce=\"secret\">(window.RLQ=window.RLQ||[]).push(function(){"
2578 . 'mw.loader.load("http://127.0.0.1:8080/w/load.php?debug=false\u0026lang=en\u0026modules=test.foo\u0026only=scripts\u0026skin=fallback");'
2579 . "});</script>"
2580 ],
2581 // Multiple only=styles load
2582 [
2583 [ [ 'test.baz', 'test.foo', 'test.bar' ], ResourceLoaderModule::TYPE_STYLES ],
2584
2585 '<link rel="stylesheet" href="http://127.0.0.1:8080/w/load.php?debug=false&amp;lang=en&amp;modules=test.bar%2Cbaz%2Cfoo&amp;only=styles&amp;skin=fallback"/>'
2586 ],
2587 // Private embed (only=scripts)
2588 [
2589 [ 'test.quux', ResourceLoaderModule::TYPE_SCRIPTS ],
2590 "<script nonce=\"secret\">(window.RLQ=window.RLQ||[]).push(function(){"
2591 . "mw.test.baz({token:123});\nmw.loader.state({\"test.quux\":\"ready\"});"
2592 . "});</script>"
2593 ],
2594 // Load private module (combined)
2595 [
2596 [ 'test.quux', ResourceLoaderModule::TYPE_COMBINED ],
2597 "<script nonce=\"secret\">(window.RLQ=window.RLQ||[]).push(function(){"
2598 . "mw.loader.implement(\"test.quux@1ev0ijv\",function($,jQuery,require,module){"
2599 . "mw.test.baz({token:123});},{\"css\":[\".mw-icon{transition:none}"
2600 . "\"]});});</script>"
2601 ],
2602 // Load no modules
2603 [
2604 [ [], ResourceLoaderModule::TYPE_COMBINED ],
2605 '',
2606 ],
2607 // noscript group
2608 [
2609 [ 'test.noscript', ResourceLoaderModule::TYPE_STYLES ],
2610 '<noscript><link rel="stylesheet" href="http://127.0.0.1:8080/w/load.php?debug=false&amp;lang=en&amp;modules=test.noscript&amp;only=styles&amp;skin=fallback"/></noscript>'
2611 ],
2612 // Load two modules in separate groups
2613 [
2614 [ [ 'test.group.foo', 'test.group.bar' ], ResourceLoaderModule::TYPE_COMBINED ],
2615 "<script nonce=\"secret\">(window.RLQ=window.RLQ||[]).push(function(){"
2616 . 'mw.loader.load("http://127.0.0.1:8080/w/load.php?debug=false\u0026lang=en\u0026modules=test.group.bar\u0026skin=fallback");'
2617 . 'mw.loader.load("http://127.0.0.1:8080/w/load.php?debug=false\u0026lang=en\u0026modules=test.group.foo\u0026skin=fallback");'
2618 . "});</script>"
2619 ],
2620 ];
2621 // phpcs:enable
2622 }
2623
2624 /**
2625 * @dataProvider provideBuildExemptModules
2626 *
2627 * @covers OutputPage::buildExemptModules
2628 */
2629 public function testBuildExemptModules( array $exemptStyleModules, $expect ) {
2630 $this->setMwGlobals( [
2631 'wgResourceLoaderDebug' => false,
2632 'wgLoadScript' => '/w/load.php',
2633 // Stub wgCacheEpoch as it influences getVersionHash used for the
2634 // urls in the expected HTML
2635 'wgCacheEpoch' => '20140101000000',
2636 ] );
2637
2638 // Set up stubs
2639 $ctx = new RequestContext();
2640 $ctx->setSkin( SkinFactory::getDefaultInstance()->makeSkin( 'fallback' ) );
2641 $ctx->setLanguage( 'en' );
2642 $op = $this->getMockBuilder( OutputPage::class )
2643 ->setConstructorArgs( [ $ctx ] )
2644 ->setMethods( [ 'buildCssLinksArray' ] )
2645 ->getMock();
2646 $op->expects( $this->any() )
2647 ->method( 'buildCssLinksArray' )
2648 ->willReturn( [] );
2649 $rl = $op->getResourceLoader();
2650 $rl->setMessageBlobStore( new NullMessageBlobStore() );
2651
2652 // Register custom modules
2653 $rl->register( [
2654 'example.site.a' => new ResourceLoaderTestModule( [ 'group' => 'site' ] ),
2655 'example.site.b' => new ResourceLoaderTestModule( [ 'group' => 'site' ] ),
2656 'example.user' => new ResourceLoaderTestModule( [ 'group' => 'user' ] ),
2657 ] );
2658
2659 $op = TestingAccessWrapper::newFromObject( $op );
2660 $op->rlExemptStyleModules = $exemptStyleModules;
2661 $this->assertEquals(
2662 $expect,
2663 strval( $op->buildExemptModules() )
2664 );
2665 }
2666
2667 public static function provideBuildExemptModules() {
2668 // phpcs:disable Generic.Files.LineLength
2669 return [
2670 'empty' => [
2671 'exemptStyleModules' => [],
2672 '<meta name="ResourceLoaderDynamicStyles" content=""/>',
2673 ],
2674 'empty sets' => [
2675 'exemptStyleModules' => [ 'site' => [], 'noscript' => [], 'private' => [], 'user' => [] ],
2676 '<meta name="ResourceLoaderDynamicStyles" content=""/>',
2677 ],
2678 'default logged-out' => [
2679 'exemptStyleModules' => [ 'site' => [ 'site.styles' ] ],
2680 '<meta name="ResourceLoaderDynamicStyles" content=""/>' . "\n" .
2681 '<link rel="stylesheet" href="/w/load.php?debug=false&amp;lang=en&amp;modules=site.styles&amp;only=styles&amp;skin=fallback"/>',
2682 ],
2683 'default logged-in' => [
2684 'exemptStyleModules' => [ 'site' => [ 'site.styles' ], 'user' => [ 'user.styles' ] ],
2685 '<meta name="ResourceLoaderDynamicStyles" content=""/>' . "\n" .
2686 '<link rel="stylesheet" href="/w/load.php?debug=false&amp;lang=en&amp;modules=site.styles&amp;only=styles&amp;skin=fallback"/>' . "\n" .
2687 '<link rel="stylesheet" href="/w/load.php?debug=false&amp;lang=en&amp;modules=user.styles&amp;only=styles&amp;skin=fallback&amp;version=1ai9g6t"/>',
2688 ],
2689 'custom modules' => [
2690 'exemptStyleModules' => [
2691 'site' => [ 'site.styles', 'example.site.a', 'example.site.b' ],
2692 'user' => [ 'user.styles', 'example.user' ],
2693 ],
2694 '<meta name="ResourceLoaderDynamicStyles" content=""/>' . "\n" .
2695 '<link rel="stylesheet" href="/w/load.php?debug=false&amp;lang=en&amp;modules=example.site.a%2Cb&amp;only=styles&amp;skin=fallback"/>' . "\n" .
2696 '<link rel="stylesheet" href="/w/load.php?debug=false&amp;lang=en&amp;modules=site.styles&amp;only=styles&amp;skin=fallback"/>' . "\n" .
2697 '<link rel="stylesheet" href="/w/load.php?debug=false&amp;lang=en&amp;modules=example.user&amp;only=styles&amp;skin=fallback&amp;version=0a56zyi"/>' . "\n" .
2698 '<link rel="stylesheet" href="/w/load.php?debug=false&amp;lang=en&amp;modules=user.styles&amp;only=styles&amp;skin=fallback&amp;version=1ai9g6t"/>',
2699 ],
2700 ];
2701 // phpcs:enable
2702 }
2703
2704 /**
2705 * @dataProvider provideTransformFilePath
2706 * @covers OutputPage::transformFilePath
2707 * @covers OutputPage::transformResourcePath
2708 */
2709 public function testTransformResourcePath( $baseDir, $basePath, $uploadDir = null,
2710 $uploadPath = null, $path = null, $expected = null
2711 ) {
2712 if ( $path === null ) {
2713 // Skip optional $uploadDir and $uploadPath
2714 $path = $uploadDir;
2715 $expected = $uploadPath;
2716 $uploadDir = "$baseDir/images";
2717 $uploadPath = "$basePath/images";
2718 }
2719 $this->setMwGlobals( 'IP', $baseDir );
2720 $conf = new HashConfig( [
2721 'ResourceBasePath' => $basePath,
2722 'UploadDirectory' => $uploadDir,
2723 'UploadPath' => $uploadPath,
2724 ] );
2725
2726 // Some of these paths don't exist and will cause warnings
2727 Wikimedia\suppressWarnings();
2728 $actual = OutputPage::transformResourcePath( $conf, $path );
2729 Wikimedia\restoreWarnings();
2730
2731 $this->assertEquals( $expected ?: $path, $actual );
2732 }
2733
2734 public static function provideTransformFilePath() {
2735 $baseDir = dirname( __DIR__ ) . '/data/media';
2736 return [
2737 // File that matches basePath, and exists. Hash found and appended.
2738 [
2739 'baseDir' => $baseDir, 'basePath' => '/w',
2740 '/w/test.jpg',
2741 '/w/test.jpg?edcf2'
2742 ],
2743 // File that matches basePath, but not found on disk. Empty query.
2744 [
2745 'baseDir' => $baseDir, 'basePath' => '/w',
2746 '/w/unknown.png',
2747 '/w/unknown.png?'
2748 ],
2749 // File not matching basePath. Ignored.
2750 [
2751 'baseDir' => $baseDir, 'basePath' => '/w',
2752 '/files/test.jpg'
2753 ],
2754 // Empty string. Ignored.
2755 [
2756 'baseDir' => $baseDir, 'basePath' => '/w',
2757 '',
2758 ''
2759 ],
2760 // Similar path, but with domain component. Ignored.
2761 [
2762 'baseDir' => $baseDir, 'basePath' => '/w',
2763 '//example.org/w/test.jpg'
2764 ],
2765 [
2766 'baseDir' => $baseDir, 'basePath' => '/w',
2767 'https://example.org/w/test.jpg'
2768 ],
2769 // Unrelated path with domain component. Ignored.
2770 [
2771 'baseDir' => $baseDir, 'basePath' => '/w',
2772 'https://example.org/files/test.jpg'
2773 ],
2774 [
2775 'baseDir' => $baseDir, 'basePath' => '/w',
2776 '//example.org/files/test.jpg'
2777 ],
2778 // Unrelated path with domain, and empty base path (root mw install). Ignored.
2779 [
2780 'baseDir' => $baseDir, 'basePath' => '',
2781 'https://example.org/files/test.jpg'
2782 ],
2783 [
2784 'baseDir' => $baseDir, 'basePath' => '',
2785 // T155310
2786 '//example.org/files/test.jpg'
2787 ],
2788 // Check UploadPath before ResourceBasePath (T155146)
2789 [
2790 'baseDir' => dirname( $baseDir ), 'basePath' => '',
2791 'uploadDir' => $baseDir, 'uploadPath' => '/images',
2792 '/images/test.jpg',
2793 '/images/test.jpg?edcf2'
2794 ],
2795 ];
2796 }
2797
2798 /**
2799 * Tests a particular case of transformCssMedia, using the given input, globals,
2800 * expected return, and message
2801 *
2802 * Asserts that $expectedReturn is returned.
2803 *
2804 * options['printableQuery'] - value of query string for printable, or omitted for none
2805 * options['handheldQuery'] - value of query string for handheld, or omitted for none
2806 * options['media'] - passed into the method under the same name
2807 * options['expectedReturn'] - expected return value
2808 * options['message'] - PHPUnit message for assertion
2809 *
2810 * @param array $args Key-value array of arguments as shown above
2811 */
2812 protected function assertTransformCssMediaCase( $args ) {
2813 $queryData = [];
2814 if ( isset( $args['printableQuery'] ) ) {
2815 $queryData['printable'] = $args['printableQuery'];
2816 }
2817
2818 if ( isset( $args['handheldQuery'] ) ) {
2819 $queryData['handheld'] = $args['handheldQuery'];
2820 }
2821
2822 $fauxRequest = new FauxRequest( $queryData, false );
2823 $this->setMwGlobals( [
2824 'wgRequest' => $fauxRequest,
2825 ] );
2826
2827 $actualReturn = OutputPage::transformCssMedia( $args['media'] );
2828 $this->assertSame( $args['expectedReturn'], $actualReturn, $args['message'] );
2829 }
2830
2831 /**
2832 * Tests print requests
2833 *
2834 * @covers OutputPage::transformCssMedia
2835 */
2836 public function testPrintRequests() {
2837 $this->assertTransformCssMediaCase( [
2838 'printableQuery' => '1',
2839 'media' => 'screen',
2840 'expectedReturn' => null,
2841 'message' => 'On printable request, screen returns null'
2842 ] );
2843
2844 $this->assertTransformCssMediaCase( [
2845 'printableQuery' => '1',
2846 'media' => self::SCREEN_MEDIA_QUERY,
2847 'expectedReturn' => null,
2848 'message' => 'On printable request, screen media query returns null'
2849 ] );
2850
2851 $this->assertTransformCssMediaCase( [
2852 'printableQuery' => '1',
2853 'media' => self::SCREEN_ONLY_MEDIA_QUERY,
2854 'expectedReturn' => null,
2855 'message' => 'On printable request, screen media query with only returns null'
2856 ] );
2857
2858 $this->assertTransformCssMediaCase( [
2859 'printableQuery' => '1',
2860 'media' => 'print',
2861 'expectedReturn' => '',
2862 'message' => 'On printable request, media print returns empty string'
2863 ] );
2864 }
2865
2866 /**
2867 * Tests screen requests, without either query parameter set
2868 *
2869 * @covers OutputPage::transformCssMedia
2870 */
2871 public function testScreenRequests() {
2872 $this->assertTransformCssMediaCase( [
2873 'media' => 'screen',
2874 'expectedReturn' => 'screen',
2875 'message' => 'On screen request, screen media type is preserved'
2876 ] );
2877
2878 $this->assertTransformCssMediaCase( [
2879 'media' => 'handheld',
2880 'expectedReturn' => 'handheld',
2881 'message' => 'On screen request, handheld media type is preserved'
2882 ] );
2883
2884 $this->assertTransformCssMediaCase( [
2885 'media' => self::SCREEN_MEDIA_QUERY,
2886 'expectedReturn' => self::SCREEN_MEDIA_QUERY,
2887 'message' => 'On screen request, screen media query is preserved.'
2888 ] );
2889
2890 $this->assertTransformCssMediaCase( [
2891 'media' => self::SCREEN_ONLY_MEDIA_QUERY,
2892 'expectedReturn' => self::SCREEN_ONLY_MEDIA_QUERY,
2893 'message' => 'On screen request, screen media query with only is preserved.'
2894 ] );
2895
2896 $this->assertTransformCssMediaCase( [
2897 'media' => 'print',
2898 'expectedReturn' => 'print',
2899 'message' => 'On screen request, print media type is preserved'
2900 ] );
2901 }
2902
2903 /**
2904 * Tests handheld behavior
2905 *
2906 * @covers OutputPage::transformCssMedia
2907 */
2908 public function testHandheld() {
2909 $this->assertTransformCssMediaCase( [
2910 'handheldQuery' => '1',
2911 'media' => 'handheld',
2912 'expectedReturn' => '',
2913 'message' => 'On request with handheld querystring and media is handheld, returns empty string'
2914 ] );
2915
2916 $this->assertTransformCssMediaCase( [
2917 'handheldQuery' => '1',
2918 'media' => 'screen',
2919 'expectedReturn' => null,
2920 'message' => 'On request with handheld querystring and media is screen, returns null'
2921 ] );
2922 }
2923
2924 /**
2925 * @covers OutputPage::isTOCEnabled
2926 * @covers OutputPage::addParserOutputMetadata
2927 * @covers OutputPage::addParserOutput
2928 */
2929 public function testIsTOCEnabled() {
2930 $op = $this->newInstance();
2931 $this->assertFalse( $op->isTOCEnabled() );
2932
2933 $pOut1 = $this->createParserOutputStub( 'getTOCHTML', false );
2934 $op->addParserOutputMetadata( $pOut1 );
2935 $this->assertFalse( $op->isTOCEnabled() );
2936
2937 $pOut2 = $this->createParserOutputStub( 'getTOCHTML', true );
2938 $op->addParserOutput( $pOut2 );
2939 $this->assertTrue( $op->isTOCEnabled() );
2940
2941 // The parser output doesn't disable the TOC after it was enabled
2942 $op->addParserOutputMetadata( $pOut1 );
2943 $this->assertTrue( $op->isTOCEnabled() );
2944 }
2945
2946 /**
2947 * @dataProvider providePreloadLinkHeaders
2948 * @covers ResourceLoaderSkinModule::getPreloadLinks
2949 * @covers ResourceLoaderSkinModule::getLogoPreloadlinks
2950 */
2951 public function testPreloadLinkHeaders( $config, $result ) {
2952 $this->setMwGlobals( $config );
2953 $ctx = $this->getMockBuilder( ResourceLoaderContext::class )
2954 ->disableOriginalConstructor()->getMock();
2955 $module = new ResourceLoaderSkinModule();
2956
2957 $this->assertEquals( [ $result ], $module->getHeaders( $ctx ) );
2958 }
2959
2960 public function providePreloadLinkHeaders() {
2961 return [
2962 [
2963 [
2964 'wgResourceBasePath' => '/w',
2965 'wgLogo' => '/img/default.png',
2966 'wgLogoHD' => [
2967 '1.5x' => '/img/one-point-five.png',
2968 '2x' => '/img/two-x.png',
2969 ],
2970 ],
2971 'Link: </img/default.png>;rel=preload;as=image;media=' .
2972 'not all and (min-resolution: 1.5dppx),' .
2973 '</img/one-point-five.png>;rel=preload;as=image;media=' .
2974 '(min-resolution: 1.5dppx) and (max-resolution: 1.999999dppx),' .
2975 '</img/two-x.png>;rel=preload;as=image;media=(min-resolution: 2dppx)'
2976 ],
2977 [
2978 [
2979 'wgResourceBasePath' => '/w',
2980 'wgLogo' => '/img/default.png',
2981 'wgLogoHD' => false,
2982 ],
2983 'Link: </img/default.png>;rel=preload;as=image'
2984 ],
2985 [
2986 [
2987 'wgResourceBasePath' => '/w',
2988 'wgLogo' => '/img/default.png',
2989 'wgLogoHD' => [
2990 '2x' => '/img/two-x.png',
2991 ],
2992 ],
2993 'Link: </img/default.png>;rel=preload;as=image;media=' .
2994 'not all and (min-resolution: 2dppx),' .
2995 '</img/two-x.png>;rel=preload;as=image;media=(min-resolution: 2dppx)'
2996 ],
2997 [
2998 [
2999 'wgResourceBasePath' => '/w',
3000 'wgLogo' => '/img/default.png',
3001 'wgLogoHD' => [
3002 'svg' => '/img/vector.svg',
3003 ],
3004 ],
3005 'Link: </img/vector.svg>;rel=preload;as=image'
3006
3007 ],
3008 [
3009 [
3010 'wgResourceBasePath' => '/w',
3011 'wgLogo' => '/w/test.jpg',
3012 'wgLogoHD' => false,
3013 'wgUploadPath' => '/w/images',
3014 'IP' => dirname( __DIR__ ) . '/data/media',
3015 ],
3016 'Link: </w/test.jpg?edcf2>;rel=preload;as=image',
3017 ],
3018 ];
3019 }
3020
3021 /**
3022 * @return OutputPage
3023 */
3024 private function newInstance( $config = [], WebRequest $request = null, $options = [] ) {
3025 $context = new RequestContext();
3026
3027 $context->setConfig( new MultiConfig( [
3028 new HashConfig( $config + [
3029 'AppleTouchIcon' => false,
3030 'DisableLangConversion' => true,
3031 'EnableCanonicalServerLink' => false,
3032 'Favicon' => false,
3033 'Feed' => false,
3034 'LanguageCode' => false,
3035 'ReferrerPolicy' => false,
3036 'RightsPage' => false,
3037 'RightsUrl' => false,
3038 'UniversalEditButton' => false,
3039 ] ),
3040 $context->getConfig()
3041 ] ) );
3042
3043 if ( !in_array( 'notitle', (array)$options ) ) {
3044 $context->setTitle( Title::newFromText( 'My test page' ) );
3045 }
3046
3047 if ( $request ) {
3048 $context->setRequest( $request );
3049 }
3050
3051 return new OutputPage( $context );
3052 }
3053 }
3054
3055 /**
3056 * MessageBlobStore that doesn't do anything
3057 */
3058 class NullMessageBlobStore extends MessageBlobStore {
3059 public function get( ResourceLoader $resourceLoader, $modules, $lang ) {
3060 return [];
3061 }
3062
3063 public function updateModule( $name, ResourceLoaderModule $module, $lang ) {
3064 }
3065
3066 public function updateMessage( $key ) {
3067 }
3068
3069 public function clear() {
3070 }
3071 }
Wiklou, le Wiki du Wiklou