tests/phpunit/includes/WikiPageTest.php

   1 <?php
   2
   3 /**
   4  * @group ContentHandler
   5  * @group Database
   6  * ^--- important, causes temporary tables to be used instead of the real database
   7  * @group medium
   8  **/
   9 class WikiPageTest extends MediaWikiLangTestCase {
  10
  11         protected $pages_to_delete;
  12
  13         function __construct( $name = null, array $data = array(), $dataName = '' ) {
  14                 parent::__construct( $name, $data, $dataName );
  15
  16                 $this->tablesUsed = array_merge(
  17                         $this->tablesUsed,
  18                         array( 'page',
  19                                 'revision',
  20                                 'text',
  21
  22                                 'recentchanges',
  23                                 'logging',
  24
  25                                 'page_props',
  26                                 'pagelinks',
  27                                 'categorylinks',
  28                                 'langlinks',
  29                                 'externallinks',
  30                                 'imagelinks',
  31                                 'templatelinks',
  32                                 'iwlinks' ) );
  33         }
  34
  35         protected function setUp() {
  36                 parent::setUp();
  37                 $this->pages_to_delete = array();
  38
  39                 LinkCache::singleton()->clear(); # avoid cached redirect status, etc
  40         }
  41
  42         protected function tearDown() {
  43                 foreach ( $this->pages_to_delete as $p ) {
  44                         /* @var $p WikiPage */
  45
  46                         try {
  47                                 if ( $p->exists() ) {
  48                                         $p->doDeleteArticle( "testing done." );
  49                                 }
  50                         } catch ( MWException $ex ) {
  51                                 // fail silently
  52                         }
  53                 }
  54                 parent::tearDown();
  55         }
  56
  57         /**
  58          * @param Title $title
  59          * @param String $model
  60          * @return WikiPage
  61          */
  62         protected function newPage( $title, $model = null ) {
  63                 if ( is_string( $title ) ) {
  64                         $ns = $this->getDefaultWikitextNS();
  65                         $title = Title::newFromText( $title, $ns );
  66                 }
  67
  68                 $p = new WikiPage( $title );
  69
  70                 $this->pages_to_delete[] = $p;
  71
  72                 return $p;
  73         }
  74
  75         /**
  76          * @param String|Title|WikiPage $page
  77          * @param String $text
  78          * @param int $model
  79          *
  80          * @return WikiPage
  81          */
  82         protected function createPage( $page, $text, $model = null ) {
  83                 if ( is_string( $page ) || $page instanceof Title ) {
  84                         $page = $this->newPage( $page, $model );
  85                 }
  86
  87                 $content = ContentHandler::makeContent( $text, $page->getTitle(), $model );
  88                 $page->doEditContent( $content, "testing", EDIT_NEW );
  89
  90                 return $page;
  91         }
  92
  93         /**
  94          * @covers WikiPage::doEditContent
  95          */
  96         public function testDoEditContent() {
  97                 $page = $this->newPage( "WikiPageTest_testDoEditContent" );
  98                 $title = $page->getTitle();
  99
 100                 $content = ContentHandler::makeContent( "[[Lorem ipsum]] dolor sit amet, consetetur sadipscing elitr, sed diam "
 101                                 . " nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat.",
 102                         $title, CONTENT_MODEL_WIKITEXT );
 103
 104                 $page->doEditContent( $content, "[[testing]] 1" );
 105
 106                 $this->assertTrue( $title->getArticleID() > 0, "Title object should have new page id" );
 107                 $this->assertTrue( $page->getId() > 0, "WikiPage should have new page id" );
 108                 $this->assertTrue( $title->exists(), "Title object should indicate that the page now exists" );
 109                 $this->assertTrue( $page->exists(), "WikiPage object should indicate that the page now exists" );
 110
 111                 $id = $page->getId();
 112
 113                 # ------------------------
 114                 $dbr = wfGetDB( DB_SLAVE );
 115                 $res = $dbr->select( 'pagelinks', '*', array( 'pl_from' => $id ) );
 116                 $n = $res->numRows();
 117                 $res->free();
 118
 119                 $this->assertEquals( 1, $n, 'pagelinks should contain one link from the page' );
 120
 121                 # ------------------------
 122                 $page = new WikiPage( $title );
 123
 124                 $retrieved = $page->getContent();
 125                 $this->assertTrue( $content->equals( $retrieved ), 'retrieved content doesn\'t equal original' );
 126
 127                 # ------------------------
 128                 $content = ContentHandler::makeContent( "At vero eos et accusam et justo duo [[dolores]] et ea rebum. "
 129                                 . "Stet clita kasd [[gubergren]], no sea takimata sanctus est.",
 130                         $title, CONTENT_MODEL_WIKITEXT );
 131
 132                 $page->doEditContent( $content, "testing 2" );
 133
 134                 # ------------------------
 135                 $page = new WikiPage( $title );
 136
 137                 $retrieved = $page->getContent();
 138                 $this->assertTrue( $content->equals( $retrieved ), 'retrieved content doesn\'t equal original' );
 139
 140                 # ------------------------
 141                 $dbr = wfGetDB( DB_SLAVE );
 142                 $res = $dbr->select( 'pagelinks', '*', array( 'pl_from' => $id ) );
 143                 $n = $res->numRows();
 144                 $res->free();
 145
 146                 $this->assertEquals( 2, $n, 'pagelinks should contain two links from the page' );
 147         }
 148
 149         /**
 150          * @covers WikiPage::doEdit
 151          */
 152         public function testDoEdit() {
 153                 $this->hideDeprecated( "WikiPage::doEdit" );
 154                 $this->hideDeprecated( "WikiPage::getText" );
 155                 $this->hideDeprecated( "Revision::getText" );
 156
 157                 //NOTE: assume help namespace will default to wikitext
 158                 $title = Title::newFromText( "Help:WikiPageTest_testDoEdit" );
 159
 160                 $page = $this->newPage( $title );
 161
 162                 $text = "[[Lorem ipsum]] dolor sit amet, consetetur sadipscing elitr, sed diam "
 163                         . " nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat.";
 164
 165                 $page->doEdit( $text, "[[testing]] 1" );
 166
 167                 $this->assertTrue( $title->getArticleID() > 0, "Title object should have new page id" );
 168                 $this->assertTrue( $page->getId() > 0, "WikiPage should have new page id" );
 169                 $this->assertTrue( $title->exists(), "Title object should indicate that the page now exists" );
 170                 $this->assertTrue( $page->exists(), "WikiPage object should indicate that the page now exists" );
 171
 172                 $id = $page->getId();
 173
 174                 # ------------------------
 175                 $dbr = wfGetDB( DB_SLAVE );
 176                 $res = $dbr->select( 'pagelinks', '*', array( 'pl_from' => $id ) );
 177                 $n = $res->numRows();
 178                 $res->free();
 179
 180                 $this->assertEquals( 1, $n, 'pagelinks should contain one link from the page' );
 181
 182                 # ------------------------
 183                 $page = new WikiPage( $title );
 184
 185                 $retrieved = $page->getText();
 186                 $this->assertEquals( $text, $retrieved, 'retrieved text doesn\'t equal original' );
 187
 188                 # ------------------------
 189                 $text = "At vero eos et accusam et justo duo [[dolores]] et ea rebum. "
 190                         . "Stet clita kasd [[gubergren]], no sea takimata sanctus est.";
 191
 192                 $page->doEdit( $text, "testing 2" );
 193
 194                 # ------------------------
 195                 $page = new WikiPage( $title );
 196
 197                 $retrieved = $page->getText();
 198                 $this->assertEquals( $text, $retrieved, 'retrieved text doesn\'t equal original' );
 199
 200                 # ------------------------
 201                 $dbr = wfGetDB( DB_SLAVE );
 202                 $res = $dbr->select( 'pagelinks', '*', array( 'pl_from' => $id ) );
 203                 $n = $res->numRows();
 204                 $res->free();
 205
 206                 $this->assertEquals( 2, $n, 'pagelinks should contain two links from the page' );
 207         }
 208
 209         /**
 210          * @covers WikiPage::doQuickEdit
 211          */
 212         public function testDoQuickEdit() {
 213                 global $wgUser;
 214
 215                 $this->hideDeprecated( "WikiPage::doQuickEdit" );
 216
 217                 //NOTE: assume help namespace will default to wikitext
 218                 $page = $this->createPage( "Help:WikiPageTest_testDoQuickEdit", "original text" );
 219
 220                 $text = "quick text";
 221                 $page->doQuickEdit( $text, $wgUser, "testing q" );
 222
 223                 # ---------------------
 224                 $page = new WikiPage( $page->getTitle() );
 225                 $this->assertEquals( $text, $page->getText() );
 226         }
 227
 228         /**
 229          * @covers WikiPage::doQuickEditContent
 230          */
 231         public function testDoQuickEditContent() {
 232                 global $wgUser;
 233
 234                 $page = $this->createPage( "WikiPageTest_testDoQuickEditContent", "original text", CONTENT_MODEL_WIKITEXT );
 235
 236                 $content = ContentHandler::makeContent( "quick text", $page->getTitle(), CONTENT_MODEL_WIKITEXT );
 237                 $page->doQuickEditContent( $content, $wgUser, "testing q" );
 238
 239                 # ---------------------
 240                 $page = new WikiPage( $page->getTitle() );
 241                 $this->assertTrue( $content->equals( $page->getContent() ) );
 242         }
 243
 244         /**
 245          * @covers WikiPage::doDeleteArticle
 246          */
 247         public function testDoDeleteArticle() {
 248                 $page = $this->createPage( "WikiPageTest_testDoDeleteArticle", "[[original text]] foo", CONTENT_MODEL_WIKITEXT );
 249                 $id = $page->getId();
 250
 251                 $page->doDeleteArticle( "testing deletion" );
 252
 253                 $this->assertFalse( $page->getTitle()->getArticleID() > 0, "Title object should now have page id 0" );
 254                 $this->assertFalse( $page->getId() > 0, "WikiPage should now have page id 0" );
 255                 $this->assertFalse( $page->exists(), "WikiPage::exists should return false after page was deleted" );
 256                 $this->assertNull( $page->getContent(), "WikiPage::getContent should return null after page was deleted" );
 257                 $this->assertFalse( $page->getText(), "WikiPage::getText should return false after page was deleted" );
 258
 259                 $t = Title::newFromText( $page->getTitle()->getPrefixedText() );
 260                 $this->assertFalse( $t->exists(), "Title::exists should return false after page was deleted" );
 261
 262                 # ------------------------
 263                 $dbr = wfGetDB( DB_SLAVE );
 264                 $res = $dbr->select( 'pagelinks', '*', array( 'pl_from' => $id ) );
 265                 $n = $res->numRows();
 266                 $res->free();
 267
 268                 $this->assertEquals( 0, $n, 'pagelinks should contain no more links from the page' );
 269         }
 270
 271         /**
 272          * @covers WikiPage::doDeleteUpdates
 273          */
 274         public function testDoDeleteUpdates() {
 275                 $page = $this->createPage( "WikiPageTest_testDoDeleteArticle", "[[original text]] foo", CONTENT_MODEL_WIKITEXT );
 276                 $id = $page->getId();
 277
 278                 $page->doDeleteUpdates( $id );
 279
 280                 # ------------------------
 281                 $dbr = wfGetDB( DB_SLAVE );
 282                 $res = $dbr->select( 'pagelinks', '*', array( 'pl_from' => $id ) );
 283                 $n = $res->numRows();
 284                 $res->free();
 285
 286                 $this->assertEquals( 0, $n, 'pagelinks should contain no more links from the page' );
 287         }
 288
 289         /**
 290          * @covers WikiPage::getRevision
 291          */
 292         public function testGetRevision() {
 293                 $page = $this->newPage( "WikiPageTest_testGetRevision" );
 294
 295                 $rev = $page->getRevision();
 296                 $this->assertNull( $rev );
 297
 298                 # -----------------
 299                 $this->createPage( $page, "some text", CONTENT_MODEL_WIKITEXT );
 300
 301                 $rev = $page->getRevision();
 302
 303                 $this->assertEquals( $page->getLatest(), $rev->getId() );
 304                 $this->assertEquals( "some text", $rev->getContent()->getNativeData() );
 305         }
 306
 307         /**
 308          * @covers WikiPage::getContent
 309          */
 310         public function testGetContent() {
 311                 $page = $this->newPage( "WikiPageTest_testGetContent" );
 312
 313                 $content = $page->getContent();
 314                 $this->assertNull( $content );
 315
 316                 # -----------------
 317                 $this->createPage( $page, "some text", CONTENT_MODEL_WIKITEXT );
 318
 319                 $content = $page->getContent();
 320                 $this->assertEquals( "some text", $content->getNativeData() );
 321         }
 322
 323         /**
 324          * @covers WikiPage::getText
 325          */
 326         public function testGetText() {
 327                 $this->hideDeprecated( "WikiPage::getText" );
 328
 329                 $page = $this->newPage( "WikiPageTest_testGetText" );
 330
 331                 $text = $page->getText();
 332                 $this->assertFalse( $text );
 333
 334                 # -----------------
 335                 $this->createPage( $page, "some text", CONTENT_MODEL_WIKITEXT );
 336
 337                 $text = $page->getText();
 338                 $this->assertEquals( "some text", $text );
 339         }
 340
 341         /**
 342          * @covers WikiPage::getRawText
 343          */
 344         public function testGetRawText() {
 345                 $this->hideDeprecated( "WikiPage::getRawText" );
 346
 347                 $page = $this->newPage( "WikiPageTest_testGetRawText" );
 348
 349                 $text = $page->getRawText();
 350                 $this->assertFalse( $text );
 351
 352                 # -----------------
 353                 $this->createPage( $page, "some text", CONTENT_MODEL_WIKITEXT );
 354
 355                 $text = $page->getRawText();
 356                 $this->assertEquals( "some text", $text );
 357         }
 358
 359         /**
 360          * @covers WikiPage::getContentModel
 361          */
 362         public function testGetContentModel() {
 363                 global $wgContentHandlerUseDB;
 364
 365                 if ( !$wgContentHandlerUseDB ) {
 366                         $this->markTestSkipped( '$wgContentHandlerUseDB is disabled' );
 367                 }
 368
 369                 $page = $this->createPage( "WikiPageTest_testGetContentModel", "some text", CONTENT_MODEL_JAVASCRIPT );
 370
 371                 $page = new WikiPage( $page->getTitle() );
 372                 $this->assertEquals( CONTENT_MODEL_JAVASCRIPT, $page->getContentModel() );
 373         }
 374
 375         /**
 376          * @covers WikiPage::getContentHandler
 377          */
 378         public function testGetContentHandler() {
 379                 global $wgContentHandlerUseDB;
 380
 381                 if ( !$wgContentHandlerUseDB ) {
 382                         $this->markTestSkipped( '$wgContentHandlerUseDB is disabled' );
 383                 }
 384
 385                 $page = $this->createPage( "WikiPageTest_testGetContentHandler", "some text", CONTENT_MODEL_JAVASCRIPT );
 386
 387                 $page = new WikiPage( $page->getTitle() );
 388                 $this->assertEquals( 'JavaScriptContentHandler', get_class( $page->getContentHandler() ) );
 389         }
 390
 391         /**
 392          * @covers WikiPage::exists
 393          */
 394         public function testExists() {
 395                 $page = $this->newPage( "WikiPageTest_testExists" );
 396                 $this->assertFalse( $page->exists() );
 397
 398                 # -----------------
 399                 $this->createPage( $page, "some text", CONTENT_MODEL_WIKITEXT );
 400                 $this->assertTrue( $page->exists() );
 401
 402                 $page = new WikiPage( $page->getTitle() );
 403                 $this->assertTrue( $page->exists() );
 404
 405                 # -----------------
 406                 $page->doDeleteArticle( "done testing" );
 407                 $this->assertFalse( $page->exists() );
 408
 409                 $page = new WikiPage( $page->getTitle() );
 410                 $this->assertFalse( $page->exists() );
 411         }
 412
 413         public static function provideHasViewableContent() {
 414                 return array(
 415                         array( 'WikiPageTest_testHasViewableContent', false, true ),
 416                         array( 'Special:WikiPageTest_testHasViewableContent', false ),
 417                         array( 'MediaWiki:WikiPageTest_testHasViewableContent', false ),
 418                         array( 'Special:Userlogin', true ),
 419                         array( 'MediaWiki:help', true ),
 420                 );
 421         }
 422
 423         /**
 424          * @dataProvider provideHasViewableContent
 425          * @covers WikiPage::hasViewableContent
 426          */
 427         public function testHasViewableContent( $title, $viewable, $create = false ) {
 428                 $page = $this->newPage( $title );
 429                 $this->assertEquals( $viewable, $page->hasViewableContent() );
 430
 431                 if ( $create ) {
 432                         $this->createPage( $page, "some text", CONTENT_MODEL_WIKITEXT );
 433                         $this->assertTrue( $page->hasViewableContent() );
 434
 435                         $page = new WikiPage( $page->getTitle() );
 436                         $this->assertTrue( $page->hasViewableContent() );
 437                 }
 438         }
 439
 440         public static function provideGetRedirectTarget() {
 441                 return array(
 442                         array( 'WikiPageTest_testGetRedirectTarget_1', CONTENT_MODEL_WIKITEXT, "hello world", null ),
 443                         array( 'WikiPageTest_testGetRedirectTarget_2', CONTENT_MODEL_WIKITEXT, "#REDIRECT [[hello world]]", "Hello world" ),
 444                 );
 445         }
 446
 447         /**
 448          * @dataProvider provideGetRedirectTarget
 449          * @covers WikiPage::getRedirectTarget
 450          */
 451         public function testGetRedirectTarget( $title, $model, $text, $target ) {
 452                 $page = $this->createPage( $title, $text, $model );
 453
 454                 # sanity check, because this test seems to fail for no reason for some people.
 455                 $c = $page->getContent();
 456                 $this->assertEquals( 'WikitextContent', get_class( $c ) );
 457
 458                 # now, test the actual redirect
 459                 $t = $page->getRedirectTarget();
 460                 $this->assertEquals( $target, is_null( $t ) ? null : $t->getPrefixedText() );
 461         }
 462
 463         /**
 464          * @dataProvider provideGetRedirectTarget
 465          * @covers WikiPage::isRedirect
 466          */
 467         public function testIsRedirect( $title, $model, $text, $target ) {
 468                 $page = $this->createPage( $title, $text, $model );
 469                 $this->assertEquals( !is_null( $target ), $page->isRedirect() );
 470         }
 471
 472         public static function provideIsCountable() {
 473                 return array(
 474
 475                         // any
 476                         array( 'WikiPageTest_testIsCountable',
 477                                 CONTENT_MODEL_WIKITEXT,
 478                                 '',
 479                                 'any',
 480                                 true
 481                         ),
 482                         array( 'WikiPageTest_testIsCountable',
 483                                 CONTENT_MODEL_WIKITEXT,
 484                                 'Foo',
 485                                 'any',
 486                                 true
 487                         ),
 488
 489                         // comma
 490                         array( 'WikiPageTest_testIsCountable',
 491                                 CONTENT_MODEL_WIKITEXT,
 492                                 'Foo',
 493                                 'comma',
 494                                 false
 495                         ),
 496                         array( 'WikiPageTest_testIsCountable',
 497                                 CONTENT_MODEL_WIKITEXT,
 498                                 'Foo, bar',
 499                                 'comma',
 500                                 true
 501                         ),
 502
 503                         // link
 504                         array( 'WikiPageTest_testIsCountable',
 505                                 CONTENT_MODEL_WIKITEXT,
 506                                 'Foo',
 507                                 'link',
 508                                 false
 509                         ),
 510                         array( 'WikiPageTest_testIsCountable',
 511                                 CONTENT_MODEL_WIKITEXT,
 512                                 'Foo [[bar]]',
 513                                 'link',
 514                                 true
 515                         ),
 516
 517                         // redirects
 518                         array( 'WikiPageTest_testIsCountable',
 519                                 CONTENT_MODEL_WIKITEXT,
 520                                 '#REDIRECT [[bar]]',
 521                                 'any',
 522                                 false
 523                         ),
 524                         array( 'WikiPageTest_testIsCountable',
 525                                 CONTENT_MODEL_WIKITEXT,
 526                                 '#REDIRECT [[bar]]',
 527                                 'comma',
 528                                 false
 529                         ),
 530                         array( 'WikiPageTest_testIsCountable',
 531                                 CONTENT_MODEL_WIKITEXT,
 532                                 '#REDIRECT [[bar]]',
 533                                 'link',
 534                                 false
 535                         ),
 536
 537                         // not a content namespace
 538                         array( 'Talk:WikiPageTest_testIsCountable',
 539                                 CONTENT_MODEL_WIKITEXT,
 540                                 'Foo',
 541                                 'any',
 542                                 false
 543                         ),
 544                         array( 'Talk:WikiPageTest_testIsCountable',
 545                                 CONTENT_MODEL_WIKITEXT,
 546                                 'Foo, bar',
 547                                 'comma',
 548                                 false
 549                         ),
 550                         array( 'Talk:WikiPageTest_testIsCountable',
 551                                 CONTENT_MODEL_WIKITEXT,
 552                                 'Foo [[bar]]',
 553                                 'link',
 554                                 false
 555                         ),
 556
 557                         // not a content namespace, different model
 558                         array( 'MediaWiki:WikiPageTest_testIsCountable.js',
 559                                 null,
 560                                 'Foo',
 561                                 'any',
 562                                 false
 563                         ),
 564                         array( 'MediaWiki:WikiPageTest_testIsCountable.js',
 565                                 null,
 566                                 'Foo, bar',
 567                                 'comma',
 568                                 false
 569                         ),
 570                         array( 'MediaWiki:WikiPageTest_testIsCountable.js',
 571                                 null,
 572                                 'Foo [[bar]]',
 573                                 'link',
 574                                 false
 575                         ),
 576                 );
 577         }
 578
 579
 580         /**
 581          * @dataProvider provideIsCountable
 582          * @covers WikiPage::isCountable
 583          */
 584         public function testIsCountable( $title, $model, $text, $mode, $expected ) {
 585                 global $wgContentHandlerUseDB;
 586
 587                 $this->setMwGlobals( 'wgArticleCountMethod', $mode );
 588
 589                 $title = Title::newFromText( $title );
 590
 591                 if ( !$wgContentHandlerUseDB && $model && ContentHandler::getDefaultModelFor( $title ) != $model ) {
 592                         $this->markTestSkipped( "Can not use non-default content model $model for "
 593                                 . $title->getPrefixedDBkey() . " with \$wgContentHandlerUseDB disabled." );
 594                 }
 595
 596                 $page = $this->createPage( $title, $text, $model );
 597                 $hasLinks = wfGetDB( DB_SLAVE )->selectField( 'pagelinks', 1,
 598                         array( 'pl_from' => $page->getId() ), __METHOD__ );
 599
 600                 $editInfo = $page->prepareContentForEdit( $page->getContent() );
 601
 602                 $v = $page->isCountable();
 603                 $w = $page->isCountable( $editInfo );
 604
 605                 $this->assertEquals( $expected, $v, "isCountable( null ) returned unexpected value " . var_export( $v, true )
 606                         . " instead of " . var_export( $expected, true ) . " in mode `$mode` for text \"$text\"" );
 607
 608                 $this->assertEquals( $expected, $w, "isCountable( \$editInfo ) returned unexpected value " . var_export( $v, true )
 609                         . " instead of " . var_export( $expected, true ) . " in mode `$mode` for text \"$text\"" );
 610         }
 611
 612         public static function provideGetParserOutput() {
 613                 return array(
 614                         array( CONTENT_MODEL_WIKITEXT, "hello ''world''\n", "<p>hello <i>world</i></p>" ),
 615                         // @todo more...?
 616                 );
 617         }
 618
 619         /**
 620          * @dataProvider provideGetParserOutput
 621          * @covers WikiPage::getParserOutput
 622          */
 623         public function testGetParserOutput( $model, $text, $expectedHtml ) {
 624                 $page = $this->createPage( 'WikiPageTest_testGetParserOutput', $text, $model );
 625
 626                 $opt = $page->makeParserOptions( 'canonical' );
 627                 $po = $page->getParserOutput( $opt );
 628                 $text = $po->getText();
 629
 630                 $text = trim( preg_replace( '/<!--.*?-->/sm', '', $text ) ); # strip injected comments
 631                 $text = preg_replace( '!\s*(</p>)!sm', '\1', $text ); # don't let tidy confuse us
 632
 633                 $this->assertEquals( $expectedHtml, $text );
 634
 635                 return $po;
 636         }
 637
 638         /**
 639          * @covers WikiPage::getParserOutput
 640          */
 641         public function testGetParserOutput_nonexisting() {
 642                 static $count = 0;
 643                 $count++;
 644
 645                 $page = new WikiPage( new Title( "WikiPageTest_testGetParserOutput_nonexisting_$count" ) );
 646
 647                 $opt = new ParserOptions();
 648                 $po = $page->getParserOutput( $opt );
 649
 650                 $this->assertFalse( $po, "getParserOutput() shall return false for non-existing pages." );
 651         }
 652
 653         /**
 654          * @covers WikiPage::getParserOutput
 655          */
 656         public function testGetParserOutput_badrev() {
 657                 $page = $this->createPage( 'WikiPageTest_testGetParserOutput', "dummy", CONTENT_MODEL_WIKITEXT );
 658
 659                 $opt = new ParserOptions();
 660                 $po = $page->getParserOutput( $opt, $page->getLatest() + 1234 );
 661
 662                 // @todo would be neat to also test deleted revision
 663
 664                 $this->assertFalse( $po, "getParserOutput() shall return false for non-existing revisions." );
 665         }
 666
 667         static $sections =
 668
 669                 "Intro
 670
 671 == stuff ==
 672 hello world
 673
 674 == test ==
 675 just a test
 676
 677 == foo ==
 678 more stuff
 679 ";
 680
 681
 682         public function dataReplaceSection() {
 683                 //NOTE: assume the Help namespace to contain wikitext
 684                 return array(
 685                         array( 'Help:WikiPageTest_testReplaceSection',
 686                                 CONTENT_MODEL_WIKITEXT,
 687                                 WikiPageTest::$sections,
 688                                 "0",
 689                                 "No more",
 690                                 null,
 691                                 trim( preg_replace( '/^Intro/sm', 'No more', WikiPageTest::$sections ) )
 692                         ),
 693                         array( 'Help:WikiPageTest_testReplaceSection',
 694                                 CONTENT_MODEL_WIKITEXT,
 695                                 WikiPageTest::$sections,
 696                                 "",
 697                                 "No more",
 698                                 null,
 699                                 "No more"
 700                         ),
 701                         array( 'Help:WikiPageTest_testReplaceSection',
 702                                 CONTENT_MODEL_WIKITEXT,
 703                                 WikiPageTest::$sections,
 704                                 "2",
 705                                 "== TEST ==\nmore fun",
 706                                 null,
 707                                 trim( preg_replace( '/^== test ==.*== foo ==/sm',
 708                                         "== TEST ==\nmore fun\n\n== foo ==",
 709                                         WikiPageTest::$sections ) )
 710                         ),
 711                         array( 'Help:WikiPageTest_testReplaceSection',
 712                                 CONTENT_MODEL_WIKITEXT,
 713                                 WikiPageTest::$sections,
 714                                 "8",
 715                                 "No more",
 716                                 null,
 717                                 trim( WikiPageTest::$sections )
 718                         ),
 719                         array( 'Help:WikiPageTest_testReplaceSection',
 720                                 CONTENT_MODEL_WIKITEXT,
 721                                 WikiPageTest::$sections,
 722                                 "new",
 723                                 "No more",
 724                                 "New",
 725                                 trim( WikiPageTest::$sections ) . "\n\n== New ==\n\nNo more"
 726                         ),
 727                 );
 728         }
 729
 730         /**
 731          * @dataProvider dataReplaceSection
 732          * @covers WikiPage::replaceSection
 733          */
 734         public function testReplaceSection( $title, $model, $text, $section, $with, $sectionTitle, $expected ) {
 735                 $this->hideDeprecated( "WikiPage::replaceSection" );
 736
 737                 $page = $this->createPage( $title, $text, $model );
 738                 $text = $page->replaceSection( $section, $with, $sectionTitle );
 739                 $text = trim( $text );
 740
 741                 $this->assertEquals( $expected, $text );
 742         }
 743
 744         /**
 745          * @dataProvider dataReplaceSection
 746          * @covers WikiPage::replaceSectionContent
 747          */
 748         public function testReplaceSectionContent( $title, $model, $text, $section, $with, $sectionTitle, $expected ) {
 749                 $page = $this->createPage( $title, $text, $model );
 750
 751                 $content = ContentHandler::makeContent( $with, $page->getTitle(), $page->getContentModel() );
 752                 $c = $page->replaceSectionContent( $section, $content, $sectionTitle );
 753
 754                 $this->assertEquals( $expected, is_null( $c ) ? null : trim( $c->getNativeData() ) );
 755         }
 756
 757         /* @todo FIXME: fix this!
 758         public function testGetUndoText() {
 759         $this->checkHasDiff3();
 760
 761         $text = "one";
 762         $page = $this->createPage( "WikiPageTest_testGetUndoText", $text );
 763         $rev1 = $page->getRevision();
 764
 765         $text .= "\n\ntwo";
 766         $page->doEditContent( ContentHandler::makeContent( $text, $page->getTitle() ), "adding section two");
 767         $rev2 = $page->getRevision();
 768
 769         $text .= "\n\nthree";
 770         $page->doEditContent( ContentHandler::makeContent( $text, $page->getTitle() ), "adding section three");
 771         $rev3 = $page->getRevision();
 772
 773         $text .= "\n\nfour";
 774         $page->doEditContent( ContentHandler::makeContent( $text, $page->getTitle() ), "adding section four");
 775         $rev4 = $page->getRevision();
 776
 777         $text .= "\n\nfive";
 778         $page->doEditContent( ContentHandler::makeContent( $text, $page->getTitle() ), "adding section five");
 779         $rev5 = $page->getRevision();
 780
 781         $text .= "\n\nsix";
 782         $page->doEditContent( ContentHandler::makeContent( $text, $page->getTitle() ), "adding section six");
 783         $rev6 = $page->getRevision();
 784
 785         $undo6 = $page->getUndoText( $rev6 );
 786         if ( $undo6 === false ) $this->fail( "getUndoText failed for rev6" );
 787         $this->assertEquals( "one\n\ntwo\n\nthree\n\nfour\n\nfive", $undo6 );
 788
 789         $undo3 = $page->getUndoText( $rev4, $rev2 );
 790         if ( $undo3 === false ) $this->fail( "getUndoText failed for rev4..rev2" );
 791         $this->assertEquals( "one\n\ntwo\n\nfive", $undo3 );
 792
 793         $undo2 = $page->getUndoText( $rev2 );
 794         if ( $undo2 === false ) $this->fail( "getUndoText failed for rev2" );
 795         $this->assertEquals( "one\n\nfive", $undo2 );
 796         }
 797          */
 798
 799         /**
 800          * @todo FIXME: this is a better rollback test than the one below, but it keeps failing in jenkins for some reason.
 801          */
 802         public function broken_testDoRollback() {
 803                 $admin = new User();
 804                 $admin->setName( "Admin" );
 805
 806                 $text = "one";
 807                 $page = $this->newPage( "WikiPageTest_testDoRollback" );
 808                 $page->doEditContent( ContentHandler::makeContent( $text, $page->getTitle() ),
 809                         "section one", EDIT_NEW, false, $admin );
 810
 811                 $user1 = new User();
 812                 $user1->setName( "127.0.1.11" );
 813                 $text .= "\n\ntwo";
 814                 $page = new WikiPage( $page->getTitle() );
 815                 $page->doEditContent( ContentHandler::makeContent( $text, $page->getTitle() ),
 816                         "adding section two", 0, false, $user1 );
 817
 818                 $user2 = new User();
 819                 $user2->setName( "127.0.2.13" );
 820                 $text .= "\n\nthree";
 821                 $page = new WikiPage( $page->getTitle() );
 822                 $page->doEditContent( ContentHandler::makeContent( $text, $page->getTitle() ),
 823                         "adding section three", 0, false, $user2 );
 824
 825                 # we are having issues with doRollback spuriously failing. apparently the last revision somehow goes missing
 826                 # or not committed under some circumstances. so, make sure the last revision has the right user name.
 827                 $dbr = wfGetDB( DB_SLAVE );
 828                 $this->assertEquals( 3, Revision::countByPageId( $dbr, $page->getId() ) );
 829
 830                 $page = new WikiPage( $page->getTitle() );
 831                 $rev3 = $page->getRevision();
 832                 $this->assertEquals( '127.0.2.13', $rev3->getUserText() );
 833
 834                 $rev2 = $rev3->getPrevious();
 835                 $this->assertEquals( '127.0.1.11', $rev2->getUserText() );
 836
 837                 $rev1 = $rev2->getPrevious();
 838                 $this->assertEquals( 'Admin', $rev1->getUserText() );
 839
 840                 # now, try the actual rollback
 841                 $admin->addGroup( "sysop" ); #XXX: make the test user a sysop...
 842                 $token = $admin->getEditToken( array( $page->getTitle()->getPrefixedText(), $user2->getName() ), null );
 843                 $errors = $page->doRollback( $user2->getName(), "testing revert", $token, false, $details, $admin );
 844
 845                 if ( $errors ) {
 846                         $this->fail( "Rollback failed:\n" . print_r( $errors, true ) . ";\n" . print_r( $details, true ) );
 847                 }
 848
 849                 $page = new WikiPage( $page->getTitle() );
 850                 $this->assertEquals( $rev2->getSha1(), $page->getRevision()->getSha1(),
 851                         "rollback did not revert to the correct revision" );
 852                 $this->assertEquals( "one\n\ntwo", $page->getContent()->getNativeData() );
 853         }
 854
 855         /**
 856          * @todo FIXME: the above rollback test is better, but it keeps failing in jenkins for some reason.
 857          * @covers WikiPage::doRollback
 858          */
 859         public function testDoRollback() {
 860                 $admin = new User();
 861                 $admin->setName( "Admin" );
 862
 863                 $text = "one";
 864                 $page = $this->newPage( "WikiPageTest_testDoRollback" );
 865                 $page->doEditContent( ContentHandler::makeContent( $text, $page->getTitle(), CONTENT_MODEL_WIKITEXT ),
 866                         "section one", EDIT_NEW, false, $admin );
 867                 $rev1 = $page->getRevision();
 868
 869                 $user1 = new User();
 870                 $user1->setName( "127.0.1.11" );
 871                 $text .= "\n\ntwo";
 872                 $page = new WikiPage( $page->getTitle() );
 873                 $page->doEditContent( ContentHandler::makeContent( $text, $page->getTitle(), CONTENT_MODEL_WIKITEXT ),
 874                         "adding section two", 0, false, $user1 );
 875
 876                 # now, try the rollback
 877                 $admin->addGroup( "sysop" ); #XXX: make the test user a sysop...
 878                 $token = $admin->getEditToken( array( $page->getTitle()->getPrefixedText(), $user1->getName() ), null );
 879                 $errors = $page->doRollback( $user1->getName(), "testing revert", $token, false, $details, $admin );
 880
 881                 if ( $errors ) {
 882                         $this->fail( "Rollback failed:\n" . print_r( $errors, true ) . ";\n" . print_r( $details, true ) );
 883                 }
 884
 885                 $page = new WikiPage( $page->getTitle() );
 886                 $this->assertEquals( $rev1->getSha1(), $page->getRevision()->getSha1(),
 887                         "rollback did not revert to the correct revision" );
 888                 $this->assertEquals( "one", $page->getContent()->getNativeData() );
 889         }
 890
 891         public static function provideGetAutosummary() {
 892                 return array(
 893                         array(
 894                                 'Hello there, world!',
 895                                 '#REDIRECT [[Foo]]',
 896                                 0,
 897                                 '/^Redirected page .*Foo/'
 898                         ),
 899
 900                         array(
 901                                 null,
 902                                 'Hello world!',
 903                                 EDIT_NEW,
 904                                 '/^Created page .*Hello/'
 905                         ),
 906
 907                         array(
 908                                 'Hello there, world!',
 909                                 '',
 910                                 0,
 911                                 '/^Blanked/'
 912                         ),
 913
 914                         array(
 915                                 'Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut
 916                                 labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et
 917                                 ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.',
 918                                 'Hello world!',
 919                                 0,
 920                                 '/^Replaced .*Hello/'
 921                         ),
 922
 923                         array(
 924                                 'foo',
 925                                 'bar',
 926                                 0,
 927                                 '/^$/'
 928                         ),
 929                 );
 930         }
 931
 932         /**
 933          * @dataProvider provideGetAutoSummary
 934          * @covers WikiPage::getAutosummary
 935          */
 936         public function testGetAutosummary( $old, $new, $flags, $expected ) {
 937                 $this->hideDeprecated( "WikiPage::getAutosummary" );
 938
 939                 $page = $this->newPage( "WikiPageTest_testGetAutosummary" );
 940
 941                 $summary = $page->getAutosummary( $old, $new, $flags );
 942
 943                 $this->assertTrue( (bool)preg_match( $expected, $summary ),
 944                         "Autosummary didn't match expected pattern $expected: $summary" );
 945         }
 946
 947         public static function provideGetAutoDeleteReason() {
 948                 return array(
 949                         array(
 950                                 array(),
 951                                 false,
 952                                 false
 953                         ),
 954
 955                         array(
 956                                 array(
 957                                         array( "first edit", null ),
 958                                 ),
 959                                 "/first edit.*only contributor/",
 960                                 false
 961                         ),
 962
 963                         array(
 964                                 array(
 965                                         array( "first edit", null ),
 966                                         array( "second edit", null ),
 967                                 ),
 968                                 "/second edit.*only contributor/",
 969                                 true
 970                         ),
 971
 972                         array(
 973                                 array(
 974                                         array( "first edit", "127.0.2.22" ),
 975                                         array( "second edit", "127.0.3.33" ),
 976                                 ),
 977                                 "/second edit/",
 978                                 true
 979                         ),
 980
 981                         array(
 982                                 array(
 983                                         array( "first edit: "
 984                                                 . "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam "
 985                                                 . " nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. "
 986                                                 . "At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea "
 987                                                 . "takimata sanctus est Lorem ipsum dolor sit amet.'", null ),
 988                                 ),
 989                                 '/first edit:.*\.\.\."/',
 990                                 false
 991                         ),
 992
 993                         array(
 994                                 array(
 995                                         array( "first edit", "127.0.2.22" ),
 996                                         array( "", "127.0.3.33" ),
 997                                 ),
 998                                 "/before blanking.*first edit/",
 999                                 true
1000                         ),
1001
1002                 );
1003         }
1004
1005         /**
1006          * @dataProvider provideGetAutoDeleteReason
1007          * @covers WikiPage::getAutoDeleteReason
1008          */
1009         public function testGetAutoDeleteReason( $edits, $expectedResult, $expectedHistory ) {
1010                 global $wgUser;
1011
1012                 //NOTE: assume Help namespace to contain wikitext
1013                 $page = $this->newPage( "Help:WikiPageTest_testGetAutoDeleteReason" );
1014
1015                 $c = 1;
1016
1017                 foreach ( $edits as $edit ) {
1018                         $user = new User();
1019
1020                         if ( !empty( $edit[1] ) ) {
1021                                 $user->setName( $edit[1] );
1022                         } else {
1023                                 $user = $wgUser;
1024                         }
1025
1026                         $content = ContentHandler::makeContent( $edit[0], $page->getTitle(), $page->getContentModel() );
1027
1028                         $page->doEditContent( $content, "test edit $c", $c < 2 ? EDIT_NEW : 0, false, $user );
1029
1030                         $c += 1;
1031                 }
1032
1033                 $reason = $page->getAutoDeleteReason( $hasHistory );
1034
1035                 if ( is_bool( $expectedResult ) || is_null( $expectedResult ) ) {
1036                         $this->assertEquals( $expectedResult, $reason );
1037                 } else {
1038                         $this->assertTrue( (bool)preg_match( $expectedResult, $reason ),
1039                                 "Autosummary didn't match expected pattern $expectedResult: $reason" );
1040                 }
1041
1042                 $this->assertEquals( $expectedHistory, $hasHistory,
1043                         "expected \$hasHistory to be " . var_export( $expectedHistory, true ) );
1044
1045                 $page->doDeleteArticle( "done" );
1046         }
1047
1048         public static function providePreSaveTransform() {
1049                 return array(
1050                         array( 'hello this is ~~~',
1051                                 "hello this is [[Special:Contributions/127.0.0.1|127.0.0.1]]",
1052                         ),
1053                         array( 'hello \'\'this\'\' is <nowiki>~~~</nowiki>',
1054                                 'hello \'\'this\'\' is <nowiki>~~~</nowiki>',
1055                         ),
1056                 );
1057         }
1058
1059         /**
1060          * @dataProvider providePreSaveTransform
1061          * @covers WikiPage::preSaveTransform
1062          */
1063         public function testPreSaveTransform( $text, $expected ) {
1064                 $this->hideDeprecated( 'WikiPage::preSaveTransform' );
1065                 $user = new User();
1066                 $user->setName( "127.0.0.1" );
1067
1068                 //NOTE: assume Help namespace to contain wikitext
1069                 $page = $this->newPage( "Help:WikiPageTest_testPreloadTransform" );
1070                 $text = $page->preSaveTransform( $text, $user );
1071
1072                 $this->assertEquals( $expected, $text );
1073         }
1074 }