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