tests/phpunit/includes/WikiPageTest.php

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