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