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