tests/phpunit/includes/WikiPageTest.php

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