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