tests/phpunit/includes/parser/ParserMethodsTest.php

   1 <?php
   2
   3 use MediaWiki\MediaWikiServices;
   4 use MediaWiki\Revision\MutableRevisionRecord;
   5 use MediaWiki\Revision\RevisionStore;
   6 use MediaWiki\Revision\SlotRecord;
   7 use MediaWiki\User\UserIdentityValue;
   8
   9 /**
  10  * @group Database
  11  * @covers Parser
  12  * @covers BlockLevelPass
  13  */
  14 class ParserMethodsTest extends MediaWikiLangTestCase {
  15
  16         public static function providePreSaveTransform() {
  17                 return [
  18                         [ 'hello this is ~~~',
  19                                 "hello this is [[Special:Contributions/127.0.0.1|127.0.0.1]]",
  20                         ],
  21                         [ 'hello \'\'this\'\' is <nowiki>~~~</nowiki>',
  22                                 'hello \'\'this\'\' is <nowiki>~~~</nowiki>',
  23                         ],
  24                 ];
  25         }
  26
  27         /**
  28          * @dataProvider providePreSaveTransform
  29          */
  30         public function testPreSaveTransform( $text, $expected ) {
  31                 $title = Title::newFromText( str_replace( '::', '__', __METHOD__ ) );
  32                 $user = new User();
  33                 $user->setName( "127.0.0.1" );
  34                 $popts = ParserOptions::newFromUser( $user );
  35                 $text = MediaWikiServices::getInstance()->getParser()
  36                         ->preSaveTransform( $text, $title, $user, $popts );
  37
  38                 $this->assertEquals( $expected, $text );
  39         }
  40
  41         public static function provideStripOuterParagraph() {
  42                 // This mimics the most common use case (stripping paragraphs generated by the parser).
  43                 $message = new RawMessage( "Message text." );
  44
  45                 return [
  46                         [
  47                                 "<p>Text.</p>",
  48                                 "Text.",
  49                         ],
  50                         [
  51                                 "<p class='foo'>Text.</p>",
  52                                 "<p class='foo'>Text.</p>",
  53                         ],
  54                         [
  55                                 "<p>Text.\n</p>\n",
  56                                 "Text.",
  57                         ],
  58                         [
  59                                 "<p>Text.</p><p>More text.</p>",
  60                                 "<p>Text.</p><p>More text.</p>",
  61                         ],
  62                         [
  63                                 $message->parse(),
  64                                 "Message text.",
  65                         ],
  66                 ];
  67         }
  68
  69         /**
  70          * @dataProvider provideStripOuterParagraph
  71          */
  72         public function testStripOuterParagraph( $text, $expected ) {
  73                 $this->assertEquals( $expected, Parser::stripOuterParagraph( $text ) );
  74         }
  75
  76         /**
  77          * @expectedException MWException
  78          * @expectedExceptionMessage Parser state cleared while parsing.
  79          *  Did you call Parser::parse recursively?
  80          */
  81         public function testRecursiveParse() {
  82                 $title = Title::newFromText( 'foo' );
  83                 $parser = MediaWikiServices::getInstance()->getParser();
  84                 $po = new ParserOptions;
  85                 $parser->setHook( 'recursivecallparser', [ $this, 'helperParserFunc' ] );
  86                 $parser->parse( '<recursivecallparser>baz</recursivecallparser>', $title, $po );
  87         }
  88
  89         public function helperParserFunc( $input, $args, $parser ) {
  90                 $title = Title::newFromText( 'foo' );
  91                 $po = new ParserOptions;
  92                 $parser->parse( $input, $title, $po );
  93                 return 'bar';
  94         }
  95
  96         public function testCallParserFunction() {
  97                 // Normal parses test passing PPNodes. Test passing an array.
  98                 $title = Title::newFromText( str_replace( '::', '__', __METHOD__ ) );
  99                 $parser = MediaWikiServices::getInstance()->getParser();
 100                 $parser->startExternalParse( $title, new ParserOptions(), Parser::OT_HTML );
 101                 $frame = $parser->getPreprocessor()->newFrame();
 102                 $ret = $parser->callParserFunction( $frame, '#tag',
 103                         [ 'pre', 'foo', 'style' => 'margin-left: 1.6em' ]
 104                 );
 105                 $ret['text'] = $parser->mStripState->unstripBoth( $ret['text'] );
 106                 $this->assertSame( [
 107                         'found' => true,
 108                         'text' => '<pre style="margin-left: 1.6em">foo</pre>',
 109                 ], $ret, 'callParserFunction works for {{#tag:pre|foo|style=margin-left: 1.6em}}' );
 110         }
 111
 112         /**
 113          * @covers Parser
 114          * @covers ParserOutput::getSections
 115          */
 116         public function testGetSections() {
 117                 $title = Title::newFromText( str_replace( '::', '__', __METHOD__ ) );
 118                 $out = MediaWikiServices::getInstance()->getParser()
 119                         ->parse( "==foo==\n<h2>bar</h2>\n==baz==\n", $title, new ParserOptions() );
 120                 $this->assertSame( [
 121                         [
 122                                 'toclevel' => 1,
 123                                 'level' => '2',
 124                                 'line' => 'foo',
 125                                 'number' => '1',
 126                                 'index' => '1',
 127                                 'fromtitle' => $title->getPrefixedDBkey(),
 128                                 'byteoffset' => 0,
 129                                 'anchor' => 'foo',
 130                         ],
 131                         [
 132                                 'toclevel' => 1,
 133                                 'level' => '2',
 134                                 'line' => 'bar',
 135                                 'number' => '2',
 136                                 'index' => '',
 137                                 'fromtitle' => false,
 138                                 'byteoffset' => null,
 139                                 'anchor' => 'bar',
 140                         ],
 141                         [
 142                                 'toclevel' => 1,
 143                                 'level' => '2',
 144                                 'line' => 'baz',
 145                                 'number' => '3',
 146                                 'index' => '2',
 147                                 'fromtitle' => $title->getPrefixedDBkey(),
 148                                 'byteoffset' => 21,
 149                                 'anchor' => 'baz',
 150                         ],
 151                 ], $out->getSections(), 'getSections() with proper value when <h2> is used' );
 152         }
 153
 154         /**
 155          * @dataProvider provideNormalizeLinkUrl
 156          */
 157         public function testNormalizeLinkUrl( $explanation, $url, $expected ) {
 158                 $this->assertEquals( $expected, Parser::normalizeLinkUrl( $url ), $explanation );
 159         }
 160
 161         public static function provideNormalizeLinkUrl() {
 162                 return [
 163                         [
 164                                 'Escaping of unsafe characters',
 165                                 'http://example.org/foo bar?param[]="value"&param[]=valüe',
 166                                 'http://example.org/foo%20bar?param%5B%5D=%22value%22&param%5B%5D=val%C3%BCe',
 167                         ],
 168                         [
 169                                 'Case normalization of percent-encoded characters',
 170                                 'http://example.org/%ab%cD%Ef%FF',
 171                                 'http://example.org/%AB%CD%EF%FF',
 172                         ],
 173                         [
 174                                 'Unescaping of safe characters',
 175                                 'http://example.org/%3C%66%6f%6F%3E?%3C%66%6f%6F%3E#%3C%66%6f%6F%3E',
 176                                 'http://example.org/%3Cfoo%3E?%3Cfoo%3E#%3Cfoo%3E',
 177                         ],
 178                         [
 179                                 'Context-sensitive replacement of sometimes-safe characters',
 180                                 'http://example.org/%23%2F%3F%26%3D%2B%3B?%23%2F%3F%26%3D%2B%3B#%23%2F%3F%26%3D%2B%3B',
 181                                 'http://example.org/%23%2F%3F&=+;?%23/?%26%3D%2B%3B#%23/?&=+;',
 182                         ],
 183                         [
 184                                 'IPv6 links aren\'t escaped',
 185                                 'http://[::1]/foobar',
 186                                 'http://[::1]/foobar',
 187                         ],
 188                         [
 189                                 'non-IPv6 links aren\'t unescaped',
 190                                 'http://%5B::1%5D/foobar',
 191                                 'http://%5B::1%5D/foobar',
 192                         ],
 193                 ];
 194         }
 195
 196         public function testWrapOutput() {
 197                 $title = Title::newFromText( 'foo' );
 198                 $po = new ParserOptions();
 199                 $parser = MediaWikiServices::getInstance()->getParser();
 200                 $parser->parse( 'Hello World', $title, $po );
 201                 $text = $parser->getOutput()->getText();
 202
 203                 $this->assertContains( 'Hello World', $text );
 204                 $this->assertContains( '<div', $text );
 205                 $this->assertContains( 'class="mw-parser-output"', $text );
 206         }
 207
 208         /**
 209          * @param string $name
 210          * @return Title
 211          */
 212         private function getMockTitle( $name ) {
 213                 $title = $this->getMock( Title::class );
 214                 $title->method( 'getPrefixedDBkey' )->willReturn( $name );
 215                 $title->method( 'getPrefixedText' )->willReturn( $name );
 216                 $title->method( 'getDBkey' )->willReturn( $name );
 217                 $title->method( 'getText' )->willReturn( $name );
 218                 $title->method( 'getNamespace' )->willReturn( 0 );
 219                 $title->method( 'getPageLanguage' )->willReturn( Language::factory( 'en' ) );
 220
 221                 return $title;
 222         }
 223
 224         public function provideRevisionAccess() {
 225                 $title = $this->getMockTitle( 'ParserRevisionAccessTest' );
 226
 227                 $frank = $this->getMockBuilder( User::class )
 228                         ->disableOriginalConstructor()
 229                         ->getMock();
 230
 231                 $frank->method( 'getName' )->willReturn( 'Frank' );
 232
 233                 $text = '* user:{{REVISIONUSER}};id:{{REVISIONID}};time:{{REVISIONTIMESTAMP}};';
 234                 $po = new ParserOptions( $frank );
 235
 236                 yield 'current' => [ $text, $po, 0, 'user:CurrentAuthor;id:200;time:20160606000000;' ];
 237                 yield 'current' => [ $text, $po, null, 'user:;id:;time:' ];
 238                 yield 'current with ID' => [ $text, $po, 200, 'user:CurrentAuthor;id:200;time:20160606000000;' ];
 239
 240                 $text = '* user:{{REVISIONUSER}};id:{{REVISIONID}};time:{{REVISIONTIMESTAMP}};';
 241                 $po = new ParserOptions( $frank );
 242
 243                 yield 'old' => [ $text, $po, 100, 'user:OldAuthor;id:100;time:20140404000000;' ];
 244
 245                 $oldRevision = new MutableRevisionRecord( $title );
 246                 $oldRevision->setId( 100 );
 247                 $oldRevision->setUser( new UserIdentityValue( 7, 'FauxAuthor', 0 ) );
 248                 $oldRevision->setTimestamp( '20141111111111' );
 249                 $oldRevision->setContent( SlotRecord::MAIN, new WikitextContent( 'FAUX' ) );
 250
 251                 $po = new ParserOptions( $frank );
 252                 $po->setCurrentRevisionCallback( function () use ( $oldRevision ) {
 253                         return new Revision( $oldRevision );
 254                 } );
 255
 256                 yield 'old with override' => [ $text, $po, 100, 'user:FauxAuthor;id:100;time:20141111111111;' ];
 257
 258                 $text = '* user:{{REVISIONUSER}};user-subst:{{subst:REVISIONUSER}};';
 259
 260                 $po = new ParserOptions( $frank );
 261                 $po->setIsPreview( true );
 262
 263                 yield 'preview without override, using context' => [
 264                         $text,
 265                         $po,
 266                         null,
 267                         'user:Frank;',
 268                         'user-subst:Frank;',
 269                 ];
 270
 271                 $text = '* user:{{REVISIONUSER}};time:{{REVISIONTIMESTAMP}};'
 272                         . 'user-subst:{{subst:REVISIONUSER}};time-subst:{{subst:REVISIONTIMESTAMP}};';
 273
 274                 $newRevision = new MutableRevisionRecord( $title );
 275                 $newRevision->setUser( new UserIdentityValue( 9, 'NewAuthor', 0 ) );
 276                 $newRevision->setTimestamp( '20180808000000' );
 277                 $newRevision->setContent( SlotRecord::MAIN, new WikitextContent( 'NEW' ) );
 278
 279                 $po = new ParserOptions( $frank );
 280                 $po->setIsPreview( true );
 281                 $po->setCurrentRevisionCallback( function () use ( $newRevision ) {
 282                         return new Revision( $newRevision );
 283                 } );
 284
 285                 yield 'preview' => [
 286                         $text,
 287                         $po,
 288                         null,
 289                         'user:NewAuthor;time:20180808000000;',
 290                         'user-subst:NewAuthor;time-subst:20180808000000;',
 291                 ];
 292
 293                 $po = new ParserOptions( $frank );
 294                 $po->setCurrentRevisionCallback( function () use ( $newRevision ) {
 295                         return new Revision( $newRevision );
 296                 } );
 297
 298                 yield 'pre-save' => [
 299                         $text,
 300                         $po,
 301                         null,
 302                         'user:NewAuthor;time:20180808000000;',
 303                         'user-subst:NewAuthor;time-subst:20180808000000;',
 304                 ];
 305
 306                 $text = "(ONE)<includeonly>(TWO)</includeonly>"
 307                         . "<noinclude>#{{:ParserRevisionAccessTest}}#</noinclude>";
 308
 309                 $newRevision = new MutableRevisionRecord( $title );
 310                 $newRevision->setUser( new UserIdentityValue( 9, 'NewAuthor', 0 ) );
 311                 $newRevision->setTimestamp( '20180808000000' );
 312                 $newRevision->setContent( SlotRecord::MAIN, new WikitextContent( $text ) );
 313
 314                 $po = new ParserOptions( $frank );
 315                 $po->setIsPreview( true );
 316                 $po->setCurrentRevisionCallback( function () use ( $newRevision ) {
 317                         return new Revision( $newRevision );
 318                 } );
 319
 320                 yield 'preview with self-transclude' => [ $text, $po, null, '(ONE)#(ONE)(TWO)#' ];
 321         }
 322
 323         /**
 324          * @dataProvider provideRevisionAccess
 325          */
 326         public function testRevisionAccess(
 327                 $text,
 328                 ParserOptions $po,
 329                 $revId,
 330                 $expectedInHtml,
 331                 $expectedInPst = null
 332         ) {
 333                 $title = $this->getMockTitle( 'ParserRevisionAccessTest' );
 334
 335                 $po->enableLimitReport( false );
 336
 337                 $oldRevision = new MutableRevisionRecord( $title );
 338                 $oldRevision->setId( 100 );
 339                 $oldRevision->setUser( new UserIdentityValue( 7, 'OldAuthor', 0 ) );
 340                 $oldRevision->setTimestamp( '20140404000000' );
 341                 $oldRevision->setContent( SlotRecord::MAIN, new WikitextContent( 'OLD' ) );
 342
 343                 $currentRevision = new MutableRevisionRecord( $title );
 344                 $currentRevision->setId( 200 );
 345                 $currentRevision->setUser( new UserIdentityValue( 9, 'CurrentAuthor', 0 ) );
 346                 $currentRevision->setTimestamp( '20160606000000' );
 347                 $currentRevision->setContent( SlotRecord::MAIN, new WikitextContent( 'CURRENT' ) );
 348
 349                 $revisionStore = $this->getMockBuilder( RevisionStore::class )
 350                         ->disableOriginalConstructor()
 351                         ->getMock();
 352
 353                 $revisionStore
 354                         ->method( 'getKnownCurrentRevision' )
 355                         ->willReturnMap( [
 356                                 [ $title, 100, $oldRevision ],
 357                                 [ $title, 200, $currentRevision ],
 358                                 [ $title, 0, $currentRevision ],
 359                         ] );
 360
 361                 $revisionStore
 362                         ->method( 'getRevisionById' )
 363                         ->willReturnMap( [
 364                                 [ 100, 0, $oldRevision ],
 365                                 [ 200, 0, $currentRevision ],
 366                         ] );
 367
 368                 $this->setService( 'RevisionStore', $revisionStore );
 369
 370                 $parser = MediaWikiServices::getInstance()->getParser();
 371                 $parser->parse( $text, $title, $po, true, true, $revId );
 372                 $html = $parser->getOutput()->getText();
 373
 374                 $this->assertContains( $expectedInHtml, $html, 'In HTML' );
 375
 376                 if ( $expectedInPst !== null ) {
 377                         $pst = $parser->preSaveTransform( $text, $title, $po->getUser(), $po );
 378                         $this->assertContains( $expectedInPst, $pst, 'After Pre-Safe Transform' );
 379                 }
 380         }
 381
 382         public static function provideGuessSectionNameFromWikiText() {
 383                 return [
 384                         [ '1/2', 'html5', '#1/2' ],
 385                         [ '1/2', 'legacy', '#1.2F2' ],
 386                 ];
 387         }
 388
 389         /** @dataProvider provideGuessSectionNameFromWikiText */
 390         public function testGuessSectionNameFromWikiText( $input, $mode, $expected ) {
 391                 $this->setMwGlobals( [ 'wgFragmentMode' => [ $mode ] ] );
 392                 $result = MediaWikiServices::getInstance()->getParser()
 393                         ->guessSectionNameFromWikiText( $input );
 394                 $this->assertEquals( $result, $expected );
 395         }
 396
 397         // @todo Add tests for cleanSig() / cleanSigInSig(), getSection(),
 398         // replaceSection(), getPreloadText()
 399 }