tests/phpunit/includes/page/WikiPageDbTestBase.php

   1 <?php
   2
   3 abstract class WikiPageDbTestBase extends MediaWikiLangTestCase {
   4
   5         private $pagesToDelete;
   6
   7         public function __construct( $name = null, array $data = [], $dataName = '' ) {
   8                 parent::__construct( $name, $data, $dataName );
   9
  10                 $this->tablesUsed = array_merge(
  11                         $this->tablesUsed,
  12                         [ 'page',
  13                                 'revision',
  14                                 'archive',
  15                                 'category',
  16                                 'ip_changes',
  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         protected function setUp() {
  33                 parent::setUp();
  34                 $this->setMwGlobals( 'wgContentHandlerUseDB', $this->getContentHandlerUseDB() );
  35                 $this->pagesToDelete = [];
  36         }
  37
  38         protected function tearDown() {
  39                 foreach ( $this->pagesToDelete as $p ) {
  40                         /* @var $p WikiPage */
  41
  42                         try {
  43                                 if ( $p->exists() ) {
  44                                         $p->doDeleteArticle( "testing done." );
  45                                 }
  46                         } catch ( MWException $ex ) {
  47                                 // fail silently
  48                         }
  49                 }
  50                 parent::tearDown();
  51         }
  52
  53         abstract protected function getContentHandlerUseDB();
  54
  55         /**
  56          * @param Title|string $title
  57          * @param string|null $model
  58          * @return WikiPage
  59          */
  60         private function newPage( $title, $model = null ) {
  61                 if ( is_string( $title ) ) {
  62                         $ns = $this->getDefaultWikitextNS();
  63                         $title = Title::newFromText( $title, $ns );
  64                 }
  65
  66                 $p = new WikiPage( $title );
  67
  68                 $this->pagesToDelete[] = $p;
  69
  70                 return $p;
  71         }
  72
  73         /**
  74          * @param string|Title|WikiPage $page
  75          * @param string $text
  76          * @param int $model
  77          *
  78          * @return WikiPage
  79          */
  80         protected function createPage( $page, $text, $model = null ) {
  81                 if ( is_string( $page ) || $page instanceof Title ) {
  82                         $page = $this->newPage( $page, $model );
  83                 }
  84
  85                 $content = ContentHandler::makeContent( $text, $page->getTitle(), $model );
  86                 $page->doEditContent( $content, "testing", EDIT_NEW );
  87
  88                 return $page;
  89         }
  90
  91         /**
  92          * @covers WikiPage::doEditContent
  93          * @covers WikiPage::doModify
  94          * @covers WikiPage::doCreate
  95          * @covers WikiPage::doEditUpdates
  96          */
  97         public function testDoEditContent() {
  98                 $page = $this->newPage( __METHOD__ );
  99                 $title = $page->getTitle();
 100
 101                 $content = ContentHandler::makeContent(
 102                         "[[Lorem ipsum]] dolor sit amet, consetetur sadipscing elitr, sed diam "
 103                                 . " nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat.",
 104                         $title,
 105                         CONTENT_MODEL_WIKITEXT
 106                 );
 107
 108                 $page->doEditContent( $content, "[[testing]] 1" );
 109
 110                 $this->assertTrue( $title->getArticleID() > 0, "Title object should have new page id" );
 111                 $this->assertTrue( $page->getId() > 0, "WikiPage should have new page id" );
 112                 $this->assertTrue( $title->exists(), "Title object should indicate that the page now exists" );
 113                 $this->assertTrue( $page->exists(), "WikiPage object should indicate that the page now exists" );
 114
 115                 $id = $page->getId();
 116
 117                 # ------------------------
 118                 $dbr = wfGetDB( DB_REPLICA );
 119                 $res = $dbr->select( 'pagelinks', '*', [ 'pl_from' => $id ] );
 120                 $n = $res->numRows();
 121                 $res->free();
 122
 123                 $this->assertEquals( 1, $n, 'pagelinks should contain one link from the page' );
 124
 125                 # ------------------------
 126                 $page = new WikiPage( $title );
 127
 128                 $retrieved = $page->getContent();
 129                 $this->assertTrue( $content->equals( $retrieved ), 'retrieved content doesn\'t equal original' );
 130
 131                 # ------------------------
 132                 $content = ContentHandler::makeContent(
 133                         "At vero eos et accusam et justo duo [[dolores]] et ea rebum. "
 134                                 . "Stet clita kasd [[gubergren]], no sea takimata sanctus est.",
 135                         $title,
 136                         CONTENT_MODEL_WIKITEXT
 137                 );
 138
 139                 $page->doEditContent( $content, "testing 2" );
 140
 141                 # ------------------------
 142                 $page = new WikiPage( $title );
 143
 144                 $retrieved = $page->getContent();
 145                 $this->assertTrue( $content->equals( $retrieved ), 'retrieved content doesn\'t equal original' );
 146
 147                 # ------------------------
 148                 $dbr = wfGetDB( DB_REPLICA );
 149                 $res = $dbr->select( 'pagelinks', '*', [ 'pl_from' => $id ] );
 150                 $n = $res->numRows();
 151                 $res->free();
 152
 153                 $this->assertEquals( 2, $n, 'pagelinks should contain two links from the page' );
 154         }
 155
 156         /**
 157          * @covers WikiPage::doDeleteArticle
 158          * @covers WikiPage::doDeleteArticleReal
 159          */
 160         public function testDoDeleteArticle() {
 161                 $page = $this->createPage(
 162                         __METHOD__,
 163                         "[[original text]] foo",
 164                         CONTENT_MODEL_WIKITEXT
 165                 );
 166                 $id = $page->getId();
 167
 168                 $page->doDeleteArticle( "testing deletion" );
 169
 170                 $this->assertFalse(
 171                         $page->getTitle()->getArticleID() > 0,
 172                         "Title object should now have page id 0"
 173                 );
 174                 $this->assertFalse( $page->getId() > 0, "WikiPage should now have page id 0" );
 175                 $this->assertFalse(
 176                         $page->exists(),
 177                         "WikiPage::exists should return false after page was deleted"
 178                 );
 179                 $this->assertNull(
 180                         $page->getContent(),
 181                         "WikiPage::getContent should return null after page was deleted"
 182                 );
 183
 184                 $t = Title::newFromText( $page->getTitle()->getPrefixedText() );
 185                 $this->assertFalse(
 186                         $t->exists(),
 187                         "Title::exists should return false after page was deleted"
 188                 );
 189
 190                 // Run the job queue
 191                 JobQueueGroup::destroySingletons();
 192                 $jobs = new RunJobs;
 193                 $jobs->loadParamsAndArgs( null, [ 'quiet' => true ], null );
 194                 $jobs->execute();
 195
 196                 # ------------------------
 197                 $dbr = wfGetDB( DB_REPLICA );
 198                 $res = $dbr->select( 'pagelinks', '*', [ 'pl_from' => $id ] );
 199                 $n = $res->numRows();
 200                 $res->free();
 201
 202                 $this->assertEquals( 0, $n, 'pagelinks should contain no more links from the page' );
 203         }
 204
 205         /**
 206          * @covers WikiPage::doDeleteUpdates
 207          */
 208         public function testDoDeleteUpdates() {
 209                 $page = $this->createPage(
 210                         __METHOD__,
 211                         "[[original text]] foo",
 212                         CONTENT_MODEL_WIKITEXT
 213                 );
 214                 $id = $page->getId();
 215
 216                 // Similar to MovePage logic
 217                 wfGetDB( DB_MASTER )->delete( 'page', [ 'page_id' => $id ], __METHOD__ );
 218                 $page->doDeleteUpdates( $id );
 219
 220                 // Run the job queue
 221                 JobQueueGroup::destroySingletons();
 222                 $jobs = new RunJobs;
 223                 $jobs->loadParamsAndArgs( null, [ 'quiet' => true ], null );
 224                 $jobs->execute();
 225
 226                 # ------------------------
 227                 $dbr = wfGetDB( DB_REPLICA );
 228                 $res = $dbr->select( 'pagelinks', '*', [ 'pl_from' => $id ] );
 229                 $n = $res->numRows();
 230                 $res->free();
 231
 232                 $this->assertEquals( 0, $n, 'pagelinks should contain no more links from the page' );
 233         }
 234
 235         /**
 236          * @covers WikiPage::getRevision
 237          */
 238         public function testGetRevision() {
 239                 $page = $this->newPage( __METHOD__ );
 240
 241                 $rev = $page->getRevision();
 242                 $this->assertNull( $rev );
 243
 244                 # -----------------
 245                 $this->createPage( $page, "some text", CONTENT_MODEL_WIKITEXT );
 246
 247                 $rev = $page->getRevision();
 248
 249                 $this->assertEquals( $page->getLatest(), $rev->getId() );
 250                 $this->assertEquals( "some text", $rev->getContent()->getNativeData() );
 251         }
 252
 253         /**
 254          * @covers WikiPage::getContent
 255          */
 256         public function testGetContent() {
 257                 $page = $this->newPage( __METHOD__ );
 258
 259                 $content = $page->getContent();
 260                 $this->assertNull( $content );
 261
 262                 # -----------------
 263                 $this->createPage( $page, "some text", CONTENT_MODEL_WIKITEXT );
 264
 265                 $content = $page->getContent();
 266                 $this->assertEquals( "some text", $content->getNativeData() );
 267         }
 268
 269         /**
 270          * @covers WikiPage::exists
 271          */
 272         public function testExists() {
 273                 $page = $this->newPage( __METHOD__ );
 274                 $this->assertFalse( $page->exists() );
 275
 276                 # -----------------
 277                 $this->createPage( $page, "some text", CONTENT_MODEL_WIKITEXT );
 278                 $this->assertTrue( $page->exists() );
 279
 280                 $page = new WikiPage( $page->getTitle() );
 281                 $this->assertTrue( $page->exists() );
 282
 283                 # -----------------
 284                 $page->doDeleteArticle( "done testing" );
 285                 $this->assertFalse( $page->exists() );
 286
 287                 $page = new WikiPage( $page->getTitle() );
 288                 $this->assertFalse( $page->exists() );
 289         }
 290
 291         public function provideHasViewableContent() {
 292                 return [
 293                         [ 'WikiPageTest_testHasViewableContent', false, true ],
 294                         [ 'Special:WikiPageTest_testHasViewableContent', false ],
 295                         [ 'MediaWiki:WikiPageTest_testHasViewableContent', false ],
 296                         [ 'Special:Userlogin', true ],
 297                         [ 'MediaWiki:help', true ],
 298                 ];
 299         }
 300
 301         /**
 302          * @dataProvider provideHasViewableContent
 303          * @covers WikiPage::hasViewableContent
 304          */
 305         public function testHasViewableContent( $title, $viewable, $create = false ) {
 306                 $page = $this->newPage( $title );
 307                 $this->assertEquals( $viewable, $page->hasViewableContent() );
 308
 309                 if ( $create ) {
 310                         $this->createPage( $page, "some text", CONTENT_MODEL_WIKITEXT );
 311                         $this->assertTrue( $page->hasViewableContent() );
 312
 313                         $page = new WikiPage( $page->getTitle() );
 314                         $this->assertTrue( $page->hasViewableContent() );
 315                 }
 316         }
 317
 318         public function provideGetRedirectTarget() {
 319                 return [
 320                         [ 'WikiPageTest_testGetRedirectTarget_1', CONTENT_MODEL_WIKITEXT, "hello world", null ],
 321                         [
 322                                 'WikiPageTest_testGetRedirectTarget_2',
 323                                 CONTENT_MODEL_WIKITEXT,
 324                                 "#REDIRECT [[hello world]]",
 325                                 "Hello world"
 326                         ],
 327                 ];
 328         }
 329
 330         /**
 331          * @dataProvider provideGetRedirectTarget
 332          * @covers WikiPage::getRedirectTarget
 333          */
 334         public function testGetRedirectTarget( $title, $model, $text, $target ) {
 335                 $this->setMwGlobals( [
 336                         'wgCapitalLinks' => true,
 337                 ] );
 338
 339                 $page = $this->createPage( $title, $text, $model );
 340
 341                 # sanity check, because this test seems to fail for no reason for some people.
 342                 $c = $page->getContent();
 343                 $this->assertEquals( 'WikitextContent', get_class( $c ) );
 344
 345                 # now, test the actual redirect
 346                 $t = $page->getRedirectTarget();
 347                 $this->assertEquals( $target, is_null( $t ) ? null : $t->getPrefixedText() );
 348         }
 349
 350         /**
 351          * @dataProvider provideGetRedirectTarget
 352          * @covers WikiPage::isRedirect
 353          */
 354         public function testIsRedirect( $title, $model, $text, $target ) {
 355                 $page = $this->createPage( $title, $text, $model );
 356                 $this->assertEquals( !is_null( $target ), $page->isRedirect() );
 357         }
 358
 359         public function provideIsCountable() {
 360                 return [
 361
 362                         // any
 363                         [ 'WikiPageTest_testIsCountable',
 364                                 CONTENT_MODEL_WIKITEXT,
 365                                 '',
 366                                 'any',
 367                                 true
 368                         ],
 369                         [ 'WikiPageTest_testIsCountable',
 370                                 CONTENT_MODEL_WIKITEXT,
 371                                 'Foo',
 372                                 'any',
 373                                 true
 374                         ],
 375
 376                         // comma
 377                         [ 'WikiPageTest_testIsCountable',
 378                                 CONTENT_MODEL_WIKITEXT,
 379                                 'Foo',
 380                                 'comma',
 381                                 false
 382                         ],
 383                         [ 'WikiPageTest_testIsCountable',
 384                                 CONTENT_MODEL_WIKITEXT,
 385                                 'Foo, bar',
 386                                 'comma',
 387                                 true
 388                         ],
 389
 390                         // link
 391                         [ 'WikiPageTest_testIsCountable',
 392                                 CONTENT_MODEL_WIKITEXT,
 393                                 'Foo',
 394                                 'link',
 395                                 false
 396                         ],
 397                         [ 'WikiPageTest_testIsCountable',
 398                                 CONTENT_MODEL_WIKITEXT,
 399                                 'Foo [[bar]]',
 400                                 'link',
 401                                 true
 402                         ],
 403
 404                         // redirects
 405                         [ 'WikiPageTest_testIsCountable',
 406                                 CONTENT_MODEL_WIKITEXT,
 407                                 '#REDIRECT [[bar]]',
 408                                 'any',
 409                                 false
 410                         ],
 411                         [ 'WikiPageTest_testIsCountable',
 412                                 CONTENT_MODEL_WIKITEXT,
 413                                 '#REDIRECT [[bar]]',
 414                                 'comma',
 415                                 false
 416                         ],
 417                         [ 'WikiPageTest_testIsCountable',
 418                                 CONTENT_MODEL_WIKITEXT,
 419                                 '#REDIRECT [[bar]]',
 420                                 'link',
 421                                 false
 422                         ],
 423
 424                         // not a content namespace
 425                         [ 'Talk:WikiPageTest_testIsCountable',
 426                                 CONTENT_MODEL_WIKITEXT,
 427                                 'Foo',
 428                                 'any',
 429                                 false
 430                         ],
 431                         [ 'Talk:WikiPageTest_testIsCountable',
 432                                 CONTENT_MODEL_WIKITEXT,
 433                                 'Foo, bar',
 434                                 'comma',
 435                                 false
 436                         ],
 437                         [ 'Talk:WikiPageTest_testIsCountable',
 438                                 CONTENT_MODEL_WIKITEXT,
 439                                 'Foo [[bar]]',
 440                                 'link',
 441                                 false
 442                         ],
 443
 444                         // not a content namespace, different model
 445                         [ 'MediaWiki:WikiPageTest_testIsCountable.js',
 446                                 null,
 447                                 'Foo',
 448                                 'any',
 449                                 false
 450                         ],
 451                         [ 'MediaWiki:WikiPageTest_testIsCountable.js',
 452                                 null,
 453                                 'Foo, bar',
 454                                 'comma',
 455                                 false
 456                         ],
 457                         [ 'MediaWiki:WikiPageTest_testIsCountable.js',
 458                                 null,
 459                                 'Foo [[bar]]',
 460                                 'link',
 461                                 false
 462                         ],
 463                 ];
 464         }
 465
 466         /**
 467          * @dataProvider provideIsCountable
 468          * @covers WikiPage::isCountable
 469          */
 470         public function testIsCountable( $title, $model, $text, $mode, $expected ) {
 471                 global $wgContentHandlerUseDB;
 472
 473                 $this->setMwGlobals( 'wgArticleCountMethod', $mode );
 474
 475                 $title = Title::newFromText( $title );
 476
 477                 if ( !$wgContentHandlerUseDB
 478                         && $model
 479                         && ContentHandler::getDefaultModelFor( $title ) != $model
 480                 ) {
 481                         $this->markTestSkipped( "Can not use non-default content model $model for "
 482                                 . $title->getPrefixedDBkey() . " with \$wgContentHandlerUseDB disabled." );
 483                 }
 484
 485                 $page = $this->createPage( $title, $text, $model );
 486
 487                 $editInfo = $page->prepareContentForEdit( $page->getContent() );
 488
 489                 $v = $page->isCountable();
 490                 $w = $page->isCountable( $editInfo );
 491
 492                 $this->assertEquals(
 493                         $expected,
 494                         $v,
 495                         "isCountable( null ) returned unexpected value " . var_export( $v, true )
 496                                 . " instead of " . var_export( $expected, true )
 497                         . " in mode `$mode` for text \"$text\""
 498                 );
 499
 500                 $this->assertEquals(
 501                         $expected,
 502                         $w,
 503                         "isCountable( \$editInfo ) returned unexpected value " . var_export( $v, true )
 504                                 . " instead of " . var_export( $expected, true )
 505                         . " in mode `$mode` for text \"$text\""
 506                 );
 507         }
 508
 509         public function provideGetParserOutput() {
 510                 return [
 511                         [
 512                                 CONTENT_MODEL_WIKITEXT,
 513                                 "hello ''world''\n",
 514                                 "<div class=\"mw-parser-output\"><p>hello <i>world</i></p></div>"
 515                         ],
 516                         // @todo more...?
 517                 ];
 518         }
 519
 520         /**
 521          * @dataProvider provideGetParserOutput
 522          * @covers WikiPage::getParserOutput
 523          */
 524         public function testGetParserOutput( $model, $text, $expectedHtml ) {
 525                 $page = $this->createPage( __METHOD__, $text, $model );
 526
 527                 $opt = $page->makeParserOptions( 'canonical' );
 528                 $po = $page->getParserOutput( $opt );
 529                 $text = $po->getText();
 530
 531                 $text = trim( preg_replace( '/<!--.*?-->/sm', '', $text ) ); # strip injected comments
 532                 $text = preg_replace( '!\s*(</p>|</div>)!sm', '\1', $text ); # don't let tidy confuse us
 533
 534                 $this->assertEquals( $expectedHtml, $text );
 535
 536                 return $po;
 537         }
 538
 539         /**
 540          * @covers WikiPage::getParserOutput
 541          */
 542         public function testGetParserOutput_nonexisting() {
 543                 $page = new WikiPage( Title::newFromText( __METHOD__ ) );
 544
 545                 $opt = new ParserOptions();
 546                 $po = $page->getParserOutput( $opt );
 547
 548                 $this->assertFalse( $po, "getParserOutput() shall return false for non-existing pages." );
 549         }
 550
 551         /**
 552          * @covers WikiPage::getParserOutput
 553          */
 554         public function testGetParserOutput_badrev() {
 555                 $page = $this->createPage( __METHOD__, 'dummy', CONTENT_MODEL_WIKITEXT );
 556
 557                 $opt = new ParserOptions();
 558                 $po = $page->getParserOutput( $opt, $page->getLatest() + 1234 );
 559
 560                 // @todo would be neat to also test deleted revision
 561
 562                 $this->assertFalse( $po, "getParserOutput() shall return false for non-existing revisions." );
 563         }
 564
 565         public static $sections =
 566
 567                 "Intro
 568
 569 == stuff ==
 570 hello world
 571
 572 == test ==
 573 just a test
 574
 575 == foo ==
 576 more stuff
 577 ";
 578
 579         public function dataReplaceSection() {
 580                 // NOTE: assume the Help namespace to contain wikitext
 581                 return [
 582                         [ 'Help:WikiPageTest_testReplaceSection',
 583                                 CONTENT_MODEL_WIKITEXT,
 584                                 self::$sections,
 585                                 "0",
 586                                 "No more",
 587                                 null,
 588                                 trim( preg_replace( '/^Intro/sm', 'No more', self::$sections ) )
 589                         ],
 590                         [ 'Help:WikiPageTest_testReplaceSection',
 591                                 CONTENT_MODEL_WIKITEXT,
 592                                 self::$sections,
 593                                 "",
 594                                 "No more",
 595                                 null,
 596                                 "No more"
 597                         ],
 598                         [ 'Help:WikiPageTest_testReplaceSection',
 599                                 CONTENT_MODEL_WIKITEXT,
 600                                 self::$sections,
 601                                 "2",
 602                                 "== TEST ==\nmore fun",
 603                                 null,
 604                                 trim( preg_replace( '/^== test ==.*== foo ==/sm',
 605                                         "== TEST ==\nmore fun\n\n== foo ==",
 606                                         self::$sections ) )
 607                         ],
 608                         [ 'Help:WikiPageTest_testReplaceSection',
 609                                 CONTENT_MODEL_WIKITEXT,
 610                                 self::$sections,
 611                                 "8",
 612                                 "No more",
 613                                 null,
 614                                 trim( self::$sections )
 615                         ],
 616                         [ 'Help:WikiPageTest_testReplaceSection',
 617                                 CONTENT_MODEL_WIKITEXT,
 618                                 self::$sections,
 619                                 "new",
 620                                 "No more",
 621                                 "New",
 622                                 trim( self::$sections ) . "\n\n== New ==\n\nNo more"
 623                         ],
 624                 ];
 625         }
 626
 627         /**
 628          * @dataProvider dataReplaceSection
 629          * @covers WikiPage::replaceSectionContent
 630          */
 631         public function testReplaceSectionContent( $title, $model, $text, $section,
 632                 $with, $sectionTitle, $expected
 633         ) {
 634                 $page = $this->createPage( $title, $text, $model );
 635
 636                 $content = ContentHandler::makeContent( $with, $page->getTitle(), $page->getContentModel() );
 637                 $c = $page->replaceSectionContent( $section, $content, $sectionTitle );
 638
 639                 $this->assertEquals( $expected, is_null( $c ) ? null : trim( $c->getNativeData() ) );
 640         }
 641
 642         /**
 643          * @dataProvider dataReplaceSection
 644          * @covers WikiPage::replaceSectionAtRev
 645          */
 646         public function testReplaceSectionAtRev( $title, $model, $text, $section,
 647                 $with, $sectionTitle, $expected
 648         ) {
 649                 $page = $this->createPage( $title, $text, $model );
 650                 $baseRevId = $page->getLatest();
 651
 652                 $content = ContentHandler::makeContent( $with, $page->getTitle(), $page->getContentModel() );
 653                 $c = $page->replaceSectionAtRev( $section, $content, $sectionTitle, $baseRevId );
 654
 655                 $this->assertEquals( $expected, is_null( $c ) ? null : trim( $c->getNativeData() ) );
 656         }
 657
 658         /**
 659          * @covers WikiPage::getOldestRevision
 660          */
 661         public function testGetOldestRevision() {
 662                 $page = $this->newPage( __METHOD__ );
 663                 $page->doEditContent(
 664                         new WikitextContent( 'one' ),
 665                         "first edit",
 666                         EDIT_NEW
 667                 );
 668                 $rev1 = $page->getRevision();
 669
 670                 $page = new WikiPage( $page->getTitle() );
 671                 $page->doEditContent(
 672                         new WikitextContent( 'two' ),
 673                         "second edit",
 674                         EDIT_UPDATE
 675                 );
 676
 677                 $page = new WikiPage( $page->getTitle() );
 678                 $page->doEditContent(
 679                         new WikitextContent( 'three' ),
 680                         "third edit",
 681                         EDIT_UPDATE
 682                 );
 683
 684                 // sanity check
 685                 $this->assertNotEquals(
 686                         $rev1->getId(),
 687                         $page->getRevision()->getId(),
 688                         '$page->getRevision()->getId()'
 689                 );
 690
 691                 // actual test
 692                 $this->assertEquals(
 693                         $rev1->getId(),
 694                         $page->getOldestRevision()->getId(),
 695                         '$page->getOldestRevision()->getId()'
 696                 );
 697         }
 698
 699         /**
 700          * @covers WikiPage::doRollback
 701          * @covers WikiPage::commitRollback
 702          */
 703         public function testDoRollback() {
 704                 $admin = $this->getTestSysop()->getUser();
 705                 $user1 = $this->getTestUser()->getUser();
 706                 // Use the confirmed group for user2 to make sure the user is different
 707                 $user2 = $this->getTestUser( [ 'confirmed' ] )->getUser();
 708
 709                 $page = $this->newPage( __METHOD__ );
 710
 711                 // Make some edits
 712                 $text = "one";
 713                 $status1 = $page->doEditContent( ContentHandler::makeContent( $text, $page->getTitle() ),
 714                         "section one", EDIT_NEW, false, $admin );
 715
 716                 $text .= "\n\ntwo";
 717                 $status2 = $page->doEditContent( ContentHandler::makeContent( $text, $page->getTitle() ),
 718                         "adding section two", 0, false, $user1 );
 719
 720                 $text .= "\n\nthree";
 721                 $status3 = $page->doEditContent( ContentHandler::makeContent( $text, $page->getTitle() ),
 722                         "adding section three", 0, false, $user2 );
 723
 724                 /** @var Revision $rev1 */
 725                 /** @var Revision $rev2 */
 726                 /** @var Revision $rev3 */
 727                 $rev1 = $status1->getValue()['revision'];
 728                 $rev2 = $status2->getValue()['revision'];
 729                 $rev3 = $status3->getValue()['revision'];
 730
 731                 /**
 732                  * We are having issues with doRollback spuriously failing. Apparently
 733                  * the last revision somehow goes missing or not committed under some
 734                  * circumstances. So, make sure the revisions have the correct usernames.
 735                  */
 736                 $this->assertEquals( 3, Revision::countByPageId( wfGetDB( DB_REPLICA ), $page->getId() ) );
 737                 $this->assertEquals( $admin->getName(), $rev1->getUserText() );
 738                 $this->assertEquals( $user1->getName(), $rev2->getUserText() );
 739                 $this->assertEquals( $user2->getName(), $rev3->getUserText() );
 740
 741                 // Now, try the actual rollback
 742                 $token = $admin->getEditToken( 'rollback' );
 743                 $rollbackErrors = $page->doRollback(
 744                         $user2->getName(),
 745                         "testing rollback",
 746                         $token,
 747                         false,
 748                         $resultDetails,
 749                         $admin
 750                 );
 751
 752                 if ( $rollbackErrors ) {
 753                         $this->fail(
 754                                 "Rollback failed:\n" .
 755                                 print_r( $rollbackErrors, true ) . ";\n" .
 756                                 print_r( $resultDetails, true )
 757                         );
 758                 }
 759
 760                 $page = new WikiPage( $page->getTitle() );
 761                 $this->assertEquals( $rev2->getSha1(), $page->getRevision()->getSha1(),
 762                         "rollback did not revert to the correct revision" );
 763                 $this->assertEquals( "one\n\ntwo", $page->getContent()->getNativeData() );
 764         }
 765
 766         /**
 767          * @covers WikiPage::doRollback
 768          * @covers WikiPage::commitRollback
 769          */
 770         public function testDoRollback_simple() {
 771                 $admin = $this->getTestSysop()->getUser();
 772
 773                 $text = "one";
 774                 $page = $this->newPage( __METHOD__ );
 775                 $page->doEditContent(
 776                         ContentHandler::makeContent( $text, $page->getTitle(), CONTENT_MODEL_WIKITEXT ),
 777                         "section one",
 778                         EDIT_NEW,
 779                         false,
 780                         $admin
 781                 );
 782                 $rev1 = $page->getRevision();
 783
 784                 $user1 = $this->getTestUser()->getUser();
 785                 $text .= "\n\ntwo";
 786                 $page = new WikiPage( $page->getTitle() );
 787                 $page->doEditContent(
 788                         ContentHandler::makeContent( $text, $page->getTitle(), CONTENT_MODEL_WIKITEXT ),
 789                         "adding section two",
 790                         0,
 791                         false,
 792                         $user1
 793                 );
 794
 795                 # now, try the rollback
 796                 $token = $admin->getEditToken( 'rollback' );
 797                 $errors = $page->doRollback(
 798                         $user1->getName(),
 799                         "testing revert",
 800                         $token,
 801                         false,
 802                         $details,
 803                         $admin
 804                 );
 805
 806                 if ( $errors ) {
 807                         $this->fail( "Rollback failed:\n" . print_r( $errors, true )
 808                                 . ";\n" . print_r( $details, true ) );
 809                 }
 810
 811                 $page = new WikiPage( $page->getTitle() );
 812                 $this->assertEquals( $rev1->getSha1(), $page->getRevision()->getSha1(),
 813                         "rollback did not revert to the correct revision" );
 814                 $this->assertEquals( "one", $page->getContent()->getNativeData() );
 815         }
 816
 817         /**
 818          * @covers WikiPage::doRollback
 819          * @covers WikiPage::commitRollback
 820          */
 821         public function testDoRollbackFailureSameContent() {
 822                 $admin = $this->getTestSysop()->getUser();
 823
 824                 $text = "one";
 825                 $page = $this->newPage( __METHOD__ );
 826                 $page->doEditContent(
 827                         ContentHandler::makeContent( $text, $page->getTitle(), CONTENT_MODEL_WIKITEXT ),
 828                         "section one",
 829                         EDIT_NEW,
 830                         false,
 831                         $admin
 832                 );
 833                 $rev1 = $page->getRevision();
 834
 835                 $user1 = $this->getTestUser( [ 'sysop' ] )->getUser();
 836                 $text .= "\n\ntwo";
 837                 $page = new WikiPage( $page->getTitle() );
 838                 $page->doEditContent(
 839                         ContentHandler::makeContent( $text, $page->getTitle(), CONTENT_MODEL_WIKITEXT ),
 840                         "adding section two",
 841                         0,
 842                         false,
 843                         $user1
 844                 );
 845
 846                 # now, do a the rollback from the same user was doing the edit before
 847                 $resultDetails = [];
 848                 $token = $user1->getEditToken( 'rollback' );
 849                 $errors = $page->doRollback(
 850                         $user1->getName(),
 851                         "testing revert same user",
 852                         $token,
 853                         false,
 854                         $resultDetails,
 855                         $admin
 856                 );
 857
 858                 $this->assertEquals( [], $errors, "Rollback failed same user" );
 859
 860                 # now, try the rollback
 861                 $resultDetails = [];
 862                 $token = $admin->getEditToken( 'rollback' );
 863                 $errors = $page->doRollback(
 864                         $user1->getName(),
 865                         "testing revert",
 866                         $token,
 867                         false,
 868                         $resultDetails,
 869                         $admin
 870                 );
 871
 872                 $this->assertEquals(
 873                         [
 874                                 [
 875                                         'alreadyrolled',
 876                                         __METHOD__,
 877                                         $user1->getName(),
 878                                         $admin->getName(),
 879                                 ],
 880                         ],
 881                         $errors,
 882                         "Rollback not failed"
 883                 );
 884
 885                 $page = new WikiPage( $page->getTitle() );
 886                 $this->assertEquals( $rev1->getSha1(), $page->getRevision()->getSha1(),
 887                         "rollback did not revert to the correct revision" );
 888                 $this->assertEquals( "one", $page->getContent()->getNativeData() );
 889         }
 890
 891         /**
 892          * Tests tagging for edits that do rollback action
 893          * @covers WikiPage::doRollback
 894          */
 895         public function testDoRollbackTagging() {
 896                 if ( !in_array( 'mw-rollback', ChangeTags::getSoftwareTags() ) ) {
 897                         $this->markTestSkipped( 'Rollback tag deactivated, skipped the test.' );
 898                 }
 899
 900                 $admin = new User();
 901                 $admin->setName( 'Administrator' );
 902                 $admin->addToDatabase();
 903
 904                 $text = 'First line';
 905                 $page = $this->newPage( 'WikiPageTest_testDoRollbackTagging' );
 906                 $page->doEditContent(
 907                         ContentHandler::makeContent( $text, $page->getTitle(), CONTENT_MODEL_WIKITEXT ),
 908                         'Added first line',
 909                         EDIT_NEW,
 910                         false,
 911                         $admin
 912                 );
 913
 914                 $secondUser = new User();
 915                 $secondUser->setName( '92.65.217.32' );
 916                 $text .= '\n\nSecond line';
 917                 $page = new WikiPage( $page->getTitle() );
 918                 $page->doEditContent(
 919                         ContentHandler::makeContent( $text, $page->getTitle(), CONTENT_MODEL_WIKITEXT ),
 920                         'Adding second line',
 921                         0,
 922                         false,
 923                         $secondUser
 924                 );
 925
 926                 // Now, try the rollback
 927                 $admin->addGroup( 'sysop' ); // Make the test user a sysop
 928                 $token = $admin->getEditToken( 'rollback' );
 929                 $errors = $page->doRollback(
 930                         $secondUser->getName(),
 931                         'testing rollback',
 932                         $token,
 933                         false,
 934                         $resultDetails,
 935                         $admin
 936                 );
 937
 938                 // If doRollback completed without errors
 939                 if ( $errors === [] ) {
 940                         $tags = $resultDetails[ 'tags' ];
 941                         $this->assertContains( 'mw-rollback', $tags );
 942                 }
 943         }
 944
 945         public function provideGetAutoDeleteReason() {
 946                 return [
 947                         [
 948                                 [],
 949                                 false,
 950                                 false
 951                         ],
 952
 953                         [
 954                                 [
 955                                         [ "first edit", null ],
 956                                 ],
 957                                 "/first edit.*only contributor/",
 958                                 false
 959                         ],
 960
 961                         [
 962                                 [
 963                                         [ "first edit", null ],
 964                                         [ "second edit", null ],
 965                                 ],
 966                                 "/second edit.*only contributor/",
 967                                 true
 968                         ],
 969
 970                         [
 971                                 [
 972                                         [ "first edit", "127.0.2.22" ],
 973                                         [ "second edit", "127.0.3.33" ],
 974                                 ],
 975                                 "/second edit/",
 976                                 true
 977                         ],
 978
 979                         [
 980                                 [
 981                                         [
 982                                                 "first edit: "
 983                                                         . "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam "
 984                                                         . " nonumy eirmod tempor invidunt ut labore et dolore magna "
 985                                                         . "aliquyam erat, sed diam voluptua. At vero eos et accusam "
 986                                                         . "et justo duo dolores et ea rebum. Stet clita kasd gubergren, "
 987                                                         . "no sea  takimata sanctus est Lorem ipsum dolor sit amet.'",
 988                                                 null
 989                                         ],
 990                                 ],
 991                                 '/first edit:.*\.\.\."/',
 992                                 false
 993                         ],
 994
 995                         [
 996                                 [
 997                                         [ "first edit", "127.0.2.22" ],
 998                                         [ "", "127.0.3.33" ],
 999                                 ],
1000                                 "/before blanking.*first edit/",
1001                                 true
1002                         ],
1003
1004                 ];
1005         }
1006
1007         /**
1008          * @dataProvider provideGetAutoDeleteReason
1009          * @covers WikiPage::getAutoDeleteReason
1010          */
1011         public function testGetAutoDeleteReason( $edits, $expectedResult, $expectedHistory ) {
1012                 global $wgUser;
1013
1014                 // NOTE: assume Help namespace to contain wikitext
1015                 $page = $this->newPage( "Help:WikiPageTest_testGetAutoDeleteReason" );
1016
1017                 $c = 1;
1018
1019                 foreach ( $edits as $edit ) {
1020                         $user = new User();
1021
1022                         if ( !empty( $edit[1] ) ) {
1023                                 $user->setName( $edit[1] );
1024                         } else {
1025                                 $user = $wgUser;
1026                         }
1027
1028                         $content = ContentHandler::makeContent( $edit[0], $page->getTitle(), $page->getContentModel() );
1029
1030                         $page->doEditContent( $content, "test edit $c", $c < 2 ? EDIT_NEW : 0, false, $user );
1031
1032                         $c += 1;
1033                 }
1034
1035                 $reason = $page->getAutoDeleteReason( $hasHistory );
1036
1037                 if ( is_bool( $expectedResult ) || is_null( $expectedResult ) ) {
1038                         $this->assertEquals( $expectedResult, $reason );
1039                 } else {
1040                         $this->assertTrue( (bool)preg_match( $expectedResult, $reason ),
1041                                 "Autosummary didn't match expected pattern $expectedResult: $reason" );
1042                 }
1043
1044                 $this->assertEquals( $expectedHistory, $hasHistory,
1045                         "expected \$hasHistory to be " . var_export( $expectedHistory, true ) );
1046
1047                 $page->doDeleteArticle( "done" );
1048         }
1049
1050         public function providePreSaveTransform() {
1051                 return [
1052                         [ 'hello this is ~~~',
1053                                 "hello this is [[Special:Contributions/127.0.0.1|127.0.0.1]]",
1054                         ],
1055                         [ 'hello \'\'this\'\' is <nowiki>~~~</nowiki>',
1056                                 'hello \'\'this\'\' is <nowiki>~~~</nowiki>',
1057                         ],
1058                 ];
1059         }
1060
1061         /**
1062          * @covers WikiPage::factory
1063          */
1064         public function testWikiPageFactory() {
1065                 $title = Title::makeTitle( NS_FILE, 'Someimage.png' );
1066                 $page = WikiPage::factory( $title );
1067                 $this->assertEquals( 'WikiFilePage', get_class( $page ) );
1068
1069                 $title = Title::makeTitle( NS_CATEGORY, 'SomeCategory' );
1070                 $page = WikiPage::factory( $title );
1071                 $this->assertEquals( 'WikiCategoryPage', get_class( $page ) );
1072
1073                 $title = Title::makeTitle( NS_MAIN, 'SomePage' );
1074                 $page = WikiPage::factory( $title );
1075                 $this->assertEquals( 'WikiPage', get_class( $page ) );
1076         }
1077
1078         /**
1079          * @dataProvider provideCommentMigrationOnDeletion
1080          *
1081          * @param int $writeStage
1082          * @param int $readStage
1083          */
1084         public function testCommentMigrationOnDeletion( $writeStage, $readStage ) {
1085                 $this->setMwGlobals( 'wgCommentTableSchemaMigrationStage', $writeStage );
1086                 $dbr = wfGetDB( DB_REPLICA );
1087
1088                 $page = $this->createPage(
1089                         __METHOD__,
1090                         "foo",
1091                         CONTENT_MODEL_WIKITEXT
1092                 );
1093                 $revid = $page->getLatest();
1094                 if ( $writeStage > MIGRATION_OLD ) {
1095                         $comment_id = $dbr->selectField(
1096                                 'revision_comment_temp',
1097                                 'revcomment_comment_id',
1098                                 [ 'revcomment_rev' => $revid ],
1099                                 __METHOD__
1100                         );
1101                 }
1102
1103                 $this->setMwGlobals( 'wgCommentTableSchemaMigrationStage', $readStage );
1104
1105                 $page->doDeleteArticle( "testing deletion" );
1106
1107                 if ( $readStage > MIGRATION_OLD ) {
1108                         // Didn't leave behind any 'revision_comment_temp' rows
1109                         $n = $dbr->selectField(
1110                                 'revision_comment_temp', 'COUNT(*)', [ 'revcomment_rev' => $revid ], __METHOD__
1111                         );
1112                         $this->assertEquals( 0, $n, 'no entry in revision_comment_temp after deletion' );
1113
1114                         // Copied or upgraded the comment_id, as applicable
1115                         $ar_comment_id = $dbr->selectField(
1116                                 'archive',
1117                                 'ar_comment_id',
1118                                 [ 'ar_rev_id' => $revid ],
1119                                 __METHOD__
1120                         );
1121                         if ( $writeStage > MIGRATION_OLD ) {
1122                                 $this->assertSame( $comment_id, $ar_comment_id );
1123                         } else {
1124                                 $this->assertNotEquals( 0, $ar_comment_id );
1125                         }
1126                 }
1127
1128                 // Copied rev_comment, if applicable
1129                 if ( $readStage <= MIGRATION_WRITE_BOTH && $writeStage <= MIGRATION_WRITE_BOTH ) {
1130                         $ar_comment = $dbr->selectField(
1131                                 'archive',
1132                                 'ar_comment',
1133                                 [ 'ar_rev_id' => $revid ],
1134                                 __METHOD__
1135                         );
1136                         $this->assertSame( 'testing', $ar_comment );
1137                 }
1138         }
1139
1140         public function provideCommentMigrationOnDeletion() {
1141                 return [
1142                         [ MIGRATION_OLD, MIGRATION_OLD ],
1143                         [ MIGRATION_OLD, MIGRATION_WRITE_BOTH ],
1144                         [ MIGRATION_OLD, MIGRATION_WRITE_NEW ],
1145                         [ MIGRATION_WRITE_BOTH, MIGRATION_OLD ],
1146                         [ MIGRATION_WRITE_BOTH, MIGRATION_WRITE_BOTH ],
1147                         [ MIGRATION_WRITE_BOTH, MIGRATION_WRITE_NEW ],
1148                         [ MIGRATION_WRITE_BOTH, MIGRATION_NEW ],
1149                         [ MIGRATION_WRITE_NEW, MIGRATION_WRITE_BOTH ],
1150                         [ MIGRATION_WRITE_NEW, MIGRATION_WRITE_NEW ],
1151                         [ MIGRATION_WRITE_NEW, MIGRATION_NEW ],
1152                         [ MIGRATION_NEW, MIGRATION_WRITE_BOTH ],
1153                         [ MIGRATION_NEW, MIGRATION_WRITE_NEW ],
1154                         [ MIGRATION_NEW, MIGRATION_NEW ],
1155                 ];
1156         }
1157
1158         /**
1159          * @covers WikiPage::updateCategoryCounts
1160          */
1161         public function testUpdateCategoryCounts() {
1162                 $page = new WikiPage( Title::newFromText( __METHOD__ ) );
1163
1164                 // Add an initial category
1165                 $page->updateCategoryCounts( [ 'A' ], [], 0 );
1166
1167                 $this->assertEquals( 1, Category::newFromName( 'A' )->getPageCount() );
1168                 $this->assertEquals( 0, Category::newFromName( 'B' )->getPageCount() );
1169                 $this->assertEquals( 0, Category::newFromName( 'C' )->getPageCount() );
1170
1171                 // Add a new category
1172                 $page->updateCategoryCounts( [ 'B' ], [], 0 );
1173
1174                 $this->assertEquals( 1, Category::newFromName( 'A' )->getPageCount() );
1175                 $this->assertEquals( 1, Category::newFromName( 'B' )->getPageCount() );
1176                 $this->assertEquals( 0, Category::newFromName( 'C' )->getPageCount() );
1177
1178                 // Add and remove a category
1179                 $page->updateCategoryCounts( [ 'C' ], [ 'A' ], 0 );
1180
1181                 $this->assertEquals( 0, Category::newFromName( 'A' )->getPageCount() );
1182                 $this->assertEquals( 1, Category::newFromName( 'B' )->getPageCount() );
1183                 $this->assertEquals( 1, Category::newFromName( 'C' )->getPageCount() );
1184         }
1185
1186 }