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