tests/phpunit/includes/WikiPageTest.php

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