tests/phpunit/includes/Storage/RevisionStoreDbTestBase.php

   1 <?php
   2
   3 namespace MediaWiki\Tests\Storage;
   4
   5 use CommentStoreComment;
   6 use Exception;
   7 use HashBagOStuff;
   8 use InvalidArgumentException;
   9 use Language;
  10 use MediaWiki\Linker\LinkTarget;
  11 use MediaWiki\MediaWikiServices;
  12 use MediaWiki\Storage\BlobStoreFactory;
  13 use MediaWiki\Storage\IncompleteRevisionException;
  14 use MediaWiki\Storage\MutableRevisionRecord;
  15 use MediaWiki\Storage\RevisionRecord;
  16 use MediaWiki\Storage\RevisionStore;
  17 use MediaWiki\Storage\SlotRecord;
  18 use MediaWiki\Storage\SqlBlobStore;
  19 use MediaWikiTestCase;
  20 use PHPUnit_Framework_MockObject_MockObject;
  21 use Revision;
  22 use TestUserRegistry;
  23 use Title;
  24 use WANObjectCache;
  25 use Wikimedia\Rdbms\Database;
  26 use Wikimedia\Rdbms\DatabaseSqlite;
  27 use Wikimedia\Rdbms\FakeResultWrapper;
  28 use Wikimedia\Rdbms\LoadBalancer;
  29 use Wikimedia\Rdbms\TransactionProfiler;
  30 use WikiPage;
  31 use WikitextContent;
  32
  33 /**
  34  * @group Database
  35  * @group RevisionStore
  36  */
  37 abstract class RevisionStoreDbTestBase extends MediaWikiTestCase {
  38
  39         /**
  40          * @return int
  41          */
  42         abstract protected function getMcrMigrationStage();
  43
  44         /**
  45          * @return bool
  46          */
  47         protected function getContentHandlerUseDB() {
  48                 return true;
  49         }
  50
  51         /**
  52          * @return string[]
  53          */
  54         abstract protected function getMcrTablesToReset();
  55
  56         public function needsDB() {
  57                 return true;
  58         }
  59
  60         public function setUp() {
  61                 parent::setUp();
  62                 $this->tablesUsed[] = 'archive';
  63                 $this->tablesUsed[] = 'page';
  64                 $this->tablesUsed[] = 'revision';
  65                 $this->tablesUsed[] = 'comment';
  66
  67                 $this->tablesUsed += $this->getMcrTablesToReset();
  68
  69                 $this->setMwGlobals(
  70                         'wgMultiContentRevisionSchemaMigrationStage',
  71                         $this->getMcrMigrationStage()
  72                 );
  73
  74                 $this->setMwGlobals(
  75                         'wgContentHandlerUseDB',
  76                         $this->getContentHandlerUseDB()
  77                 );
  78
  79                 $this->overrideMwServices();
  80         }
  81
  82         /**
  83          * @return LoadBalancer|PHPUnit_Framework_MockObject_MockObject
  84          */
  85         private function getLoadBalancerMock( array $server ) {
  86                 $lb = $this->getMockBuilder( LoadBalancer::class )
  87                         ->setMethods( [ 'reallyOpenConnection' ] )
  88                         ->setConstructorArgs( [ [ 'servers' => [ $server ] ] ] )
  89                         ->getMock();
  90
  91                 $lb->method( 'reallyOpenConnection' )->willReturnCallback(
  92                         function ( array $server, $dbNameOverride ) {
  93                                 return $this->getDatabaseMock( $server );
  94                         }
  95                 );
  96
  97                 return $lb;
  98         }
  99
 100         /**
 101          * @return Database|PHPUnit_Framework_MockObject_MockObject
 102          */
 103         private function getDatabaseMock( array $params ) {
 104                 $db = $this->getMockBuilder( DatabaseSqlite::class )
 105                         ->setMethods( [ 'select', 'doQuery', 'open', 'closeConnection', 'isOpen' ] )
 106                         ->setConstructorArgs( [ $params ] )
 107                         ->getMock();
 108
 109                 $db->method( 'select' )->willReturn( new FakeResultWrapper( [] ) );
 110                 $db->method( 'isOpen' )->willReturn( true );
 111
 112                 return $db;
 113         }
 114
 115         public function provideDomainCheck() {
 116                 yield [ false, 'test', '' ];
 117                 yield [ 'test', 'test', '' ];
 118
 119                 yield [ false, 'test', 'foo_' ];
 120                 yield [ 'test-foo_', 'test', 'foo_' ];
 121
 122                 yield [ false, 'dash-test', '' ];
 123                 yield [ 'dash-test', 'dash-test', '' ];
 124
 125                 yield [ false, 'underscore_test', 'foo_' ];
 126                 yield [ 'underscore_test-foo_', 'underscore_test', 'foo_' ];
 127         }
 128
 129         /**
 130          * @dataProvider provideDomainCheck
 131          * @covers \MediaWiki\Storage\RevisionStore::checkDatabaseWikiId
 132          */
 133         public function testDomainCheck( $wikiId, $dbName, $dbPrefix ) {
 134                 $this->setMwGlobals(
 135                         [
 136                                 'wgDBname' => $dbName,
 137                                 'wgDBprefix' => $dbPrefix,
 138                         ]
 139                 );
 140
 141                 $loadBalancer = $this->getLoadBalancerMock(
 142                         [
 143                                 'host' => '*dummy*',
 144                                 'dbDirectory' => '*dummy*',
 145                                 'user' => 'test',
 146                                 'password' => 'test',
 147                                 'flags' => 0,
 148                                 'variables' => [],
 149                                 'schema' => '',
 150                                 'cliMode' => true,
 151                                 'agent' => '',
 152                                 'load' => 100,
 153                                 'profiler' => null,
 154                                 'trxProfiler' => new TransactionProfiler(),
 155                                 'connLogger' => new \Psr\Log\NullLogger(),
 156                                 'queryLogger' => new \Psr\Log\NullLogger(),
 157                                 'errorLogger' => function () {
 158                                 },
 159                                 'deprecationLogger' => function () {
 160                                 },
 161                                 'type' => 'test',
 162                                 'dbname' => $dbName,
 163                                 'tablePrefix' => $dbPrefix,
 164                         ]
 165                 );
 166                 $db = $loadBalancer->getConnection( DB_REPLICA );
 167
 168                 /** @var SqlBlobStore $blobStore */
 169                 $blobStore = $this->getMockBuilder( SqlBlobStore::class )
 170                         ->disableOriginalConstructor()
 171                         ->getMock();
 172
 173                 $store = new RevisionStore(
 174                         $loadBalancer,
 175                         $blobStore,
 176                         new WANObjectCache( [ 'cache' => new HashBagOStuff() ] ),
 177                         MediaWikiServices::getInstance()->getCommentStore(),
 178                         MediaWikiServices::getInstance()->getActorMigration(),
 179                         $wikiId
 180                 );
 181
 182                 $count = $store->countRevisionsByPageId( $db, 0 );
 183
 184                 // Dummy check to make PhpUnit happy. We are really only interested in
 185                 // countRevisionsByPageId not failing due to the DB domain check.
 186                 $this->assertSame( 0, $count );
 187         }
 188
 189         private function assertLinkTargetsEqual( LinkTarget $l1, LinkTarget $l2 ) {
 190                 $this->assertEquals( $l1->getDBkey(), $l2->getDBkey() );
 191                 $this->assertEquals( $l1->getNamespace(), $l2->getNamespace() );
 192                 $this->assertEquals( $l1->getFragment(), $l2->getFragment() );
 193                 $this->assertEquals( $l1->getInterwiki(), $l2->getInterwiki() );
 194         }
 195
 196         private function assertRevisionRecordsEqual( RevisionRecord $r1, RevisionRecord $r2 ) {
 197                 $this->assertEquals( $r1->getUser()->getName(), $r2->getUser()->getName() );
 198                 $this->assertEquals( $r1->getUser()->getId(), $r2->getUser()->getId() );
 199                 $this->assertEquals( $r1->getComment(), $r2->getComment() );
 200                 $this->assertEquals( $r1->getPageAsLinkTarget(), $r2->getPageAsLinkTarget() );
 201                 $this->assertEquals( $r1->getTimestamp(), $r2->getTimestamp() );
 202                 $this->assertEquals( $r1->getVisibility(), $r2->getVisibility() );
 203                 $this->assertEquals( $r1->getSha1(), $r2->getSha1() );
 204                 $this->assertEquals( $r1->getParentId(), $r2->getParentId() );
 205                 $this->assertEquals( $r1->getSize(), $r2->getSize() );
 206                 $this->assertEquals( $r1->getPageId(), $r2->getPageId() );
 207                 $this->assertEquals( $r1->getSlotRoles(), $r2->getSlotRoles() );
 208                 $this->assertEquals( $r1->getWikiId(), $r2->getWikiId() );
 209                 $this->assertEquals( $r1->isMinor(), $r2->isMinor() );
 210                 foreach ( $r1->getSlotRoles() as $role ) {
 211                         $this->assertSlotRecordsEqual( $r1->getSlot( $role ), $r2->getSlot( $role ) );
 212                         $this->assertTrue( $r1->getContent( $role )->equals( $r2->getContent( $role ) ) );
 213                 }
 214                 foreach ( [
 215                         RevisionRecord::DELETED_TEXT,
 216                         RevisionRecord::DELETED_COMMENT,
 217                         RevisionRecord::DELETED_USER,
 218                         RevisionRecord::DELETED_RESTRICTED,
 219                 ] as $field ) {
 220                         $this->assertEquals( $r1->isDeleted( $field ), $r2->isDeleted( $field ) );
 221                 }
 222         }
 223
 224         private function assertSlotRecordsEqual( SlotRecord $s1, SlotRecord $s2 ) {
 225                 $this->assertSame( $s1->getRole(), $s2->getRole() );
 226                 $this->assertSame( $s1->getModel(), $s2->getModel() );
 227                 $this->assertSame( $s1->getFormat(), $s2->getFormat() );
 228                 $this->assertSame( $s1->getSha1(), $s2->getSha1() );
 229                 $this->assertSame( $s1->getSize(), $s2->getSize() );
 230                 $this->assertTrue( $s1->getContent()->equals( $s2->getContent() ) );
 231
 232                 $s1->hasRevision() ? $this->assertSame( $s1->getRevision(), $s2->getRevision() ) : null;
 233                 $s1->hasAddress() ? $this->assertSame( $s1->hasAddress(), $s2->hasAddress() ) : null;
 234         }
 235
 236         private function assertRevisionCompleteness( RevisionRecord $r ) {
 237                 foreach ( $r->getSlotRoles() as $role ) {
 238                         $this->assertSlotCompleteness( $r, $r->getSlot( $role ) );
 239                 }
 240         }
 241
 242         private function assertSlotCompleteness( RevisionRecord $r, SlotRecord $slot ) {
 243                 $this->assertTrue( $slot->hasAddress() );
 244                 $this->assertSame( $r->getId(), $slot->getRevision() );
 245         }
 246
 247         /**
 248          * @param mixed[] $details
 249          *
 250          * @return RevisionRecord
 251          */
 252         private function getRevisionRecordFromDetailsArray( $title, $details = [] ) {
 253                 // Convert some values that can't be provided by dataProviders
 254                 $page = WikiPage::factory( $title );
 255                 if ( isset( $details['user'] ) && $details['user'] === true ) {
 256                         $details['user'] = $this->getTestUser()->getUser();
 257                 }
 258                 if ( isset( $details['page'] ) && $details['page'] === true ) {
 259                         $details['page'] = $page->getId();
 260                 }
 261                 if ( isset( $details['parent'] ) && $details['parent'] === true ) {
 262                         $details['parent'] = $page->getLatest();
 263                 }
 264
 265                 // Create the RevisionRecord with any available data
 266                 $rev = new MutableRevisionRecord( $title );
 267                 isset( $details['slot'] ) ? $rev->setSlot( $details['slot'] ) : null;
 268                 isset( $details['parent'] ) ? $rev->setParentId( $details['parent'] ) : null;
 269                 isset( $details['page'] ) ? $rev->setPageId( $details['page'] ) : null;
 270                 isset( $details['size'] ) ? $rev->setSize( $details['size'] ) : null;
 271                 isset( $details['sha1'] ) ? $rev->setSha1( $details['sha1'] ) : null;
 272                 isset( $details['comment'] ) ? $rev->setComment( $details['comment'] ) : null;
 273                 isset( $details['timestamp'] ) ? $rev->setTimestamp( $details['timestamp'] ) : null;
 274                 isset( $details['minor'] ) ? $rev->setMinorEdit( $details['minor'] ) : null;
 275                 isset( $details['user'] ) ? $rev->setUser( $details['user'] ) : null;
 276                 isset( $details['visibility'] ) ? $rev->setVisibility( $details['visibility'] ) : null;
 277                 isset( $details['id'] ) ? $rev->setId( $details['id'] ) : null;
 278
 279                 return $rev;
 280         }
 281
 282         public function provideInsertRevisionOn_successes() {
 283                 yield 'Bare minimum revision insertion' => [
 284                         Title::newFromText( 'UTPage' ),
 285                         [
 286                                 'slot' => SlotRecord::newUnsaved( 'main', new WikitextContent( 'Chicken' ) ),
 287                                 'parent' => true,
 288                                 'comment' => $this->getRandomCommentStoreComment(),
 289                                 'timestamp' => '20171117010101',
 290                                 'user' => true,
 291                         ],
 292                 ];
 293                 yield 'Detailed revision insertion' => [
 294                         Title::newFromText( 'UTPage' ),
 295                         [
 296                                 'slot' => SlotRecord::newUnsaved( 'main', new WikitextContent( 'Chicken' ) ),
 297                                 'parent' => true,
 298                                 'page' => true,
 299                                 'comment' => $this->getRandomCommentStoreComment(),
 300                                 'timestamp' => '20171117010101',
 301                                 'user' => true,
 302                                 'minor' => true,
 303                                 'visibility' => RevisionRecord::DELETED_RESTRICTED,
 304                         ],
 305                 ];
 306         }
 307
 308         private function getRandomCommentStoreComment() {
 309                 return CommentStoreComment::newUnsavedComment( __METHOD__ . '.' . rand( 0, 1000 ) );
 310         }
 311
 312         /**
 313          * @dataProvider provideInsertRevisionOn_successes
 314          * @covers \MediaWiki\Storage\RevisionStore::insertRevisionOn
 315          */
 316         public function testInsertRevisionOn_successes(
 317                 Title $title,
 318                 array $revDetails = []
 319         ) {
 320                 $rev = $this->getRevisionRecordFromDetailsArray( $title, $revDetails );
 321
 322                 $this->overrideMwServices();
 323                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 324                 $return = $store->insertRevisionOn( $rev, wfGetDB( DB_MASTER ) );
 325
 326                 $this->assertLinkTargetsEqual( $title, $return->getPageAsLinkTarget() );
 327                 $this->assertRevisionRecordsEqual( $rev, $return );
 328                 $this->assertRevisionCompleteness( $return );
 329                 $this->assertRevisionExistsInDatabase( $return );
 330         }
 331
 332         protected function assertRevisionExistsInDatabase( RevisionRecord $rev ) {
 333                 $this->assertSelect(
 334                         'revision', [ 'count(*)' ], [ 'rev_id' => $rev->getId() ], [ [ '1' ] ]
 335                 );
 336         }
 337
 338         /**
 339          * @param SlotRecord $a
 340          * @param SlotRecord $b
 341          */
 342         protected function assertSameSlotContent( SlotRecord $a, SlotRecord $b ) {
 343                 // Assert that the same blob address has been used.
 344                 $this->assertSame( $a->getAddress(), $b->getAddress() );
 345         }
 346
 347         /**
 348          * @covers \MediaWiki\Storage\RevisionStore::insertRevisionOn
 349          */
 350         public function testInsertRevisionOn_blobAddressExists() {
 351                 $title = Title::newFromText( 'UTPage' );
 352                 $revDetails = [
 353                         'slot' => SlotRecord::newUnsaved( 'main', new WikitextContent( 'Chicken' ) ),
 354                         'parent' => true,
 355                         'comment' => $this->getRandomCommentStoreComment(),
 356                         'timestamp' => '20171117010101',
 357                         'user' => true,
 358                 ];
 359
 360                 $this->overrideMwServices();
 361                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 362
 363                 // Insert the first revision
 364                 $revOne = $this->getRevisionRecordFromDetailsArray( $title, $revDetails );
 365                 $firstReturn = $store->insertRevisionOn( $revOne, wfGetDB( DB_MASTER ) );
 366                 $this->assertLinkTargetsEqual( $title, $firstReturn->getPageAsLinkTarget() );
 367                 $this->assertRevisionRecordsEqual( $revOne, $firstReturn );
 368
 369                 // Insert a second revision inheriting the same blob address
 370                 $revDetails['slot'] = SlotRecord::newInherited( $firstReturn->getSlot( 'main' ) );
 371                 $revTwo = $this->getRevisionRecordFromDetailsArray( $title, $revDetails );
 372                 $secondReturn = $store->insertRevisionOn( $revTwo, wfGetDB( DB_MASTER ) );
 373                 $this->assertLinkTargetsEqual( $title, $secondReturn->getPageAsLinkTarget() );
 374                 $this->assertRevisionRecordsEqual( $revTwo, $secondReturn );
 375
 376                 $firstMainSlot = $firstReturn->getSlot( 'main' );
 377                 $secondMainSlot = $secondReturn->getSlot( 'main' );
 378
 379                 $this->assertSameSlotContent( $firstMainSlot, $secondMainSlot );
 380
 381                 // And that different revisions have been created.
 382                 $this->assertNotSame( $firstReturn->getId(), $secondReturn->getId() );
 383
 384                 // Make sure the slot rows reference the correct revision
 385                 $this->assertSame( $firstReturn->getId(), $firstMainSlot->getRevision() );
 386                 $this->assertSame( $secondReturn->getId(), $secondMainSlot->getRevision() );
 387         }
 388
 389         public function provideInsertRevisionOn_failures() {
 390                 yield 'no slot' => [
 391                         Title::newFromText( 'UTPage' ),
 392                         [
 393                                 'comment' => $this->getRandomCommentStoreComment(),
 394                                 'timestamp' => '20171117010101',
 395                                 'user' => true,
 396                         ],
 397                         new InvalidArgumentException( 'At least one slot needs to be defined!' )
 398                 ];
 399                 yield 'slot that is not main slot' => [
 400                         Title::newFromText( 'UTPage' ),
 401                         [
 402                                 'slot' => SlotRecord::newUnsaved( 'lalala', new WikitextContent( 'Chicken' ) ),
 403                                 'comment' => $this->getRandomCommentStoreComment(),
 404                                 'timestamp' => '20171117010101',
 405                                 'user' => true,
 406                         ],
 407                         new InvalidArgumentException( 'Only the main slot is supported for now!' )
 408                 ];
 409                 yield 'no timestamp' => [
 410                         Title::newFromText( 'UTPage' ),
 411                         [
 412                                 'slot' => SlotRecord::newUnsaved( 'main', new WikitextContent( 'Chicken' ) ),
 413                                 'comment' => $this->getRandomCommentStoreComment(),
 414                                 'user' => true,
 415                         ],
 416                         new IncompleteRevisionException( 'timestamp field must not be NULL!' )
 417                 ];
 418                 yield 'no comment' => [
 419                         Title::newFromText( 'UTPage' ),
 420                         [
 421                                 'slot' => SlotRecord::newUnsaved( 'main', new WikitextContent( 'Chicken' ) ),
 422                                 'timestamp' => '20171117010101',
 423                                 'user' => true,
 424                         ],
 425                         new IncompleteRevisionException( 'comment must not be NULL!' )
 426                 ];
 427                 yield 'no user' => [
 428                         Title::newFromText( 'UTPage' ),
 429                         [
 430                                 'slot' => SlotRecord::newUnsaved( 'main', new WikitextContent( 'Chicken' ) ),
 431                                 'comment' => $this->getRandomCommentStoreComment(),
 432                                 'timestamp' => '20171117010101',
 433                         ],
 434                         new IncompleteRevisionException( 'user must not be NULL!' )
 435                 ];
 436         }
 437
 438         /**
 439          * @dataProvider provideInsertRevisionOn_failures
 440          * @covers \MediaWiki\Storage\RevisionStore::insertRevisionOn
 441          */
 442         public function testInsertRevisionOn_failures(
 443                 Title $title,
 444                 array $revDetails = [],
 445                 Exception $exception
 446         ) {
 447                 $rev = $this->getRevisionRecordFromDetailsArray( $title, $revDetails );
 448
 449                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 450
 451                 $this->setExpectedException(
 452                         get_class( $exception ),
 453                         $exception->getMessage(),
 454                         $exception->getCode()
 455                 );
 456                 $store->insertRevisionOn( $rev, wfGetDB( DB_MASTER ) );
 457         }
 458
 459         public function provideNewNullRevision() {
 460                 yield [
 461                         Title::newFromText( 'UTPage_notAutoCreated' ),
 462                         CommentStoreComment::newUnsavedComment( __METHOD__ . ' comment1' ),
 463                         true,
 464                 ];
 465                 yield [
 466                         Title::newFromText( 'UTPage_notAutoCreated' ),
 467                         CommentStoreComment::newUnsavedComment( __METHOD__ . ' comment2', [ 'a' => 1 ] ),
 468                         false,
 469                 ];
 470         }
 471
 472         /**
 473          * @dataProvider provideNewNullRevision
 474          * @covers \MediaWiki\Storage\RevisionStore::newNullRevision
 475          */
 476         public function testNewNullRevision( Title $title, $comment, $minor ) {
 477                 $this->overrideMwServices();
 478
 479                 $page = WikiPage::factory( $title );
 480                 $status = $page->doEditContent(
 481                         new WikitextContent( __METHOD__ ),
 482                         __METHOD__,
 483                         0,
 484                         false
 485                 );
 486                 /** @var Revision $rev */
 487                 $rev = $status->value['revision'];
 488
 489                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 490                 $user = TestUserRegistry::getMutableTestUser( __METHOD__ )->getUser();
 491
 492                 $parent = $store->getRevisionById( $rev->getId() );
 493                 $record = $store->newNullRevision(
 494                         wfGetDB( DB_MASTER ),
 495                         $title,
 496                         $comment,
 497                         $minor,
 498                         $user
 499                 );
 500
 501                 $this->assertEquals( $title->getNamespace(), $record->getPageAsLinkTarget()->getNamespace() );
 502                 $this->assertEquals( $title->getDBkey(), $record->getPageAsLinkTarget()->getDBkey() );
 503                 $this->assertEquals( $comment, $record->getComment() );
 504                 $this->assertEquals( $minor, $record->isMinor() );
 505                 $this->assertEquals( $user->getName(), $record->getUser()->getName() );
 506                 $this->assertEquals( $parent->getId(), $record->getParentId() );
 507
 508                 $parentSlot = $parent->getSlot( 'main' );
 509                 $slot = $record->getSlot( 'main' );
 510
 511                 $this->assertTrue( $slot->isInherited(), 'isInherited' );
 512                 $this->assertSame( $parentSlot->getOrigin(), $slot->getOrigin(), 'getOrigin' );
 513                 $this->assertSameSlotContent( $parentSlot, $slot );
 514         }
 515
 516         /**
 517          * @covers \MediaWiki\Storage\RevisionStore::newNullRevision
 518          */
 519         public function testNewNullRevision_nonExistingTitle() {
 520                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 521                 $record = $store->newNullRevision(
 522                         wfGetDB( DB_MASTER ),
 523                         Title::newFromText( __METHOD__ . '.iDontExist!' ),
 524                         CommentStoreComment::newUnsavedComment( __METHOD__ . ' comment' ),
 525                         false,
 526                         TestUserRegistry::getMutableTestUser( __METHOD__ )->getUser()
 527                 );
 528                 $this->assertNull( $record );
 529         }
 530
 531         /**
 532          * @covers \MediaWiki\Storage\RevisionStore::getRcIdIfUnpatrolled
 533          */
 534         public function testGetRcIdIfUnpatrolled_returnsRecentChangesId() {
 535                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
 536                 $status = $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ );
 537                 /** @var Revision $rev */
 538                 $rev = $status->value['revision'];
 539
 540                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 541                 $revisionRecord = $store->getRevisionById( $rev->getId() );
 542                 $result = $store->getRcIdIfUnpatrolled( $revisionRecord );
 543
 544                 $this->assertGreaterThan( 0, $result );
 545                 $this->assertSame(
 546                         $page->getRevision()->getRecentChange()->getAttribute( 'rc_id' ),
 547                         $result
 548                 );
 549         }
 550
 551         /**
 552          * @covers \MediaWiki\Storage\RevisionStore::getRcIdIfUnpatrolled
 553          */
 554         public function testGetRcIdIfUnpatrolled_returnsZeroIfPatrolled() {
 555                 // This assumes that sysops are auto patrolled
 556                 $sysop = $this->getTestSysop()->getUser();
 557                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
 558                 $status = $page->doEditContent(
 559                         new WikitextContent( __METHOD__ ),
 560                         __METHOD__,
 561                         0,
 562                         false,
 563                         $sysop
 564                 );
 565                 /** @var Revision $rev */
 566                 $rev = $status->value['revision'];
 567
 568                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 569                 $revisionRecord = $store->getRevisionById( $rev->getId() );
 570                 $result = $store->getRcIdIfUnpatrolled( $revisionRecord );
 571
 572                 $this->assertSame( 0, $result );
 573         }
 574
 575         /**
 576          * @covers \MediaWiki\Storage\RevisionStore::getRecentChange
 577          */
 578         public function testGetRecentChange() {
 579                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
 580                 $content = new WikitextContent( __METHOD__ );
 581                 $status = $page->doEditContent( $content, __METHOD__ );
 582                 /** @var Revision $rev */
 583                 $rev = $status->value['revision'];
 584
 585                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 586                 $revRecord = $store->getRevisionById( $rev->getId() );
 587                 $recentChange = $store->getRecentChange( $revRecord );
 588
 589                 $this->assertEquals( $rev->getId(), $recentChange->getAttribute( 'rc_this_oldid' ) );
 590                 $this->assertEquals( $rev->getRecentChange(), $recentChange );
 591         }
 592
 593         /**
 594          * @covers \MediaWiki\Storage\RevisionStore::getRevisionById
 595          */
 596         public function testGetRevisionById() {
 597                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
 598                 $content = new WikitextContent( __METHOD__ );
 599                 $status = $page->doEditContent( $content, __METHOD__ );
 600                 /** @var Revision $rev */
 601                 $rev = $status->value['revision'];
 602
 603                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 604                 $revRecord = $store->getRevisionById( $rev->getId() );
 605
 606                 $this->assertSame( $rev->getId(), $revRecord->getId() );
 607                 $this->assertTrue( $revRecord->getSlot( 'main' )->getContent()->equals( $content ) );
 608                 $this->assertSame( __METHOD__, $revRecord->getComment()->text );
 609         }
 610
 611         /**
 612          * @covers \MediaWiki\Storage\RevisionStore::getRevisionByTitle
 613          */
 614         public function testGetRevisionByTitle() {
 615                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
 616                 $content = new WikitextContent( __METHOD__ );
 617                 $status = $page->doEditContent( $content, __METHOD__ );
 618                 /** @var Revision $rev */
 619                 $rev = $status->value['revision'];
 620
 621                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 622                 $revRecord = $store->getRevisionByTitle( $page->getTitle() );
 623
 624                 $this->assertSame( $rev->getId(), $revRecord->getId() );
 625                 $this->assertTrue( $revRecord->getSlot( 'main' )->getContent()->equals( $content ) );
 626                 $this->assertSame( __METHOD__, $revRecord->getComment()->text );
 627         }
 628
 629         /**
 630          * @covers \MediaWiki\Storage\RevisionStore::getRevisionByPageId
 631          */
 632         public function testGetRevisionByPageId() {
 633                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
 634                 $content = new WikitextContent( __METHOD__ );
 635                 $status = $page->doEditContent( $content, __METHOD__ );
 636                 /** @var Revision $rev */
 637                 $rev = $status->value['revision'];
 638
 639                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 640                 $revRecord = $store->getRevisionByPageId( $page->getId() );
 641
 642                 $this->assertSame( $rev->getId(), $revRecord->getId() );
 643                 $this->assertTrue( $revRecord->getSlot( 'main' )->getContent()->equals( $content ) );
 644                 $this->assertSame( __METHOD__, $revRecord->getComment()->text );
 645         }
 646
 647         /**
 648          * @covers \MediaWiki\Storage\RevisionStore::getRevisionByTimestamp
 649          */
 650         public function testGetRevisionByTimestamp() {
 651                 // Make sure there is 1 second between the last revision and the rev we create...
 652                 // Otherwise we might not get the correct revision and the test may fail...
 653                 // :(
 654                 sleep( 1 );
 655                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
 656                 $content = new WikitextContent( __METHOD__ );
 657                 $status = $page->doEditContent( $content, __METHOD__ );
 658                 /** @var Revision $rev */
 659                 $rev = $status->value['revision'];
 660
 661                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 662                 $revRecord = $store->getRevisionByTimestamp(
 663                         $page->getTitle(),
 664                         $rev->getTimestamp()
 665                 );
 666
 667                 $this->assertSame( $rev->getId(), $revRecord->getId() );
 668                 $this->assertTrue( $revRecord->getSlot( 'main' )->getContent()->equals( $content ) );
 669                 $this->assertSame( __METHOD__, $revRecord->getComment()->text );
 670         }
 671
 672         protected function revisionToRow( Revision $rev ) {
 673                 $page = WikiPage::factory( $rev->getTitle() );
 674
 675                 return (object)[
 676                         'rev_id' => (string)$rev->getId(),
 677                         'rev_page' => (string)$rev->getPage(),
 678                         'rev_text_id' => (string)$rev->getTextId(),
 679                         'rev_timestamp' => $this->db->timestamp( $rev->getTimestamp() ),
 680                         'rev_user_text' => (string)$rev->getUserText(),
 681                         'rev_user' => (string)$rev->getUser(),
 682                         'rev_minor_edit' => $rev->isMinor() ? '1' : '0',
 683                         'rev_deleted' => (string)$rev->getVisibility(),
 684                         'rev_len' => (string)$rev->getSize(),
 685                         'rev_parent_id' => (string)$rev->getParentId(),
 686                         'rev_sha1' => (string)$rev->getSha1(),
 687                         'rev_comment_text' => $rev->getComment(),
 688                         'rev_comment_data' => null,
 689                         'rev_comment_cid' => null,
 690                         'rev_content_format' => $rev->getContentFormat(),
 691                         'rev_content_model' => $rev->getContentModel(),
 692                         'page_namespace' => (string)$page->getTitle()->getNamespace(),
 693                         'page_title' => $page->getTitle()->getDBkey(),
 694                         'page_id' => (string)$page->getId(),
 695                         'page_latest' => (string)$page->getLatest(),
 696                         'page_is_redirect' => $page->isRedirect() ? '1' : '0',
 697                         'page_len' => (string)$page->getContent()->getSize(),
 698                         'user_name' => (string)$rev->getUserText(),
 699                 ];
 700         }
 701
 702         private function assertRevisionRecordMatchesRevision(
 703                 Revision $rev,
 704                 RevisionRecord $record
 705         ) {
 706                 $this->assertSame( $rev->getId(), $record->getId() );
 707                 $this->assertSame( $rev->getPage(), $record->getPageId() );
 708                 $this->assertSame( $rev->getTimestamp(), $record->getTimestamp() );
 709                 $this->assertSame( $rev->getUserText(), $record->getUser()->getName() );
 710                 $this->assertSame( $rev->getUser(), $record->getUser()->getId() );
 711                 $this->assertSame( $rev->isMinor(), $record->isMinor() );
 712                 $this->assertSame( $rev->getVisibility(), $record->getVisibility() );
 713                 $this->assertSame( $rev->getSize(), $record->getSize() );
 714                 /**
 715                  * @note As of MW 1.31, the database schema allows the parent ID to be
 716                  * NULL to indicate that it is unknown.
 717                  */
 718                 $expectedParent = $rev->getParentId();
 719                 if ( $expectedParent === null ) {
 720                         $expectedParent = 0;
 721                 }
 722                 $this->assertSame( $expectedParent, $record->getParentId() );
 723                 $this->assertSame( $rev->getSha1(), $record->getSha1() );
 724                 $this->assertSame( $rev->getComment(), $record->getComment()->text );
 725                 $this->assertSame( $rev->getContentFormat(), $record->getContent( 'main' )->getDefaultFormat() );
 726                 $this->assertSame( $rev->getContentModel(), $record->getContent( 'main' )->getModel() );
 727                 $this->assertLinkTargetsEqual( $rev->getTitle(), $record->getPageAsLinkTarget() );
 728         }
 729
 730         /**
 731          * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow
 732          * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow_1_29
 733          */
 734         public function testNewRevisionFromRow_anonEdit() {
 735                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
 736                 $text = __METHOD__ . 'a-ä';
 737                 /** @var Revision $rev */
 738                 $rev = $page->doEditContent(
 739                         new WikitextContent( $text ),
 740                         __METHOD__ . 'a'
 741                 )->value['revision'];
 742
 743                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 744                 $record = $store->newRevisionFromRow(
 745                         $this->revisionToRow( $rev ),
 746                         [],
 747                         $page->getTitle()
 748                 );
 749                 $this->assertRevisionRecordMatchesRevision( $rev, $record );
 750                 $this->assertSame( $text, $rev->getContent()->serialize() );
 751         }
 752
 753         /**
 754          * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow
 755          * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow_1_29
 756          */
 757         public function testNewRevisionFromRow_anonEdit_legacyEncoding() {
 758                 $this->setMwGlobals( 'wgLegacyEncoding', 'windows-1252' );
 759                 $this->overrideMwServices();
 760                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
 761                 $text = __METHOD__ . 'a-ä';
 762                 /** @var Revision $rev */
 763                 $rev = $page->doEditContent(
 764                         new WikitextContent( $text ),
 765                         __METHOD__. 'a'
 766                 )->value['revision'];
 767
 768                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 769                 $record = $store->newRevisionFromRow(
 770                         $this->revisionToRow( $rev ),
 771                         [],
 772                         $page->getTitle()
 773                 );
 774                 $this->assertRevisionRecordMatchesRevision( $rev, $record );
 775                 $this->assertSame( $text, $rev->getContent()->serialize() );
 776         }
 777
 778         /**
 779          * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow
 780          * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow_1_29
 781          */
 782         public function testNewRevisionFromRow_userEdit() {
 783                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
 784                 $text = __METHOD__ . 'b-ä';
 785                 /** @var Revision $rev */
 786                 $rev = $page->doEditContent(
 787                         new WikitextContent( $text ),
 788                         __METHOD__ . 'b',
 789                         0,
 790                         false,
 791                         $this->getTestUser()->getUser()
 792                 )->value['revision'];
 793
 794                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 795                 $record = $store->newRevisionFromRow(
 796                         $this->revisionToRow( $rev ),
 797                         [],
 798                         $page->getTitle()
 799                 );
 800                 $this->assertRevisionRecordMatchesRevision( $rev, $record );
 801                 $this->assertSame( $text, $rev->getContent()->serialize() );
 802         }
 803
 804         /**
 805          * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromArchiveRow
 806          */
 807         public function testNewRevisionFromArchiveRow() {
 808                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 809                 $title = Title::newFromText( __METHOD__ );
 810                 $text = __METHOD__ . '-bä';
 811                 $page = WikiPage::factory( $title );
 812                 /** @var Revision $orig */
 813                 $orig = $page->doEditContent( new WikitextContent( $text ), __METHOD__ )
 814                         ->value['revision'];
 815                 $page->doDeleteArticle( __METHOD__ );
 816
 817                 $db = wfGetDB( DB_MASTER );
 818                 $arQuery = $store->getArchiveQueryInfo();
 819                 $res = $db->select(
 820                         $arQuery['tables'], $arQuery['fields'], [ 'ar_rev_id' => $orig->getId() ],
 821                         __METHOD__, [], $arQuery['joins']
 822                 );
 823                 $this->assertTrue( is_object( $res ), 'query failed' );
 824
 825                 $row = $res->fetchObject();
 826                 $res->free();
 827                 $record = $store->newRevisionFromArchiveRow( $row );
 828
 829                 $this->assertRevisionRecordMatchesRevision( $orig, $record );
 830                 $this->assertSame( $text, $record->getContent( 'main' )->serialize() );
 831         }
 832
 833         /**
 834          * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromArchiveRow
 835          */
 836         public function testNewRevisionFromArchiveRow_legacyEncoding() {
 837                 $this->setMwGlobals( 'wgLegacyEncoding', 'windows-1252' );
 838                 $this->overrideMwServices();
 839                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 840                 $title = Title::newFromText( __METHOD__ );
 841                 $text = __METHOD__ . '-bä';
 842                 $page = WikiPage::factory( $title );
 843                 /** @var Revision $orig */
 844                 $orig = $page->doEditContent( new WikitextContent( $text ), __METHOD__ )
 845                         ->value['revision'];
 846                 $page->doDeleteArticle( __METHOD__ );
 847
 848                 $db = wfGetDB( DB_MASTER );
 849                 $arQuery = $store->getArchiveQueryInfo();
 850                 $res = $db->select(
 851                         $arQuery['tables'], $arQuery['fields'], [ 'ar_rev_id' => $orig->getId() ],
 852                         __METHOD__, [], $arQuery['joins']
 853                 );
 854                 $this->assertTrue( is_object( $res ), 'query failed' );
 855
 856                 $row = $res->fetchObject();
 857                 $res->free();
 858                 $record = $store->newRevisionFromArchiveRow( $row );
 859
 860                 $this->assertRevisionRecordMatchesRevision( $orig, $record );
 861                 $this->assertSame( $text, $record->getContent( 'main' )->serialize() );
 862         }
 863
 864         /**
 865          * @covers \MediaWiki\Storage\RevisionStore::loadRevisionFromId
 866          */
 867         public function testLoadRevisionFromId() {
 868                 $title = Title::newFromText( __METHOD__ );
 869                 $page = WikiPage::factory( $title );
 870                 /** @var Revision $rev */
 871                 $rev = $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ )
 872                         ->value['revision'];
 873
 874                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 875                 $result = $store->loadRevisionFromId( wfGetDB( DB_MASTER ), $rev->getId() );
 876                 $this->assertRevisionRecordMatchesRevision( $rev, $result );
 877         }
 878
 879         /**
 880          * @covers \MediaWiki\Storage\RevisionStore::loadRevisionFromPageId
 881          */
 882         public function testLoadRevisionFromPageId() {
 883                 $title = Title::newFromText( __METHOD__ );
 884                 $page = WikiPage::factory( $title );
 885                 /** @var Revision $rev */
 886                 $rev = $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ )
 887                         ->value['revision'];
 888
 889                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 890                 $result = $store->loadRevisionFromPageId( wfGetDB( DB_MASTER ), $page->getId() );
 891                 $this->assertRevisionRecordMatchesRevision( $rev, $result );
 892         }
 893
 894         /**
 895          * @covers \MediaWiki\Storage\RevisionStore::loadRevisionFromTitle
 896          */
 897         public function testLoadRevisionFromTitle() {
 898                 $title = Title::newFromText( __METHOD__ );
 899                 $page = WikiPage::factory( $title );
 900                 /** @var Revision $rev */
 901                 $rev = $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ )
 902                         ->value['revision'];
 903
 904                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 905                 $result = $store->loadRevisionFromTitle( wfGetDB( DB_MASTER ), $title );
 906                 $this->assertRevisionRecordMatchesRevision( $rev, $result );
 907         }
 908
 909         /**
 910          * @covers \MediaWiki\Storage\RevisionStore::loadRevisionFromTimestamp
 911          */
 912         public function testLoadRevisionFromTimestamp() {
 913                 $title = Title::newFromText( __METHOD__ );
 914                 $page = WikiPage::factory( $title );
 915                 /** @var Revision $revOne */
 916                 $revOne = $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ )
 917                         ->value['revision'];
 918                 // Sleep to ensure different timestamps... )(evil)
 919                 sleep( 1 );
 920                 /** @var Revision $revTwo */
 921                 $revTwo = $page->doEditContent( new WikitextContent( __METHOD__ . 'a' ), '' )
 922                         ->value['revision'];
 923
 924                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 925                 $this->assertNull(
 926                         $store->loadRevisionFromTimestamp( wfGetDB( DB_MASTER ), $title, '20150101010101' )
 927                 );
 928                 $this->assertSame(
 929                         $revOne->getId(),
 930                         $store->loadRevisionFromTimestamp(
 931                                 wfGetDB( DB_MASTER ),
 932                                 $title,
 933                                 $revOne->getTimestamp()
 934                         )->getId()
 935                 );
 936                 $this->assertSame(
 937                         $revTwo->getId(),
 938                         $store->loadRevisionFromTimestamp(
 939                                 wfGetDB( DB_MASTER ),
 940                                 $title,
 941                                 $revTwo->getTimestamp()
 942                         )->getId()
 943                 );
 944         }
 945
 946         /**
 947          * @covers \MediaWiki\Storage\RevisionStore::listRevisionSizes
 948          */
 949         public function testGetParentLengths() {
 950                 $page = WikiPage::factory( Title::newFromText( __METHOD__ ) );
 951                 /** @var Revision $revOne */
 952                 $revOne = $page->doEditContent(
 953                         new WikitextContent( __METHOD__ ), __METHOD__
 954                 )->value['revision'];
 955                 /** @var Revision $revTwo */
 956                 $revTwo = $page->doEditContent(
 957                         new WikitextContent( __METHOD__ . '2' ), __METHOD__
 958                 )->value['revision'];
 959
 960                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 961                 $this->assertSame(
 962                         [
 963                                 $revOne->getId() => strlen( __METHOD__ ),
 964                         ],
 965                         $store->listRevisionSizes(
 966                                 wfGetDB( DB_MASTER ),
 967                                 [ $revOne->getId() ]
 968                         )
 969                 );
 970                 $this->assertSame(
 971                         [
 972                                 $revOne->getId() => strlen( __METHOD__ ),
 973                                 $revTwo->getId() => strlen( __METHOD__ ) + 1,
 974                         ],
 975                         $store->listRevisionSizes(
 976                                 wfGetDB( DB_MASTER ),
 977                                 [ $revOne->getId(), $revTwo->getId() ]
 978                         )
 979                 );
 980         }
 981
 982         /**
 983          * @covers \MediaWiki\Storage\RevisionStore::getPreviousRevision
 984          */
 985         public function testGetPreviousRevision() {
 986                 $page = WikiPage::factory( Title::newFromText( __METHOD__ ) );
 987                 /** @var Revision $revOne */
 988                 $revOne = $page->doEditContent(
 989                         new WikitextContent( __METHOD__ ), __METHOD__
 990                 )->value['revision'];
 991                 /** @var Revision $revTwo */
 992                 $revTwo = $page->doEditContent(
 993                         new WikitextContent( __METHOD__ . '2' ), __METHOD__
 994                 )->value['revision'];
 995
 996                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 997                 $this->assertNull(
 998                         $store->getPreviousRevision( $store->getRevisionById( $revOne->getId() ) )
 999                 );
1000                 $this->assertSame(
1001                         $revOne->getId(),
1002                         $store->getPreviousRevision( $store->getRevisionById( $revTwo->getId() ) )->getId()
1003                 );
1004         }
1005
1006         /**
1007          * @covers \MediaWiki\Storage\RevisionStore::getNextRevision
1008          */
1009         public function testGetNextRevision() {
1010                 $page = WikiPage::factory( Title::newFromText( __METHOD__ ) );
1011                 /** @var Revision $revOne */
1012                 $revOne = $page->doEditContent(
1013                         new WikitextContent( __METHOD__ ), __METHOD__
1014                 )->value['revision'];
1015                 /** @var Revision $revTwo */
1016                 $revTwo = $page->doEditContent(
1017                         new WikitextContent( __METHOD__ . '2' ), __METHOD__
1018                 )->value['revision'];
1019
1020                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1021                 $this->assertSame(
1022                         $revTwo->getId(),
1023                         $store->getNextRevision( $store->getRevisionById( $revOne->getId() ) )->getId()
1024                 );
1025                 $this->assertNull(
1026                         $store->getNextRevision( $store->getRevisionById( $revTwo->getId() ) )
1027                 );
1028         }
1029
1030         /**
1031          * @covers \MediaWiki\Storage\RevisionStore::getTimestampFromId
1032          */
1033         public function testGetTimestampFromId_found() {
1034                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
1035                 /** @var Revision $rev */
1036                 $rev = $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ )
1037                         ->value['revision'];
1038
1039                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1040                 $result = $store->getTimestampFromId(
1041                         $page->getTitle(),
1042                         $rev->getId()
1043                 );
1044
1045                 $this->assertSame( $rev->getTimestamp(), $result );
1046         }
1047
1048         /**
1049          * @covers \MediaWiki\Storage\RevisionStore::getTimestampFromId
1050          */
1051         public function testGetTimestampFromId_notFound() {
1052                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
1053                 /** @var Revision $rev */
1054                 $rev = $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ )
1055                         ->value['revision'];
1056
1057                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1058                 $result = $store->getTimestampFromId(
1059                         $page->getTitle(),
1060                         $rev->getId() + 1
1061                 );
1062
1063                 $this->assertFalse( $result );
1064         }
1065
1066         /**
1067          * @covers \MediaWiki\Storage\RevisionStore::countRevisionsByPageId
1068          */
1069         public function testCountRevisionsByPageId() {
1070                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1071                 $page = WikiPage::factory( Title::newFromText( __METHOD__ ) );
1072
1073                 $this->assertSame(
1074                         0,
1075                         $store->countRevisionsByPageId( wfGetDB( DB_MASTER ), $page->getId() )
1076                 );
1077                 $page->doEditContent( new WikitextContent( 'a' ), 'a' );
1078                 $this->assertSame(
1079                         1,
1080                         $store->countRevisionsByPageId( wfGetDB( DB_MASTER ), $page->getId() )
1081                 );
1082                 $page->doEditContent( new WikitextContent( 'b' ), 'b' );
1083                 $this->assertSame(
1084                         2,
1085                         $store->countRevisionsByPageId( wfGetDB( DB_MASTER ), $page->getId() )
1086                 );
1087         }
1088
1089         /**
1090          * @covers \MediaWiki\Storage\RevisionStore::countRevisionsByTitle
1091          */
1092         public function testCountRevisionsByTitle() {
1093                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1094                 $page = WikiPage::factory( Title::newFromText( __METHOD__ ) );
1095
1096                 $this->assertSame(
1097                         0,
1098                         $store->countRevisionsByTitle( wfGetDB( DB_MASTER ), $page->getTitle() )
1099                 );
1100                 $page->doEditContent( new WikitextContent( 'a' ), 'a' );
1101                 $this->assertSame(
1102                         1,
1103                         $store->countRevisionsByTitle( wfGetDB( DB_MASTER ), $page->getTitle() )
1104                 );
1105                 $page->doEditContent( new WikitextContent( 'b' ), 'b' );
1106                 $this->assertSame(
1107                         2,
1108                         $store->countRevisionsByTitle( wfGetDB( DB_MASTER ), $page->getTitle() )
1109                 );
1110         }
1111
1112         /**
1113          * @covers \MediaWiki\Storage\RevisionStore::userWasLastToEdit
1114          */
1115         public function testUserWasLastToEdit_false() {
1116                 $sysop = $this->getTestSysop()->getUser();
1117                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
1118                 $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ );
1119
1120                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1121                 $result = $store->userWasLastToEdit(
1122                         wfGetDB( DB_MASTER ),
1123                         $page->getId(),
1124                         $sysop->getId(),
1125                         '20160101010101'
1126                 );
1127                 $this->assertFalse( $result );
1128         }
1129
1130         /**
1131          * @covers \MediaWiki\Storage\RevisionStore::userWasLastToEdit
1132          */
1133         public function testUserWasLastToEdit_true() {
1134                 $startTime = wfTimestampNow();
1135                 $sysop = $this->getTestSysop()->getUser();
1136                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
1137                 $page->doEditContent(
1138                         new WikitextContent( __METHOD__ ),
1139                         __METHOD__,
1140                         0,
1141                         false,
1142                         $sysop
1143                 );
1144
1145                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1146                 $result = $store->userWasLastToEdit(
1147                         wfGetDB( DB_MASTER ),
1148                         $page->getId(),
1149                         $sysop->getId(),
1150                         $startTime
1151                 );
1152                 $this->assertTrue( $result );
1153         }
1154
1155         /**
1156          * @covers \MediaWiki\Storage\RevisionStore::getKnownCurrentRevision
1157          */
1158         public function testGetKnownCurrentRevision() {
1159                 $page = WikiPage::factory( Title::newFromText( 'UTPage' ) );
1160                 /** @var Revision $rev */
1161                 $rev = $page->doEditContent(
1162                         new WikitextContent( __METHOD__ . 'b' ),
1163                         __METHOD__ . 'b',
1164                         0,
1165                         false,
1166                         $this->getTestUser()->getUser()
1167                 )->value['revision'];
1168
1169                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1170                 $record = $store->getKnownCurrentRevision(
1171                         $page->getTitle(),
1172                         $rev->getId()
1173                 );
1174
1175                 $this->assertRevisionRecordMatchesRevision( $rev, $record );
1176         }
1177
1178         public function provideNewMutableRevisionFromArray() {
1179                 yield 'Basic array, with page & id' => [
1180                         [
1181                                 'id' => 2,
1182                                 'page' => 1,
1183                                 'text_id' => 2,
1184                                 'timestamp' => '20171017114835',
1185                                 'user_text' => '111.0.1.2',
1186                                 'user' => 0,
1187                                 'minor_edit' => false,
1188                                 'deleted' => 0,
1189                                 'len' => 46,
1190                                 'parent_id' => 1,
1191                                 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1192                                 'comment' => 'Goat Comment!',
1193                                 'content_format' => 'text/x-wiki',
1194                                 'content_model' => 'wikitext',
1195                         ]
1196                 ];
1197                 yield 'Basic array, content object' => [
1198                         [
1199                                 'id' => 2,
1200                                 'page' => 1,
1201                                 'timestamp' => '20171017114835',
1202                                 'user_text' => '111.0.1.2',
1203                                 'user' => 0,
1204                                 'minor_edit' => false,
1205                                 'deleted' => 0,
1206                                 'len' => 46,
1207                                 'parent_id' => 1,
1208                                 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1209                                 'comment' => 'Goat Comment!',
1210                                 'content' => new WikitextContent( 'Some Content' ),
1211                         ]
1212                 ];
1213                 yield 'Basic array, serialized text' => [
1214                         [
1215                                 'id' => 2,
1216                                 'page' => 1,
1217                                 'timestamp' => '20171017114835',
1218                                 'user_text' => '111.0.1.2',
1219                                 'user' => 0,
1220                                 'minor_edit' => false,
1221                                 'deleted' => 0,
1222                                 'len' => 46,
1223                                 'parent_id' => 1,
1224                                 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1225                                 'comment' => 'Goat Comment!',
1226                                 'text' => ( new WikitextContent( 'Söme Content' ) )->serialize(),
1227                         ]
1228                 ];
1229                 yield 'Basic array, serialized text, utf-8 flags' => [
1230                         [
1231                                 'id' => 2,
1232                                 'page' => 1,
1233                                 'timestamp' => '20171017114835',
1234                                 'user_text' => '111.0.1.2',
1235                                 'user' => 0,
1236                                 'minor_edit' => false,
1237                                 'deleted' => 0,
1238                                 'len' => 46,
1239                                 'parent_id' => 1,
1240                                 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1241                                 'comment' => 'Goat Comment!',
1242                                 'text' => ( new WikitextContent( 'Söme Content' ) )->serialize(),
1243                                 'flags' => 'utf-8',
1244                         ]
1245                 ];
1246                 yield 'Basic array, with title' => [
1247                         [
1248                                 'title' => Title::newFromText( 'SomeText' ),
1249                                 'text_id' => 2,
1250                                 'timestamp' => '20171017114835',
1251                                 'user_text' => '111.0.1.2',
1252                                 'user' => 0,
1253                                 'minor_edit' => false,
1254                                 'deleted' => 0,
1255                                 'len' => 46,
1256                                 'parent_id' => 1,
1257                                 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1258                                 'comment' => 'Goat Comment!',
1259                                 'content_format' => 'text/x-wiki',
1260                                 'content_model' => 'wikitext',
1261                         ]
1262                 ];
1263                 yield 'Basic array, no user field' => [
1264                         [
1265                                 'id' => 2,
1266                                 'page' => 1,
1267                                 'text_id' => 2,
1268                                 'timestamp' => '20171017114835',
1269                                 'user_text' => '111.0.1.3',
1270                                 'minor_edit' => false,
1271                                 'deleted' => 0,
1272                                 'len' => 46,
1273                                 'parent_id' => 1,
1274                                 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1275                                 'comment' => 'Goat Comment!',
1276                                 'content_format' => 'text/x-wiki',
1277                                 'content_model' => 'wikitext',
1278                         ]
1279                 ];
1280         }
1281
1282         /**
1283          * @dataProvider provideNewMutableRevisionFromArray
1284          * @covers \MediaWiki\Storage\RevisionStore::newMutableRevisionFromArray
1285          */
1286         public function testNewMutableRevisionFromArray( array $array ) {
1287                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1288
1289                 $result = $store->newMutableRevisionFromArray( $array );
1290
1291                 if ( isset( $array['id'] ) ) {
1292                         $this->assertSame( $array['id'], $result->getId() );
1293                 }
1294                 if ( isset( $array['page'] ) ) {
1295                         $this->assertSame( $array['page'], $result->getPageId() );
1296                 }
1297                 $this->assertSame( $array['timestamp'], $result->getTimestamp() );
1298                 $this->assertSame( $array['user_text'], $result->getUser()->getName() );
1299                 if ( isset( $array['user'] ) ) {
1300                         $this->assertSame( $array['user'], $result->getUser()->getId() );
1301                 }
1302                 $this->assertSame( (bool)$array['minor_edit'], $result->isMinor() );
1303                 $this->assertSame( $array['deleted'], $result->getVisibility() );
1304                 $this->assertSame( $array['len'], $result->getSize() );
1305                 $this->assertSame( $array['parent_id'], $result->getParentId() );
1306                 $this->assertSame( $array['sha1'], $result->getSha1() );
1307                 $this->assertSame( $array['comment'], $result->getComment()->text );
1308                 if ( isset( $array['content'] ) ) {
1309                         $this->assertTrue(
1310                                 $result->getSlot( 'main' )->getContent()->equals( $array['content'] )
1311                         );
1312                 } elseif ( isset( $array['text'] ) ) {
1313                         $this->assertSame( $array['text'], $result->getSlot( 'main' )->getContent()->serialize() );
1314                 } else {
1315                         $this->assertSame(
1316                                 $array['content_format'],
1317                                 $result->getSlot( 'main' )->getContent()->getDefaultFormat()
1318                         );
1319                         $this->assertSame( $array['content_model'], $result->getSlot( 'main' )->getModel() );
1320                 }
1321         }
1322
1323         /**
1324          * @dataProvider provideNewMutableRevisionFromArray
1325          * @covers \MediaWiki\Storage\RevisionStore::newMutableRevisionFromArray
1326          */
1327         public function testNewMutableRevisionFromArray_legacyEncoding( array $array ) {
1328                 $cache = new WANObjectCache( [ 'cache' => new HashBagOStuff() ] );
1329                 $lb = MediaWikiServices::getInstance()->getDBLoadBalancer();
1330                 $blobStore = new SqlBlobStore( $lb, $cache );
1331                 $blobStore->setLegacyEncoding( 'windows-1252', Language::factory( 'en' ) );
1332
1333                 $factory = $this->getMockBuilder( BlobStoreFactory::class )
1334                         ->setMethods( [ 'newBlobStore', 'newSqlBlobStore' ] )
1335                         ->disableOriginalConstructor()
1336                         ->getMock();
1337                 $factory->expects( $this->any() )
1338                         ->method( 'newBlobStore' )
1339                         ->willReturn( $blobStore );
1340                 $factory->expects( $this->any() )
1341                         ->method( 'newSqlBlobStore' )
1342                         ->willReturn( $blobStore );
1343
1344                 $this->setService( 'BlobStoreFactory', $factory );
1345
1346                 $this->testNewMutableRevisionFromArray( $array );
1347         }
1348
1349         protected function getDefaultQueryFields( $returnTextIdField = true ) {
1350                 $fields = [
1351                         'rev_id',
1352                         'rev_page',
1353                         'rev_timestamp',
1354                         'rev_minor_edit',
1355                         'rev_deleted',
1356                         'rev_len',
1357                         'rev_parent_id',
1358                         'rev_sha1',
1359                 ];
1360                 if ( $returnTextIdField ) {
1361                         $fields[] = 'rev_text_id';
1362                 }
1363                 return $fields;
1364         }
1365
1366         protected function getCommentQueryFields() {
1367                 return [
1368                         'rev_comment_text' => 'rev_comment',
1369                         'rev_comment_data' => 'NULL',
1370                         'rev_comment_cid' => 'NULL',
1371                 ];
1372         }
1373
1374         protected function getActorQueryFields() {
1375                 return [
1376                         'rev_user' => 'rev_user',
1377                         'rev_user_text' => 'rev_user_text',
1378                         'rev_actor' => 'NULL',
1379                 ];
1380         }
1381
1382         protected function getContentHandlerQueryFields() {
1383                 return [
1384                         'rev_content_format',
1385                         'rev_content_model',
1386                 ];
1387         }
1388
1389         abstract public function provideGetQueryInfo();
1390
1391         /**
1392          * @dataProvider provideGetQueryInfo
1393          * @covers \MediaWiki\Storage\RevisionStore::getQueryInfo
1394          */
1395         public function testGetQueryInfo( $options, $expected ) {
1396                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1397
1398                 $queryInfo = $store->getQueryInfo( $options );
1399
1400                 $this->assertArrayEqualsIgnoringIntKeyOrder(
1401                         $expected['tables'],
1402                         $queryInfo['tables']
1403                 );
1404                 $this->assertArrayEqualsIgnoringIntKeyOrder(
1405                         $expected['fields'],
1406                         $queryInfo['fields']
1407                 );
1408                 $this->assertArrayEqualsIgnoringIntKeyOrder(
1409                         $expected['joins'],
1410                         $queryInfo['joins']
1411                 );
1412         }
1413
1414         protected function getDefaultArchiveFields( $returnTextFields = true ) {
1415                 $fields = [
1416                         'ar_id',
1417                         'ar_page_id',
1418                         'ar_namespace',
1419                         'ar_title',
1420                         'ar_rev_id',
1421                         'ar_timestamp',
1422                         'ar_minor_edit',
1423                         'ar_deleted',
1424                         'ar_len',
1425                         'ar_parent_id',
1426                         'ar_sha1',
1427                 ];
1428                 if ( $returnTextFields ) {
1429                         $fields[] = 'ar_text_id';
1430                 }
1431                 return $fields;
1432         }
1433
1434         abstract public function provideGetArchiveQueryInfo();
1435
1436         /**
1437          * @dataProvider provideGetArchiveQueryInfo
1438          * @covers \MediaWiki\Storage\RevisionStore::getArchiveQueryInfo
1439          */
1440         public function testGetArchiveQueryInfo( $expected ) {
1441                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1442
1443                 $archiveQueryInfo = $store->getArchiveQueryInfo();
1444
1445                 $this->assertArrayEqualsIgnoringIntKeyOrder(
1446                         $expected['tables'],
1447                         $archiveQueryInfo['tables']
1448                 );
1449
1450                 $this->assertArrayEqualsIgnoringIntKeyOrder(
1451                         $expected['fields'],
1452                         $archiveQueryInfo['fields']
1453                 );
1454
1455                 $this->assertArrayEqualsIgnoringIntKeyOrder(
1456                         $expected['joins'],
1457                         $archiveQueryInfo['joins']
1458                 );
1459         }
1460
1461         /**
1462          * Assert that the two arrays passed are equal, ignoring the order of the values that integer
1463          * keys.
1464          *
1465          * Note: Failures of this assertion can be slightly confusing as the arrays are actually
1466          * split into a string key array and an int key array before assertions occur.
1467          *
1468          * @param array $expected
1469          * @param array $actual
1470          */
1471         private function assertArrayEqualsIgnoringIntKeyOrder( array $expected, array $actual ) {
1472                 $this->objectAssociativeSort( $expected );
1473                 $this->objectAssociativeSort( $actual );
1474
1475                 // Separate the int key values from the string key values so that assertion failures are
1476                 // easier to understand.
1477                 $expectedIntKeyValues = [];
1478                 $actualIntKeyValues = [];
1479
1480                 // Remove all int keys and re add them at the end after sorting by value
1481                 // This will result in all int keys being in the same order with same ints at the end of
1482                 // the array
1483                 foreach ( $expected as $key => $value ) {
1484                         if ( is_int( $key ) ) {
1485                                 unset( $expected[$key] );
1486                                 $expectedIntKeyValues[] = $value;
1487                         }
1488                 }
1489                 foreach ( $actual as $key => $value ) {
1490                         if ( is_int( $key ) ) {
1491                                 unset( $actual[$key] );
1492                                 $actualIntKeyValues[] = $value;
1493                         }
1494                 }
1495
1496                 $this->assertArrayEquals( $expected, $actual, false, true );
1497                 $this->assertArrayEquals( $expectedIntKeyValues, $actualIntKeyValues, false, true );
1498         }
1499
1500 }