3 namespace MediaWiki\Tests\Revision
;
5 use CommentStoreComment
;
9 use MediaWiki\Permissions\PermissionManager
;
10 use MediaWiki\Revision\MutableRevisionRecord
;
11 use MediaWiki\Revision\MainSlotRoleHandler
;
12 use MediaWiki\Revision\RevisionRecord
;
13 use MediaWiki\Revision\RevisionRenderer
;
14 use MediaWiki\Revision\SlotRecord
;
15 use MediaWiki\Revision\SlotRoleRegistry
;
16 use MediaWiki\Storage\NameTableStore
;
17 use MediaWikiTestCase
;
18 use MediaWiki\User\UserIdentityValue
;
21 use PHPUnit\Framework\MockObject\MockObject
;
24 use Wikimedia\Rdbms\IDatabase
;
25 use Wikimedia\Rdbms\ILoadBalancer
;
29 * @covers \MediaWiki\Revision\RevisionRenderer
31 class RevisionRendererTest
extends MediaWikiTestCase
{
33 /** @var PermissionManager|\PHPUnit_Framework_MockObject_MockObject $permissionManagerMock */
34 private $permissionManagerMock;
36 protected function setUp() {
39 $this->permissionManagerMock
= $this->createMock( PermissionManager
::class );
40 $this->overrideMwServices( null, [
41 'PermissionManager' => function (): PermissionManager
{
42 return $this->permissionManagerMock
;
48 * @param int $articleId
49 * @param int $revisionId
52 private function getMockTitle( $articleId, $revisionId ) {
53 /** @var Title|MockObject $mock */
54 $mock = $this->getMockBuilder( Title
::class )
55 ->disableOriginalConstructor()
57 $mock->expects( $this->any() )
58 ->method( 'getNamespace' )
59 ->will( $this->returnValue( NS_MAIN
) );
60 $mock->expects( $this->any() )
62 ->will( $this->returnValue( __CLASS__
) );
63 $mock->expects( $this->any() )
64 ->method( 'getPrefixedText' )
65 ->will( $this->returnValue( __CLASS__
) );
66 $mock->expects( $this->any() )
67 ->method( 'getDBkey' )
68 ->will( $this->returnValue( __CLASS__
) );
69 $mock->expects( $this->any() )
70 ->method( 'getArticleID' )
71 ->will( $this->returnValue( $articleId ) );
72 $mock->expects( $this->any() )
73 ->method( 'getLatestRevId' )
74 ->will( $this->returnValue( $revisionId ) );
75 $mock->expects( $this->any() )
76 ->method( 'getContentModel' )
77 ->will( $this->returnValue( CONTENT_MODEL_WIKITEXT
) );
78 $mock->expects( $this->any() )
79 ->method( 'getPageLanguage' )
80 ->will( $this->returnValue( Language
::factory( 'en' ) ) );
81 $mock->expects( $this->any() )
82 ->method( 'isContentPage' )
83 ->will( $this->returnValue( true ) );
84 $mock->expects( $this->any() )
87 function ( Title
$other ) use ( $mock ) {
88 return $mock->getArticleID() === $other->getArticleID();
91 $this->permissionManagerMock
->expects( $this->any() )
94 function ( $perm, User
$user ) {
95 return $user->isAllowed( $perm );
104 * @param int $linkCount
108 private function getMockDatabaseConnection( $maxRev = 100, $linkCount = 0 ) {
109 /** @var IDatabase|MockObject $db */
110 $db = $this->getMock( IDatabase
::class );
111 $db->method( 'selectField' )
112 ->willReturnCallback(
113 function ( $table, $fields, $cond ) use ( $maxRev, $linkCount ) {
114 return $this->selectFieldCallback(
128 * @return RevisionRenderer
130 private function newRevisionRenderer( $maxRev = 100, $useMaster = false ) {
131 $dbIndex = $useMaster ? DB_MASTER
: DB_REPLICA
;
133 $db = $this->getMockDatabaseConnection( $maxRev );
135 /** @var ILoadBalancer|MockObject $lb */
136 $lb = $this->getMock( ILoadBalancer
::class );
137 $lb->method( 'getConnection' )
140 $lb->method( 'getConnectionRef' )
143 $lb->method( 'getLazyConnectionRef' )
147 /** @var NameTableStore|MockObject $slotRoles */
148 $slotRoles = $this->getMockBuilder( NameTableStore
::class )
149 ->disableOriginalConstructor()
151 $slotRoles->method( 'getMap' )
154 $roleReg = new SlotRoleRegistry( $slotRoles );
155 $roleReg->defineRole( 'main', function () {
156 return new MainSlotRoleHandler( [] );
158 $roleReg->defineRoleWithModel( 'aux', CONTENT_MODEL_WIKITEXT
);
160 return new RevisionRenderer( $lb, $roleReg );
163 private function selectFieldCallback( $table, $fields, $cond, $maxRev ) {
164 if ( [ $table, $fields, $cond ] === [ 'revision', 'MAX(rev_id)', [] ] ) {
168 $this->fail( 'Unexpected call to selectField' );
169 throw new LogicException( 'Ooops' ); // Can't happen, make analyzer happy
172 public function testGetRenderedRevision_new() {
173 $renderer = $this->newRevisionRenderer( 100 );
174 $title = $this->getMockTitle( 7, 21 );
176 $rev = new MutableRevisionRecord( $title );
177 $rev->setUser( new UserIdentityValue( 9, 'Frank', 0 ) );
178 $rev->setTimestamp( '20180101000003' );
179 $rev->setComment( CommentStoreComment
::newUnsavedComment( '' ) );
182 $text .= "* page:{{PAGENAME}}\n";
183 $text .= "* rev:{{REVISIONID}}\n";
184 $text .= "* user:{{REVISIONUSER}}\n";
185 $text .= "* time:{{REVISIONTIMESTAMP}}\n";
186 $text .= "* [[Link It]]\n";
188 $rev->setContent( SlotRecord
::MAIN
, new WikitextContent( $text ) );
190 $options = ParserOptions
::newCanonical( 'canonical' );
191 $rr = $renderer->getRenderedRevision( $rev, $options );
193 $this->assertFalse( $rr->isContentDeleted(), 'isContentDeleted' );
195 $this->assertSame( $rev, $rr->getRevision() );
196 $this->assertSame( $options, $rr->getOptions() );
198 $html = $rr->getRevisionParserOutput()->getText();
200 $this->assertContains( 'page:' . __CLASS__
, $html );
201 $this->assertContains( 'rev:101', $html ); // from speculativeRevIdCallback
202 $this->assertContains( 'user:Frank', $html );
203 $this->assertContains( 'time:20180101000003', $html );
205 $this->assertSame( $html, $rr->getSlotParserOutput( SlotRecord
::MAIN
)->getText() );
208 public function testGetRenderedRevision_current() {
209 $renderer = $this->newRevisionRenderer( 100 );
210 $title = $this->getMockTitle( 7, 21 );
212 $rev = new MutableRevisionRecord( $title );
213 $rev->setId( 21 ); // current!
214 $rev->setUser( new UserIdentityValue( 9, 'Frank', 0 ) );
215 $rev->setTimestamp( '20180101000003' );
216 $rev->setComment( CommentStoreComment
::newUnsavedComment( '' ) );
219 $text .= "* page:{{PAGENAME}}\n";
220 $text .= "* rev:{{REVISIONID}}\n";
221 $text .= "* user:{{REVISIONUSER}}\n";
222 $text .= "* time:{{REVISIONTIMESTAMP}}\n";
224 $rev->setContent( SlotRecord
::MAIN
, new WikitextContent( $text ) );
226 $options = ParserOptions
::newCanonical( 'canonical' );
227 $rr = $renderer->getRenderedRevision( $rev, $options );
229 $this->assertFalse( $rr->isContentDeleted(), 'isContentDeleted' );
231 $this->assertSame( $rev, $rr->getRevision() );
232 $this->assertSame( $options, $rr->getOptions() );
234 $html = $rr->getRevisionParserOutput()->getText();
236 $this->assertContains( 'page:' . __CLASS__
, $html );
237 $this->assertContains( 'rev:21', $html );
238 $this->assertContains( 'user:Frank', $html );
239 $this->assertContains( 'time:20180101000003', $html );
241 $this->assertSame( $html, $rr->getSlotParserOutput( SlotRecord
::MAIN
)->getText() );
244 public function testGetRenderedRevision_master() {
245 $renderer = $this->newRevisionRenderer( 100, true ); // use master
246 $title = $this->getMockTitle( 7, 21 );
248 $rev = new MutableRevisionRecord( $title );
249 $rev->setId( 21 ); // current!
250 $rev->setUser( new UserIdentityValue( 9, 'Frank', 0 ) );
251 $rev->setTimestamp( '20180101000003' );
252 $rev->setComment( CommentStoreComment
::newUnsavedComment( '' ) );
255 $text .= "* page:{{PAGENAME}}\n";
256 $text .= "* rev:{{REVISIONID}}\n";
257 $text .= "* user:{{REVISIONUSER}}\n";
258 $text .= "* time:{{REVISIONTIMESTAMP}}\n";
260 $rev->setContent( SlotRecord
::MAIN
, new WikitextContent( $text ) );
262 $options = ParserOptions
::newCanonical( 'canonical' );
263 $rr = $renderer->getRenderedRevision( $rev, $options, null, [ 'use-master' => true ] );
265 $this->assertFalse( $rr->isContentDeleted(), 'isContentDeleted' );
267 $html = $rr->getRevisionParserOutput()->getText();
269 $this->assertContains( 'rev:21', $html );
271 $this->assertSame( $html, $rr->getSlotParserOutput( SlotRecord
::MAIN
)->getText() );
274 public function testGetRenderedRevision_known() {
275 $renderer = $this->newRevisionRenderer( 100, true ); // use master
276 $title = $this->getMockTitle( 7, 21 );
278 $rev = new MutableRevisionRecord( $title );
279 $rev->setId( 21 ); // current!
280 $rev->setUser( new UserIdentityValue( 9, 'Frank', 0 ) );
281 $rev->setTimestamp( '20180101000003' );
282 $rev->setComment( CommentStoreComment
::newUnsavedComment( '' ) );
284 $text = "uncached text";
285 $rev->setContent( SlotRecord
::MAIN
, new WikitextContent( $text ) );
287 $output = new ParserOutput( 'cached text' );
289 $options = ParserOptions
::newCanonical( 'canonical' );
290 $rr = $renderer->getRenderedRevision(
294 [ 'known-revision-output' => $output ]
297 $this->assertSame( $output, $rr->getRevisionParserOutput() );
298 $this->assertSame( 'cached text', $rr->getRevisionParserOutput()->getText() );
299 $this->assertSame( 'cached text', $rr->getSlotParserOutput( SlotRecord
::MAIN
)->getText() );
302 public function testGetRenderedRevision_old() {
303 $renderer = $this->newRevisionRenderer( 100 );
304 $title = $this->getMockTitle( 7, 21 );
306 $rev = new MutableRevisionRecord( $title );
307 $rev->setId( 11 ); // old!
308 $rev->setUser( new UserIdentityValue( 9, 'Frank', 0 ) );
309 $rev->setTimestamp( '20180101000003' );
310 $rev->setComment( CommentStoreComment
::newUnsavedComment( '' ) );
313 $text .= "* page:{{PAGENAME}}\n";
314 $text .= "* rev:{{REVISIONID}}\n";
315 $text .= "* user:{{REVISIONUSER}}\n";
316 $text .= "* time:{{REVISIONTIMESTAMP}}\n";
318 $rev->setContent( SlotRecord
::MAIN
, new WikitextContent( $text ) );
320 $options = ParserOptions
::newCanonical( 'canonical' );
321 $rr = $renderer->getRenderedRevision( $rev, $options );
323 $this->assertFalse( $rr->isContentDeleted(), 'isContentDeleted' );
325 $this->assertSame( $rev, $rr->getRevision() );
326 $this->assertSame( $options, $rr->getOptions() );
328 $html = $rr->getRevisionParserOutput()->getText();
330 $this->assertContains( 'page:' . __CLASS__
, $html );
331 $this->assertContains( 'rev:11', $html );
332 $this->assertContains( 'user:Frank', $html );
333 $this->assertContains( 'time:20180101000003', $html );
335 $this->assertSame( $html, $rr->getSlotParserOutput( 'main' )->getText() );
338 public function testGetRenderedRevision_suppressed() {
339 $renderer = $this->newRevisionRenderer( 100 );
340 $title = $this->getMockTitle( 7, 21 );
342 $rev = new MutableRevisionRecord( $title );
343 $rev->setId( 11 ); // old!
344 $rev->setVisibility( RevisionRecord
::DELETED_TEXT
); // suppressed!
345 $rev->setUser( new UserIdentityValue( 9, 'Frank', 0 ) );
346 $rev->setTimestamp( '20180101000003' );
347 $rev->setComment( CommentStoreComment
::newUnsavedComment( '' ) );
350 $text .= "* page:{{PAGENAME}}\n";
351 $text .= "* rev:{{REVISIONID}}\n";
352 $text .= "* user:{{REVISIONUSER}}\n";
353 $text .= "* time:{{REVISIONTIMESTAMP}}\n";
355 $rev->setContent( SlotRecord
::MAIN
, new WikitextContent( $text ) );
357 $options = ParserOptions
::newCanonical( 'canonical' );
358 $rr = $renderer->getRenderedRevision( $rev, $options );
360 $this->assertNull( $rr, 'getRenderedRevision' );
363 public function testGetRenderedRevision_privileged() {
364 $renderer = $this->newRevisionRenderer( 100 );
365 $title = $this->getMockTitle( 7, 21 );
367 $rev = new MutableRevisionRecord( $title );
368 $rev->setId( 11 ); // old!
369 $rev->setVisibility( RevisionRecord
::DELETED_TEXT
); // suppressed!
370 $rev->setUser( new UserIdentityValue( 9, 'Frank', 0 ) );
371 $rev->setTimestamp( '20180101000003' );
372 $rev->setComment( CommentStoreComment
::newUnsavedComment( '' ) );
375 $text .= "* page:{{PAGENAME}}\n";
376 $text .= "* rev:{{REVISIONID}}\n";
377 $text .= "* user:{{REVISIONUSER}}\n";
378 $text .= "* time:{{REVISIONTIMESTAMP}}\n";
380 $rev->setContent( SlotRecord
::MAIN
, new WikitextContent( $text ) );
382 $options = ParserOptions
::newCanonical( 'canonical' );
383 $sysop = $this->getTestUser( [ 'sysop' ] )->getUser(); // privileged!
384 $rr = $renderer->getRenderedRevision( $rev, $options, $sysop );
386 $this->assertTrue( $rr->isContentDeleted(), 'isContentDeleted' );
388 $this->assertSame( $rev, $rr->getRevision() );
389 $this->assertSame( $options, $rr->getOptions() );
391 $html = $rr->getRevisionParserOutput()->getText();
393 // Suppressed content should be visible for sysops
394 $this->assertContains( 'page:' . __CLASS__
, $html );
395 $this->assertContains( 'rev:11', $html );
396 $this->assertContains( 'user:Frank', $html );
397 $this->assertContains( 'time:20180101000003', $html );
399 $this->assertSame( $html, $rr->getSlotParserOutput( 'main' )->getText() );
402 public function testGetRenderedRevision_raw() {
403 $renderer = $this->newRevisionRenderer( 100 );
404 $title = $this->getMockTitle( 7, 21 );
406 $rev = new MutableRevisionRecord( $title );
407 $rev->setId( 11 ); // old!
408 $rev->setVisibility( RevisionRecord
::DELETED_TEXT
); // suppressed!
409 $rev->setUser( new UserIdentityValue( 9, 'Frank', 0 ) );
410 $rev->setTimestamp( '20180101000003' );
411 $rev->setComment( CommentStoreComment
::newUnsavedComment( '' ) );
414 $text .= "* page:{{PAGENAME}}\n";
415 $text .= "* rev:{{REVISIONID}}\n";
416 $text .= "* user:{{REVISIONUSER}}\n";
417 $text .= "* time:{{REVISIONTIMESTAMP}}\n";
419 $rev->setContent( SlotRecord
::MAIN
, new WikitextContent( $text ) );
421 $options = ParserOptions
::newCanonical( 'canonical' );
422 $rr = $renderer->getRenderedRevision(
426 [ 'audience' => RevisionRecord
::RAW
]
429 $this->assertTrue( $rr->isContentDeleted(), 'isContentDeleted' );
431 $this->assertSame( $rev, $rr->getRevision() );
432 $this->assertSame( $options, $rr->getOptions() );
434 $html = $rr->getRevisionParserOutput()->getText();
436 // Suppressed content should be visible in raw mode
437 $this->assertContains( 'page:' . __CLASS__
, $html );
438 $this->assertContains( 'rev:11', $html );
439 $this->assertContains( 'user:Frank', $html );
440 $this->assertContains( 'time:20180101000003', $html );
442 $this->assertSame( $html, $rr->getSlotParserOutput( 'main' )->getText() );
445 public function testGetRenderedRevision_multi() {
446 $renderer = $this->newRevisionRenderer();
447 $title = $this->getMockTitle( 7, 21 );
449 $rev = new MutableRevisionRecord( $title );
450 $rev->setUser( new UserIdentityValue( 9, 'Frank', 0 ) );
451 $rev->setTimestamp( '20180101000003' );
452 $rev->setComment( CommentStoreComment
::newUnsavedComment( '' ) );
454 $rev->setContent( SlotRecord
::MAIN
, new WikitextContent( '[[Kittens]]' ) );
455 $rev->setContent( 'aux', new WikitextContent( '[[Goats]]' ) );
457 $rr = $renderer->getRenderedRevision( $rev );
459 $combinedOutput = $rr->getRevisionParserOutput();
460 $mainOutput = $rr->getSlotParserOutput( SlotRecord
::MAIN
);
461 $auxOutput = $rr->getSlotParserOutput( 'aux' );
463 $combinedHtml = $combinedOutput->getText();
464 $mainHtml = $mainOutput->getText();
465 $auxHtml = $auxOutput->getText();
467 $this->assertContains( 'Kittens', $mainHtml );
468 $this->assertContains( 'Goats', $auxHtml );
469 $this->assertNotContains( 'Goats', $mainHtml );
470 $this->assertNotContains( 'Kittens', $auxHtml );
471 $this->assertContains( 'Kittens', $combinedHtml );
472 $this->assertContains( 'Goats', $combinedHtml );
473 $this->assertContains( '>aux<', $combinedHtml, 'slot header' );
474 $this->assertNotContains( '<mw:slotheader', $combinedHtml, 'slot header placeholder' );
476 // make sure output wrapping works right
477 $this->assertContains( 'class="mw-parser-output"', $mainHtml );
478 $this->assertContains( 'class="mw-parser-output"', $auxHtml );
479 $this->assertContains( 'class="mw-parser-output"', $combinedHtml );
481 // there should be only one wrapper div
482 $this->assertSame( 1, preg_match_all( '#class="mw-parser-output"#', $combinedHtml ) );
483 $this->assertNotContains( 'class="mw-parser-output"', $combinedOutput->getRawText() );
485 $combinedLinks = $combinedOutput->getLinks();
486 $mainLinks = $mainOutput->getLinks();
487 $auxLinks = $auxOutput->getLinks();
488 $this->assertTrue( isset( $combinedLinks[NS_MAIN
]['Kittens'] ), 'links from main slot' );
489 $this->assertTrue( isset( $combinedLinks[NS_MAIN
]['Goats'] ), 'links from aux slot' );
490 $this->assertFalse( isset( $mainLinks[NS_MAIN
]['Goats'] ), 'no aux links in main' );
491 $this->assertFalse( isset( $auxLinks[NS_MAIN
]['Kittens'] ), 'no main links in aux' );
494 public function testGetRenderedRevision_noHtml() {
495 /** @var MockObject|Content $mockContent */
496 $mockContent = $this->getMockBuilder( WikitextContent
::class )
497 ->setMethods( [ 'getParserOutput' ] )
498 ->setConstructorArgs( [ 'Whatever' ] )
500 $mockContent->method( 'getParserOutput' )
501 ->willReturnCallback( function ( Title
$title, $revId = null,
502 ParserOptions
$options = null, $generateHtml = true
504 if ( !$generateHtml ) {
505 return new ParserOutput( null );
507 $this->fail( 'Should not be called with $generateHtml == true' );
508 return null; // never happens, make analyzer happy
512 $renderer = $this->newRevisionRenderer();
513 $title = $this->getMockTitle( 7, 21 );
515 $rev = new MutableRevisionRecord( $title );
516 $rev->setContent( SlotRecord
::MAIN
, $mockContent );
517 $rev->setContent( 'aux', $mockContent );
519 // NOTE: we are testing the private combineSlotOutput() callback here.
520 $rr = $renderer->getRenderedRevision( $rev );
522 $output = $rr->getSlotParserOutput( SlotRecord
::MAIN
, [ 'generate-html' => false ] );
523 $this->assertFalse( $output->hasText(), 'hasText' );
525 $output = $rr->getRevisionParserOutput( [ 'generate-html' => false ] );
526 $this->assertFalse( $output->hasText(), 'hasText' );