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