tests/phpunit/includes/Revision/RevisionStoreDbTestBase.php

   1 <?php
   2
   3 namespace MediaWiki\Tests\Revision;
   4
   5 use CommentStoreComment;
   6 use Content;
   7 use Exception;
   8 use HashBagOStuff;
   9 use InvalidArgumentException;
  10 use Language;
  11 use MediaWiki\Linker\LinkTarget;
  12 use MediaWiki\MediaWikiServices;
  13 use MediaWiki\Revision\IncompleteRevisionException;
  14 use MediaWiki\Revision\MutableRevisionRecord;
  15 use MediaWiki\Revision\RevisionArchiveRecord;
  16 use MediaWiki\Revision\RevisionRecord;
  17 use MediaWiki\Revision\RevisionStoreRecord;
  18 use MediaWiki\Revision\RevisionSlots;
  19 use MediaWiki\Revision\RevisionStore;
  20 use MediaWiki\Revision\SlotRecord;
  21 use MediaWiki\Storage\BlobStoreFactory;
  22 use MediaWiki\Storage\SqlBlobStore;
  23 use MediaWiki\User\UserIdentityValue;
  24 use MediaWikiTestCase;
  25 use PHPUnit_Framework_MockObject_MockObject;
  26 use Revision;
  27 use TestUserRegistry;
  28 use Title;
  29 use WANObjectCache;
  30 use Wikimedia\Rdbms\Database;
  31 use Wikimedia\Rdbms\DatabaseDomain;
  32 use Wikimedia\Rdbms\DatabaseSqlite;
  33 use Wikimedia\Rdbms\FakeResultWrapper;
  34 use Wikimedia\Rdbms\LoadBalancer;
  35 use Wikimedia\Rdbms\TransactionProfiler;
  36 use WikiPage;
  37 use WikitextContent;
  38
  39 /**
  40  * @group Database
  41  * @group RevisionStore
  42  */
  43 abstract class RevisionStoreDbTestBase extends MediaWikiTestCase {
  44
  45         /**
  46          * @var Title
  47          */
  48         private $testPageTitle;
  49
  50         /**
  51          * @var WikiPage
  52          */
  53         private $testPage;
  54
  55         /**
  56          * @return int
  57          */
  58         abstract protected function getMcrMigrationStage();
  59
  60         /**
  61          * @return bool
  62          */
  63         protected function getContentHandlerUseDB() {
  64                 return true;
  65         }
  66
  67         /**
  68          * @return string[]
  69          */
  70         abstract protected function getMcrTablesToReset();
  71
  72         public function setUp() {
  73                 parent::setUp();
  74                 $this->tablesUsed[] = 'archive';
  75                 $this->tablesUsed[] = 'page';
  76                 $this->tablesUsed[] = 'revision';
  77                 $this->tablesUsed[] = 'comment';
  78
  79                 $this->tablesUsed += $this->getMcrTablesToReset();
  80
  81                 $this->setMwGlobals( [
  82                         'wgMultiContentRevisionSchemaMigrationStage' => $this->getMcrMigrationStage(),
  83                         'wgContentHandlerUseDB' => $this->getContentHandlerUseDB(),
  84                         'wgActorTableSchemaMigrationStage' => SCHEMA_COMPAT_NEW,
  85                 ] );
  86         }
  87
  88         protected function addCoreDBData() {
  89                 // Blank out. This would fail with a modified schema, and we don't need it.
  90         }
  91
  92         /**
  93          * @return Title
  94          */
  95         protected function getTestPageTitle() {
  96                 if ( $this->testPageTitle ) {
  97                         return $this->testPageTitle;
  98                 }
  99
 100                 $this->testPageTitle = Title::newFromText( 'UTPage-' . __CLASS__ );
 101                 return $this->testPageTitle;
 102         }
 103
 104         /**
 105          * @return WikiPage
 106          */
 107         protected function getTestPage() {
 108                 if ( $this->testPage ) {
 109                         return $this->testPage;
 110                 }
 111
 112                 $title = $this->getTestPageTitle();
 113                 $this->testPage = WikiPage::factory( $title );
 114
 115                 if ( !$this->testPage->exists() ) {
 116                         // Make sure we don't write to the live db.
 117                         $this->ensureMockDatabaseConnection( wfGetDB( DB_MASTER ) );
 118
 119                         $user = static::getTestSysop()->getUser();
 120
 121                         $this->testPage->doEditContent(
 122                                 new WikitextContent( 'UTContent-' . __CLASS__ ),
 123                                 'UTPageSummary-' . __CLASS__,
 124                                 EDIT_NEW | EDIT_SUPPRESS_RC,
 125                                 false,
 126                                 $user
 127                         );
 128                 }
 129
 130                 return $this->testPage;
 131         }
 132
 133         /**
 134          * @return LoadBalancer|PHPUnit_Framework_MockObject_MockObject
 135          */
 136         private function getLoadBalancerMock( array $server ) {
 137                 $domain = new DatabaseDomain( $server['dbname'], null, $server['tablePrefix'] );
 138
 139                 $lb = $this->getMockBuilder( LoadBalancer::class )
 140                         ->setMethods( [ 'reallyOpenConnection' ] )
 141                         ->setConstructorArgs( [
 142                                 [ 'servers' => [ $server ], 'localDomain' => $domain ]
 143                         ] )
 144                         ->getMock();
 145
 146                 $lb->method( 'reallyOpenConnection' )->willReturnCallback(
 147                         function ( array $server, $dbNameOverride ) {
 148                                 return $this->getDatabaseMock( $server );
 149                         }
 150                 );
 151
 152                 return $lb;
 153         }
 154
 155         /**
 156          * @return Database|PHPUnit_Framework_MockObject_MockObject
 157          */
 158         private function getDatabaseMock( array $params ) {
 159                 $db = $this->getMockBuilder( DatabaseSqlite::class )
 160                         ->setMethods( [ 'select', 'doQuery', 'open', 'closeConnection', 'isOpen' ] )
 161                         ->setConstructorArgs( [ $params ] )
 162                         ->getMock();
 163
 164                 $db->method( 'select' )->willReturn( new FakeResultWrapper( [] ) );
 165                 $db->method( 'isOpen' )->willReturn( true );
 166
 167                 return $db;
 168         }
 169
 170         public function provideDomainCheck() {
 171                 yield [ false, 'test', '' ];
 172                 yield [ 'test', 'test', '' ];
 173
 174                 yield [ false, 'test', 'foo_' ];
 175                 yield [ 'test-foo_', 'test', 'foo_' ];
 176
 177                 yield [ false, 'dash-test', '' ];
 178                 yield [ 'dash-test', 'dash-test', '' ];
 179
 180                 yield [ false, 'underscore_test', 'foo_' ];
 181                 yield [ 'underscore_test-foo_', 'underscore_test', 'foo_' ];
 182         }
 183
 184         /**
 185          * @dataProvider provideDomainCheck
 186          * @covers \MediaWiki\Revision\RevisionStore::checkDatabaseDomain
 187          */
 188         public function testDomainCheck( $wikiId, $dbName, $dbPrefix ) {
 189                 $this->setMwGlobals(
 190                         [
 191                                 'wgDBname' => $dbName,
 192                                 'wgDBprefix' => $dbPrefix,
 193                         ]
 194                 );
 195
 196                 $loadBalancer = $this->getLoadBalancerMock(
 197                         [
 198                                 'host' => '*dummy*',
 199                                 'dbDirectory' => '*dummy*',
 200                                 'user' => 'test',
 201                                 'password' => 'test',
 202                                 'flags' => 0,
 203                                 'variables' => [],
 204                                 'schema' => '',
 205                                 'cliMode' => true,
 206                                 'agent' => '',
 207                                 'load' => 100,
 208                                 'profiler' => null,
 209                                 'trxProfiler' => new TransactionProfiler(),
 210                                 'connLogger' => new \Psr\Log\NullLogger(),
 211                                 'queryLogger' => new \Psr\Log\NullLogger(),
 212                                 'errorLogger' => function () {
 213                                 },
 214                                 'deprecationLogger' => function () {
 215                                 },
 216                                 'type' => 'test',
 217                                 'dbname' => $dbName,
 218                                 'tablePrefix' => $dbPrefix,
 219                         ]
 220                 );
 221                 $db = $loadBalancer->getConnection( DB_REPLICA );
 222
 223                 /** @var SqlBlobStore $blobStore */
 224                 $blobStore = $this->getMockBuilder( SqlBlobStore::class )
 225                         ->disableOriginalConstructor()
 226                         ->getMock();
 227
 228                 $store = new RevisionStore(
 229                         $loadBalancer,
 230                         $blobStore,
 231                         new WANObjectCache( [ 'cache' => new HashBagOStuff() ] ),
 232                         MediaWikiServices::getInstance()->getCommentStore(),
 233                         MediaWikiServices::getInstance()->getContentModelStore(),
 234                         MediaWikiServices::getInstance()->getSlotRoleStore(),
 235                         MediaWikiServices::getInstance()->getSlotRoleRegistry(),
 236                         $this->getMcrMigrationStage(),
 237                         MediaWikiServices::getInstance()->getActorMigration(),
 238                         $wikiId
 239                 );
 240
 241                 $count = $store->countRevisionsByPageId( $db, 0 );
 242
 243                 // Dummy check to make PhpUnit happy. We are really only interested in
 244                 // countRevisionsByPageId not failing due to the DB domain check.
 245                 $this->assertSame( 0, $count );
 246         }
 247
 248         protected function assertLinkTargetsEqual( LinkTarget $l1, LinkTarget $l2 ) {
 249                 $this->assertEquals( $l1->getDBkey(), $l2->getDBkey() );
 250                 $this->assertEquals( $l1->getNamespace(), $l2->getNamespace() );
 251                 $this->assertEquals( $l1->getFragment(), $l2->getFragment() );
 252                 $this->assertEquals( $l1->getInterwiki(), $l2->getInterwiki() );
 253         }
 254
 255         protected function assertRevisionRecordsEqual( RevisionRecord $r1, RevisionRecord $r2 ) {
 256                 $this->assertEquals(
 257                         $r1->getPageAsLinkTarget()->getNamespace(),
 258                         $r2->getPageAsLinkTarget()->getNamespace()
 259                 );
 260
 261                 $this->assertEquals(
 262                         $r1->getPageAsLinkTarget()->getText(),
 263                         $r2->getPageAsLinkTarget()->getText()
 264                 );
 265
 266                 if ( $r1->getParentId() ) {
 267                         $this->assertEquals( $r1->getParentId(), $r2->getParentId() );
 268                 }
 269
 270                 $this->assertEquals( $r1->getUser()->getName(), $r2->getUser()->getName() );
 271                 $this->assertEquals( $r1->getUser()->getId(), $r2->getUser()->getId() );
 272                 $this->assertEquals( $r1->getComment(), $r2->getComment() );
 273                 $this->assertEquals( $r1->getTimestamp(), $r2->getTimestamp() );
 274                 $this->assertEquals( $r1->getVisibility(), $r2->getVisibility() );
 275                 $this->assertEquals( $r1->getSha1(), $r2->getSha1() );
 276                 $this->assertEquals( $r1->getSize(), $r2->getSize() );
 277                 $this->assertEquals( $r1->getPageId(), $r2->getPageId() );
 278                 $this->assertArrayEquals( $r1->getSlotRoles(), $r2->getSlotRoles() );
 279                 $this->assertEquals( $r1->getWikiId(), $r2->getWikiId() );
 280                 $this->assertEquals( $r1->isMinor(), $r2->isMinor() );
 281                 foreach ( $r1->getSlotRoles() as $role ) {
 282                         $this->assertSlotRecordsEqual( $r1->getSlot( $role ), $r2->getSlot( $role ) );
 283                         $this->assertTrue( $r1->getContent( $role )->equals( $r2->getContent( $role ) ) );
 284                 }
 285                 foreach ( [
 286                         RevisionRecord::DELETED_TEXT,
 287                         RevisionRecord::DELETED_COMMENT,
 288                         RevisionRecord::DELETED_USER,
 289                         RevisionRecord::DELETED_RESTRICTED,
 290                 ] as $field ) {
 291                         $this->assertEquals( $r1->isDeleted( $field ), $r2->isDeleted( $field ) );
 292                 }
 293         }
 294
 295         protected function assertSlotRecordsEqual( SlotRecord $s1, SlotRecord $s2 ) {
 296                 $this->assertSame( $s1->getRole(), $s2->getRole() );
 297                 $this->assertSame( $s1->getModel(), $s2->getModel() );
 298                 $this->assertSame( $s1->getFormat(), $s2->getFormat() );
 299                 $this->assertSame( $s1->getSha1(), $s2->getSha1() );
 300                 $this->assertSame( $s1->getSize(), $s2->getSize() );
 301                 $this->assertTrue( $s1->getContent()->equals( $s2->getContent() ) );
 302
 303                 $s1->hasRevision() ? $this->assertSame( $s1->getRevision(), $s2->getRevision() ) : null;
 304                 $s1->hasAddress() ? $this->assertSame( $s1->hasAddress(), $s2->hasAddress() ) : null;
 305         }
 306
 307         protected function assertRevisionCompleteness( RevisionRecord $r ) {
 308                 $this->assertTrue( $r->hasSlot( SlotRecord::MAIN ) );
 309                 $this->assertInstanceOf( SlotRecord::class, $r->getSlot( SlotRecord::MAIN ) );
 310                 $this->assertInstanceOf( Content::class, $r->getContent( SlotRecord::MAIN ) );
 311
 312                 foreach ( $r->getSlotRoles() as $role ) {
 313                         $this->assertSlotCompleteness( $r, $r->getSlot( $role ) );
 314                 }
 315         }
 316
 317         protected function assertSlotCompleteness( RevisionRecord $r, SlotRecord $slot ) {
 318                 $this->assertTrue( $slot->hasAddress() );
 319                 $this->assertSame( $r->getId(), $slot->getRevision() );
 320
 321                 $this->assertInstanceOf( Content::class, $slot->getContent() );
 322         }
 323
 324         /**
 325          * @param mixed[] $details
 326          *
 327          * @return RevisionRecord
 328          */
 329         private function getRevisionRecordFromDetailsArray( $details = [] ) {
 330                 // Convert some values that can't be provided by dataProviders
 331                 if ( isset( $details['user'] ) && $details['user'] === true ) {
 332                         $details['user'] = $this->getTestUser()->getUser();
 333                 }
 334                 if ( isset( $details['page'] ) && $details['page'] === true ) {
 335                         $details['page'] = $this->getTestPage()->getId();
 336                 }
 337                 if ( isset( $details['parent'] ) && $details['parent'] === true ) {
 338                         $details['parent'] = $this->getTestPage()->getLatest();
 339                 }
 340
 341                 // Create the RevisionRecord with any available data
 342                 $rev = new MutableRevisionRecord( $this->getTestPageTitle() );
 343                 isset( $details['slot'] ) ? $rev->setSlot( $details['slot'] ) : null;
 344                 isset( $details['parent'] ) ? $rev->setParentId( $details['parent'] ) : null;
 345                 isset( $details['page'] ) ? $rev->setPageId( $details['page'] ) : null;
 346                 isset( $details['size'] ) ? $rev->setSize( $details['size'] ) : null;
 347                 isset( $details['sha1'] ) ? $rev->setSha1( $details['sha1'] ) : null;
 348                 isset( $details['comment'] ) ? $rev->setComment( $details['comment'] ) : null;
 349                 isset( $details['timestamp'] ) ? $rev->setTimestamp( $details['timestamp'] ) : null;
 350                 isset( $details['minor'] ) ? $rev->setMinorEdit( $details['minor'] ) : null;
 351                 isset( $details['user'] ) ? $rev->setUser( $details['user'] ) : null;
 352                 isset( $details['visibility'] ) ? $rev->setVisibility( $details['visibility'] ) : null;
 353                 isset( $details['id'] ) ? $rev->setId( $details['id'] ) : null;
 354
 355                 if ( isset( $details['content'] ) ) {
 356                         foreach ( $details['content'] as $role => $content ) {
 357                                 $rev->setContent( $role, $content );
 358                         }
 359                 }
 360
 361                 return $rev;
 362         }
 363
 364         public function provideInsertRevisionOn_successes() {
 365                 yield 'Bare minimum revision insertion' => [
 366                         [
 367                                 'slot' => SlotRecord::newUnsaved( SlotRecord::MAIN, new WikitextContent( 'Chicken' ) ),
 368                                 'page' => true,
 369                                 'comment' => $this->getRandomCommentStoreComment(),
 370                                 'timestamp' => '20171117010101',
 371                                 'user' => true,
 372                         ],
 373                 ];
 374                 yield 'Detailed revision insertion' => [
 375                         [
 376                                 'slot' => SlotRecord::newUnsaved( SlotRecord::MAIN, new WikitextContent( 'Chicken' ) ),
 377                                 'parent' => true,
 378                                 'page' => true,
 379                                 'comment' => $this->getRandomCommentStoreComment(),
 380                                 'timestamp' => '20171117010101',
 381                                 'user' => true,
 382                                 'minor' => true,
 383                                 'visibility' => RevisionRecord::DELETED_RESTRICTED,
 384                         ],
 385                 ];
 386         }
 387
 388         protected function getRandomCommentStoreComment() {
 389                 return CommentStoreComment::newUnsavedComment( __METHOD__ . '.' . rand( 0, 1000 ) );
 390         }
 391
 392         /**
 393          * @dataProvider provideInsertRevisionOn_successes
 394          * @covers \MediaWiki\Revision\RevisionStore::insertRevisionOn
 395          * @covers \MediaWiki\Revision\RevisionStore::insertSlotRowOn
 396          * @covers \MediaWiki\Revision\RevisionStore::insertContentRowOn
 397          */
 398         public function testInsertRevisionOn_successes(
 399                 array $revDetails = []
 400         ) {
 401                 $title = $this->getTestPageTitle();
 402                 $rev = $this->getRevisionRecordFromDetailsArray( $revDetails );
 403
 404                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 405                 $return = $store->insertRevisionOn( $rev, wfGetDB( DB_MASTER ) );
 406
 407                 // is the new revision correct?
 408                 $this->assertRevisionCompleteness( $return );
 409                 $this->assertLinkTargetsEqual( $title, $return->getPageAsLinkTarget() );
 410                 $this->assertRevisionRecordsEqual( $rev, $return );
 411
 412                 // can we load it from the store?
 413                 $loaded = $store->getRevisionById( $return->getId() );
 414                 $this->assertRevisionCompleteness( $loaded );
 415                 $this->assertRevisionRecordsEqual( $return, $loaded );
 416
 417                 // can we find it directly in the database?
 418                 $this->assertRevisionExistsInDatabase( $return );
 419         }
 420
 421         protected function assertRevisionExistsInDatabase( RevisionRecord $rev ) {
 422                 $row = $this->revisionToRow( new Revision( $rev ), [] );
 423
 424                 // unset nulled fields
 425                 unset( $row->rev_content_model );
 426                 unset( $row->rev_content_format );
 427
 428                 // unset fake fields
 429                 unset( $row->rev_comment_text );
 430                 unset( $row->rev_comment_data );
 431                 unset( $row->rev_comment_cid );
 432                 unset( $row->rev_comment_id );
 433
 434                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 435                 $queryInfo = $store->getQueryInfo( [ 'user' ] );
 436
 437                 $row = get_object_vars( $row );
 438
 439                 // Use aliased fields from $queryInfo, e.g. rev_user
 440                 $keys = array_keys( $row );
 441                 $keys = array_combine( $keys, $keys );
 442                 $fields = array_intersect_key( $queryInfo['fields'], $keys ) + $keys;
 443
 444                 // assertSelect() fails unless the orders match.
 445                 ksort( $fields );
 446                 ksort( $row );
 447
 448                 $this->assertSelect(
 449                         $queryInfo['tables'],
 450                         $fields,
 451                         [ 'rev_id' => $rev->getId() ],
 452                         [ array_values( $row ) ],
 453                         [],
 454                         $queryInfo['joins']
 455                 );
 456         }
 457
 458         /**
 459          * @param SlotRecord $a
 460          * @param SlotRecord $b
 461          */
 462         protected function assertSameSlotContent( SlotRecord $a, SlotRecord $b ) {
 463                 // Assert that the same blob address has been used.
 464                 $this->assertSame( $a->getAddress(), $b->getAddress() );
 465         }
 466
 467         /**
 468          * @covers \MediaWiki\Revision\RevisionStore::insertRevisionOn
 469          */
 470         public function testInsertRevisionOn_blobAddressExists() {
 471                 $title = $this->getTestPageTitle();
 472                 $revDetails = [
 473                         'slot' => SlotRecord::newUnsaved( SlotRecord::MAIN, new WikitextContent( 'Chicken' ) ),
 474                         'parent' => true,
 475                         'comment' => $this->getRandomCommentStoreComment(),
 476                         'timestamp' => '20171117010101',
 477                         'user' => true,
 478                 ];
 479
 480                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 481
 482                 // Insert the first revision
 483                 $revOne = $this->getRevisionRecordFromDetailsArray( $revDetails );
 484                 $firstReturn = $store->insertRevisionOn( $revOne, wfGetDB( DB_MASTER ) );
 485                 $this->assertLinkTargetsEqual( $title, $firstReturn->getPageAsLinkTarget() );
 486                 $this->assertRevisionRecordsEqual( $revOne, $firstReturn );
 487
 488                 // Insert a second revision inheriting the same blob address
 489                 $revDetails['slot'] = SlotRecord::newInherited( $firstReturn->getSlot( SlotRecord::MAIN ) );
 490                 $revTwo = $this->getRevisionRecordFromDetailsArray( $revDetails );
 491                 $secondReturn = $store->insertRevisionOn( $revTwo, wfGetDB( DB_MASTER ) );
 492                 $this->assertLinkTargetsEqual( $title, $secondReturn->getPageAsLinkTarget() );
 493                 $this->assertRevisionRecordsEqual( $revTwo, $secondReturn );
 494
 495                 $firstMainSlot = $firstReturn->getSlot( SlotRecord::MAIN );
 496                 $secondMainSlot = $secondReturn->getSlot( SlotRecord::MAIN );
 497
 498                 $this->assertSameSlotContent( $firstMainSlot, $secondMainSlot );
 499
 500                 // And that different revisions have been created.
 501                 $this->assertNotSame( $firstReturn->getId(), $secondReturn->getId() );
 502
 503                 // Make sure the slot rows reference the correct revision
 504                 $this->assertSame( $firstReturn->getId(), $firstMainSlot->getRevision() );
 505                 $this->assertSame( $secondReturn->getId(), $secondMainSlot->getRevision() );
 506         }
 507
 508         public function provideInsertRevisionOn_failures() {
 509                 yield 'no slot' => [
 510                         [
 511                                 'comment' => $this->getRandomCommentStoreComment(),
 512                                 'timestamp' => '20171117010101',
 513                                 'user' => true,
 514                         ],
 515                         new InvalidArgumentException( 'main slot must be provided' )
 516                 ];
 517                 yield 'no main slot' => [
 518                         [
 519                                 'slot' => SlotRecord::newUnsaved( 'aux', new WikitextContent( 'Turkey' ) ),
 520                                 'comment' => $this->getRandomCommentStoreComment(),
 521                                 'timestamp' => '20171117010101',
 522                                 'user' => true,
 523                         ],
 524                         new InvalidArgumentException( 'main slot must be provided' )
 525                 ];
 526                 yield 'no timestamp' => [
 527                         [
 528                                 'slot' => SlotRecord::newUnsaved( SlotRecord::MAIN, new WikitextContent( 'Chicken' ) ),
 529                                 'comment' => $this->getRandomCommentStoreComment(),
 530                                 'user' => true,
 531                         ],
 532                         new IncompleteRevisionException( 'timestamp field must not be NULL!' )
 533                 ];
 534                 yield 'no comment' => [
 535                         [
 536                                 'slot' => SlotRecord::newUnsaved( SlotRecord::MAIN, new WikitextContent( 'Chicken' ) ),
 537                                 'timestamp' => '20171117010101',
 538                                 'user' => true,
 539                         ],
 540                         new IncompleteRevisionException( 'comment must not be NULL!' )
 541                 ];
 542                 yield 'no user' => [
 543                         [
 544                                 'slot' => SlotRecord::newUnsaved( SlotRecord::MAIN, new WikitextContent( 'Chicken' ) ),
 545                                 'comment' => $this->getRandomCommentStoreComment(),
 546                                 'timestamp' => '20171117010101',
 547                         ],
 548                         new IncompleteRevisionException( 'user must not be NULL!' )
 549                 ];
 550         }
 551
 552         /**
 553          * @dataProvider provideInsertRevisionOn_failures
 554          * @covers \MediaWiki\Revision\RevisionStore::insertRevisionOn
 555          */
 556         public function testInsertRevisionOn_failures(
 557                 array $revDetails = [],
 558                 Exception $exception
 559         ) {
 560                 $rev = $this->getRevisionRecordFromDetailsArray( $revDetails );
 561
 562                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 563
 564                 $this->setExpectedException(
 565                         get_class( $exception ),
 566                         $exception->getMessage(),
 567                         $exception->getCode()
 568                 );
 569                 $store->insertRevisionOn( $rev, wfGetDB( DB_MASTER ) );
 570         }
 571
 572         public function provideNewNullRevision() {
 573                 yield [
 574                         Title::newFromText( 'UTPage_notAutoCreated' ),
 575                         [ 'content' => [ 'main' => new WikitextContent( 'Flubber1' ) ] ],
 576                         CommentStoreComment::newUnsavedComment( __METHOD__ . ' comment1' ),
 577                         true,
 578                 ];
 579                 yield [
 580                         Title::newFromText( 'UTPage_notAutoCreated' ),
 581                         [ 'content' => [ 'main' => new WikitextContent( 'Flubber2' ) ] ],
 582                         CommentStoreComment::newUnsavedComment( __METHOD__ . ' comment2', [ 'a' => 1 ] ),
 583                         false,
 584                 ];
 585         }
 586
 587         /**
 588          * @dataProvider provideNewNullRevision
 589          * @covers \MediaWiki\Revision\RevisionStore::newNullRevision
 590          * @covers \MediaWiki\Revision\RevisionStore::findSlotContentId
 591          */
 592         public function testNewNullRevision( Title $title, $revDetails, $comment, $minor = false ) {
 593                 $user = TestUserRegistry::getMutableTestUser( __METHOD__ )->getUser();
 594                 $page = WikiPage::factory( $title );
 595
 596                 if ( !$page->exists() ) {
 597                         $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__, EDIT_NEW );
 598                 }
 599
 600                 $revDetails['page'] = $page->getId();
 601                 $revDetails['timestamp'] = wfTimestampNow();
 602                 $revDetails['comment'] = CommentStoreComment::newUnsavedComment( 'Base' );
 603                 $revDetails['user'] = $user;
 604
 605                 $baseRev = $this->getRevisionRecordFromDetailsArray( $revDetails );
 606                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 607
 608                 $dbw = wfGetDB( DB_MASTER );
 609                 $baseRev = $store->insertRevisionOn( $baseRev, $dbw );
 610                 $page->updateRevisionOn( $dbw, new Revision( $baseRev ), $page->getLatest() );
 611
 612                 $record = $store->newNullRevision(
 613                         wfGetDB( DB_MASTER ),
 614                         $title,
 615                         $comment,
 616                         $minor,
 617                         $user
 618                 );
 619
 620                 $this->assertEquals( $title->getNamespace(), $record->getPageAsLinkTarget()->getNamespace() );
 621                 $this->assertEquals( $title->getDBkey(), $record->getPageAsLinkTarget()->getDBkey() );
 622                 $this->assertEquals( $comment, $record->getComment() );
 623                 $this->assertEquals( $minor, $record->isMinor() );
 624                 $this->assertEquals( $user->getName(), $record->getUser()->getName() );
 625                 $this->assertEquals( $baseRev->getId(), $record->getParentId() );
 626
 627                 $this->assertArrayEquals(
 628                         $baseRev->getSlotRoles(),
 629                         $record->getSlotRoles()
 630                 );
 631
 632                 foreach ( $baseRev->getSlotRoles() as $role ) {
 633                         $parentSlot = $baseRev->getSlot( $role );
 634                         $slot = $record->getSlot( $role );
 635
 636                         $this->assertTrue( $slot->isInherited(), 'isInherited' );
 637                         $this->assertSame( $parentSlot->getOrigin(), $slot->getOrigin(), 'getOrigin' );
 638                         $this->assertSameSlotContent( $parentSlot, $slot );
 639                 }
 640         }
 641
 642         /**
 643          * @covers \MediaWiki\Revision\RevisionStore::newNullRevision
 644          */
 645         public function testNewNullRevision_nonExistingTitle() {
 646                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 647                 $record = $store->newNullRevision(
 648                         wfGetDB( DB_MASTER ),
 649                         Title::newFromText( __METHOD__ . '.iDontExist!' ),
 650                         CommentStoreComment::newUnsavedComment( __METHOD__ . ' comment' ),
 651                         false,
 652                         TestUserRegistry::getMutableTestUser( __METHOD__ )->getUser()
 653                 );
 654                 $this->assertNull( $record );
 655         }
 656
 657         /**
 658          * @covers \MediaWiki\Revision\RevisionStore::getRcIdIfUnpatrolled
 659          */
 660         public function testGetRcIdIfUnpatrolled_returnsRecentChangesId() {
 661                 $page = $this->getTestPage();
 662                 $status = $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ );
 663                 /** @var Revision $rev */
 664                 $rev = $status->value['revision'];
 665
 666                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 667                 $revisionRecord = $store->getRevisionById( $rev->getId() );
 668                 $result = $store->getRcIdIfUnpatrolled( $revisionRecord );
 669
 670                 $this->assertGreaterThan( 0, $result );
 671                 $this->assertSame(
 672                         $store->getRecentChange( $revisionRecord )->getAttribute( 'rc_id' ),
 673                         $result
 674                 );
 675         }
 676
 677         /**
 678          * @covers \MediaWiki\Revision\RevisionStore::getRcIdIfUnpatrolled
 679          */
 680         public function testGetRcIdIfUnpatrolled_returnsZeroIfPatrolled() {
 681                 // This assumes that sysops are auto patrolled
 682                 $sysop = $this->getTestSysop()->getUser();
 683                 $page = $this->getTestPage();
 684                 $status = $page->doEditContent(
 685                         new WikitextContent( __METHOD__ ),
 686                         __METHOD__,
 687                         0,
 688                         false,
 689                         $sysop
 690                 );
 691                 /** @var Revision $rev */
 692                 $rev = $status->value['revision'];
 693
 694                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 695                 $revisionRecord = $store->getRevisionById( $rev->getId() );
 696                 $result = $store->getRcIdIfUnpatrolled( $revisionRecord );
 697
 698                 $this->assertSame( 0, $result );
 699         }
 700
 701         /**
 702          * @covers \MediaWiki\Revision\RevisionStore::getRecentChange
 703          */
 704         public function testGetRecentChange() {
 705                 $page = $this->getTestPage();
 706                 $content = new WikitextContent( __METHOD__ );
 707                 $status = $page->doEditContent( $content, __METHOD__ );
 708                 /** @var Revision $rev */
 709                 $rev = $status->value['revision'];
 710
 711                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 712                 $revRecord = $store->getRevisionById( $rev->getId() );
 713                 $recentChange = $store->getRecentChange( $revRecord );
 714
 715                 $this->assertEquals( $rev->getId(), $recentChange->getAttribute( 'rc_this_oldid' ) );
 716                 $this->assertEquals( $rev->getRecentChange(), $recentChange );
 717         }
 718
 719         /**
 720          * @covers \MediaWiki\Revision\RevisionStore::getRevisionById
 721          */
 722         public function testGetRevisionById() {
 723                 $page = $this->getTestPage();
 724                 $content = new WikitextContent( __METHOD__ );
 725                 $status = $page->doEditContent( $content, __METHOD__ );
 726                 /** @var Revision $rev */
 727                 $rev = $status->value['revision'];
 728
 729                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 730                 $revRecord = $store->getRevisionById( $rev->getId() );
 731
 732                 $this->assertSame( $rev->getId(), $revRecord->getId() );
 733                 $this->assertTrue( $revRecord->getSlot( SlotRecord::MAIN )->getContent()->equals( $content ) );
 734                 $this->assertSame( __METHOD__, $revRecord->getComment()->text );
 735         }
 736
 737         /**
 738          * @covers \MediaWiki\Revision\RevisionStore::getRevisionByTitle
 739          */
 740         public function testGetRevisionByTitle() {
 741                 $page = $this->getTestPage();
 742                 $content = new WikitextContent( __METHOD__ );
 743                 $status = $page->doEditContent( $content, __METHOD__ );
 744                 /** @var Revision $rev */
 745                 $rev = $status->value['revision'];
 746
 747                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 748                 $revRecord = $store->getRevisionByTitle( $page->getTitle() );
 749
 750                 $this->assertSame( $rev->getId(), $revRecord->getId() );
 751                 $this->assertTrue( $revRecord->getSlot( SlotRecord::MAIN )->getContent()->equals( $content ) );
 752                 $this->assertSame( __METHOD__, $revRecord->getComment()->text );
 753         }
 754
 755         /**
 756          * @covers \MediaWiki\Revision\RevisionStore::getRevisionByPageId
 757          */
 758         public function testGetRevisionByPageId() {
 759                 $page = $this->getTestPage();
 760                 $content = new WikitextContent( __METHOD__ );
 761                 $status = $page->doEditContent( $content, __METHOD__ );
 762                 /** @var Revision $rev */
 763                 $rev = $status->value['revision'];
 764
 765                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 766                 $revRecord = $store->getRevisionByPageId( $page->getId() );
 767
 768                 $this->assertSame( $rev->getId(), $revRecord->getId() );
 769                 $this->assertTrue( $revRecord->getSlot( SlotRecord::MAIN )->getContent()->equals( $content ) );
 770                 $this->assertSame( __METHOD__, $revRecord->getComment()->text );
 771         }
 772
 773         /**
 774          * @covers \MediaWiki\Revision\RevisionStore::getRevisionByTimestamp
 775          */
 776         public function testGetRevisionByTimestamp() {
 777                 // Make sure there is 1 second between the last revision and the rev we create...
 778                 // Otherwise we might not get the correct revision and the test may fail...
 779                 // :(
 780                 $page = $this->getTestPage();
 781                 sleep( 1 );
 782                 $content = new WikitextContent( __METHOD__ );
 783                 $status = $page->doEditContent( $content, __METHOD__ );
 784                 /** @var Revision $rev */
 785                 $rev = $status->value['revision'];
 786
 787                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 788                 $revRecord = $store->getRevisionByTimestamp(
 789                         $page->getTitle(),
 790                         $rev->getTimestamp()
 791                 );
 792
 793                 $this->assertSame( $rev->getId(), $revRecord->getId() );
 794                 $this->assertTrue( $revRecord->getSlot( SlotRecord::MAIN )->getContent()->equals( $content ) );
 795                 $this->assertSame( __METHOD__, $revRecord->getComment()->text );
 796         }
 797
 798         protected function revisionToRow( Revision $rev, $options = [ 'page', 'user', 'comment' ] ) {
 799                 // XXX: the WikiPage object loads another RevisionRecord from the database. Not great.
 800                 $page = WikiPage::factory( $rev->getTitle() );
 801
 802                 $fields = [
 803                         'rev_id' => (string)$rev->getId(),
 804                         'rev_page' => (string)$rev->getPage(),
 805                         'rev_timestamp' => $this->db->timestamp( $rev->getTimestamp() ),
 806                         'rev_user_text' => (string)$rev->getUserText(),
 807                         'rev_user' => (string)$rev->getUser() ?: null,
 808                         'rev_minor_edit' => $rev->isMinor() ? '1' : '0',
 809                         'rev_deleted' => (string)$rev->getVisibility(),
 810                         'rev_len' => (string)$rev->getSize(),
 811                         'rev_parent_id' => (string)$rev->getParentId(),
 812                         'rev_sha1' => (string)$rev->getSha1(),
 813                 ];
 814
 815                 if ( in_array( 'page', $options ) ) {
 816                         $fields += [
 817                                 'page_namespace' => (string)$page->getTitle()->getNamespace(),
 818                                 'page_title' => $page->getTitle()->getDBkey(),
 819                                 'page_id' => (string)$page->getId(),
 820                                 'page_latest' => (string)$page->getLatest(),
 821                                 'page_is_redirect' => $page->isRedirect() ? '1' : '0',
 822                                 'page_len' => (string)$page->getContent()->getSize(),
 823                         ];
 824                 }
 825
 826                 if ( in_array( 'user', $options ) ) {
 827                         $fields += [
 828                                 'user_name' => (string)$rev->getUserText(),
 829                         ];
 830                 }
 831
 832                 if ( in_array( 'comment', $options ) ) {
 833                         $fields += [
 834                                 'rev_comment_text' => $rev->getComment(),
 835                                 'rev_comment_data' => null,
 836                                 'rev_comment_cid' => null,
 837                         ];
 838                 }
 839
 840                 if ( $rev->getId() ) {
 841                         $fields += [
 842                                 'rev_id' => (string)$rev->getId(),
 843                         ];
 844                 }
 845
 846                 return (object)$fields;
 847         }
 848
 849         protected function assertRevisionRecordMatchesRevision(
 850                 Revision $rev,
 851                 RevisionRecord $record
 852         ) {
 853                 $this->assertSame( $rev->getId(), $record->getId() );
 854                 $this->assertSame( $rev->getPage(), $record->getPageId() );
 855                 $this->assertSame( $rev->getTimestamp(), $record->getTimestamp() );
 856                 $this->assertSame( $rev->getUserText(), $record->getUser()->getName() );
 857                 $this->assertSame( $rev->getUser(), $record->getUser()->getId() );
 858                 $this->assertSame( $rev->isMinor(), $record->isMinor() );
 859                 $this->assertSame( $rev->getVisibility(), $record->getVisibility() );
 860                 $this->assertSame( $rev->getSize(), $record->getSize() );
 861                 /**
 862                  * @note As of MW 1.31, the database schema allows the parent ID to be
 863                  * NULL to indicate that it is unknown.
 864                  */
 865                 $expectedParent = $rev->getParentId();
 866                 if ( $expectedParent === null ) {
 867                         $expectedParent = 0;
 868                 }
 869                 $this->assertSame( $expectedParent, $record->getParentId() );
 870                 $this->assertSame( $rev->getSha1(), $record->getSha1() );
 871                 $this->assertSame( $rev->getComment(), $record->getComment()->text );
 872                 $this->assertSame( $rev->getContentFormat(),
 873                         $record->getContent( SlotRecord::MAIN )->getDefaultFormat() );
 874                 $this->assertSame( $rev->getContentModel(), $record->getContent( SlotRecord::MAIN )->getModel() );
 875                 $this->assertLinkTargetsEqual( $rev->getTitle(), $record->getPageAsLinkTarget() );
 876
 877                 $revRec = $rev->getRevisionRecord();
 878                 $revMain = $revRec->getSlot( SlotRecord::MAIN );
 879                 $recMain = $record->getSlot( SlotRecord::MAIN );
 880
 881                 $this->assertSame( $revMain->hasOrigin(), $recMain->hasOrigin(), 'hasOrigin' );
 882                 $this->assertSame( $revMain->hasAddress(), $recMain->hasAddress(), 'hasAddress' );
 883                 $this->assertSame( $revMain->hasContentId(), $recMain->hasContentId(), 'hasContentId' );
 884
 885                 if ( $revMain->hasOrigin() ) {
 886                         $this->assertSame( $revMain->getOrigin(), $recMain->getOrigin(), 'getOrigin' );
 887                 }
 888
 889                 if ( $revMain->hasAddress() ) {
 890                         $this->assertSame( $revMain->getAddress(), $recMain->getAddress(), 'getAddress' );
 891                 }
 892
 893                 if ( $revMain->hasContentId() ) {
 894                         // XXX: the content ID value is ill-defined when SCHEMA_COMPAT_WRITE_BOTH and
 895                         //      SCHEMA_COMPAT_READ_OLD is set, since revision insertion will report the
 896                         //      content ID used with the new schema, while loading the revision from the
 897                         //      old schema will report an emulated ID.
 898                         if ( $this->getMcrMigrationStage() & SCHEMA_COMPAT_READ_NEW ) {
 899                                 $this->assertSame( $revMain->getContentId(), $recMain->getContentId(), 'getContentId' );
 900                         }
 901                 }
 902         }
 903
 904         /**
 905          * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRowAndSlots
 906          * @covers \MediaWiki\Revision\RevisionStore::getQueryInfo
 907          */
 908         public function testNewRevisionFromRowAndSlot_getQueryInfo() {
 909                 $page = $this->getTestPage();
 910                 $text = __METHOD__ . 'o-ö';
 911                 /** @var Revision $rev */
 912                 $rev = $page->doEditContent(
 913                         new WikitextContent( $text ),
 914                         __METHOD__ . 'a'
 915                 )->value['revision'];
 916
 917                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 918                 $info = $store->getQueryInfo();
 919                 $row = $this->db->selectRow(
 920                         $info['tables'],
 921                         $info['fields'],
 922                         [ 'rev_id' => $rev->getId() ],
 923                         __METHOD__,
 924                         [],
 925                         $info['joins']
 926                 );
 927
 928                 $info = $store->getSlotsQueryInfo( [ 'content' ] );
 929                 $slotRows = $this->db->select(
 930                         $info['tables'],
 931                         $info['fields'],
 932                         $this->getSlotRevisionConditions( $rev->getId() ),
 933                         __METHOD__,
 934                         [],
 935                         $info['joins']
 936                 );
 937
 938                 $record = $store->newRevisionFromRowAndSlots(
 939                         $row,
 940                         iterator_to_array( $slotRows ),
 941                         [],
 942                         $page->getTitle()
 943                 );
 944                 $this->assertRevisionRecordMatchesRevision( $rev, $record );
 945                 $this->assertSame( $text, $rev->getContent()->serialize() );
 946         }
 947
 948         /**
 949          * Conditions to use together with getSlotsQueryInfo() when selecting slot rows for a given
 950          * revision.
 951          *
 952          * @return array
 953          */
 954         abstract protected function getSlotRevisionConditions( $revId );
 955
 956         /**
 957          * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRow
 958          * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRowAndSlots
 959          * @covers \MediaWiki\Revision\RevisionStore::getQueryInfo
 960          */
 961         public function testNewRevisionFromRow_getQueryInfo() {
 962                 $page = $this->getTestPage();
 963                 $text = __METHOD__ . 'a-ä';
 964                 /** @var Revision $rev */
 965                 $rev = $page->doEditContent(
 966                         new WikitextContent( $text ),
 967                         __METHOD__ . 'a'
 968                 )->value['revision'];
 969
 970                 $store = MediaWikiServices::getInstance()->getRevisionStore();
 971                 $info = $store->getQueryInfo();
 972                 $row = $this->db->selectRow(
 973                         $info['tables'],
 974                         $info['fields'],
 975                         [ 'rev_id' => $rev->getId() ],
 976                         __METHOD__,
 977                         [],
 978                         $info['joins']
 979                 );
 980                 $record = $store->newRevisionFromRow(
 981                         $row,
 982                         [],
 983                         $page->getTitle()
 984                 );
 985                 $this->assertRevisionRecordMatchesRevision( $rev, $record );
 986                 $this->assertSame( $text, $rev->getContent()->serialize() );
 987         }
 988
 989         /**
 990          * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRow
 991          * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRowAndSlots
 992          */
 993         public function testNewRevisionFromRow_anonEdit() {
 994                 $page = $this->getTestPage();
 995                 $text = __METHOD__ . 'a-ä';
 996                 /** @var Revision $rev */
 997                 $rev = $page->doEditContent(
 998                         new WikitextContent( $text ),
 999                         __METHOD__ . 'a'
1000                 )->value['revision'];
1001
1002                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1003                 $record = $store->newRevisionFromRow(
1004                         $this->revisionToRow( $rev ),
1005                         [],
1006                         $page->getTitle()
1007                 );
1008                 $this->assertRevisionRecordMatchesRevision( $rev, $record );
1009                 $this->assertSame( $text, $rev->getContent()->serialize() );
1010         }
1011
1012         /**
1013          * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRow
1014          * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRowAndSlots
1015          */
1016         public function testNewRevisionFromRow_anonEdit_legacyEncoding() {
1017                 $this->setMwGlobals( 'wgLegacyEncoding', 'windows-1252' );
1018                 $page = $this->getTestPage();
1019                 $text = __METHOD__ . 'a-ä';
1020                 /** @var Revision $rev */
1021                 $rev = $page->doEditContent(
1022                         new WikitextContent( $text ),
1023                         __METHOD__ . 'a'
1024                 )->value['revision'];
1025
1026                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1027                 $record = $store->newRevisionFromRow(
1028                         $this->revisionToRow( $rev ),
1029                         [],
1030                         $page->getTitle()
1031                 );
1032                 $this->assertRevisionRecordMatchesRevision( $rev, $record );
1033                 $this->assertSame( $text, $rev->getContent()->serialize() );
1034         }
1035
1036         /**
1037          * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRow
1038          * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRowAndSlots
1039          */
1040         public function testNewRevisionFromRow_userEdit() {
1041                 $page = $this->getTestPage();
1042                 $text = __METHOD__ . 'b-ä';
1043                 /** @var Revision $rev */
1044                 $rev = $page->doEditContent(
1045                         new WikitextContent( $text ),
1046                         __METHOD__ . 'b',
1047                         0,
1048                         false,
1049                         $this->getTestUser()->getUser()
1050                 )->value['revision'];
1051
1052                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1053                 $record = $store->newRevisionFromRow(
1054                         $this->revisionToRow( $rev ),
1055                         [],
1056                         $page->getTitle()
1057                 );
1058                 $this->assertRevisionRecordMatchesRevision( $rev, $record );
1059                 $this->assertSame( $text, $rev->getContent()->serialize() );
1060         }
1061
1062         /**
1063          * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromArchiveRow
1064          * @covers \MediaWiki\Revision\RevisionStore::getArchiveQueryInfo
1065          */
1066         public function testNewRevisionFromArchiveRow_getArchiveQueryInfo() {
1067                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1068                 $title = Title::newFromText( __METHOD__ );
1069                 $text = __METHOD__ . '-bä';
1070                 $page = WikiPage::factory( $title );
1071                 /** @var Revision $orig */
1072                 $orig = $page->doEditContent( new WikitextContent( $text ), __METHOD__ )
1073                         ->value['revision'];
1074                 $page->doDeleteArticle( __METHOD__ );
1075
1076                 $db = wfGetDB( DB_MASTER );
1077                 $arQuery = $store->getArchiveQueryInfo();
1078                 $res = $db->select(
1079                         $arQuery['tables'], $arQuery['fields'], [ 'ar_rev_id' => $orig->getId() ],
1080                         __METHOD__, [], $arQuery['joins']
1081                 );
1082                 $this->assertTrue( is_object( $res ), 'query failed' );
1083
1084                 $row = $res->fetchObject();
1085                 $res->free();
1086                 $record = $store->newRevisionFromArchiveRow( $row );
1087
1088                 $this->assertRevisionRecordMatchesRevision( $orig, $record );
1089                 $this->assertSame( $text, $record->getContent( SlotRecord::MAIN )->serialize() );
1090         }
1091
1092         /**
1093          * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromArchiveRow
1094          */
1095         public function testNewRevisionFromArchiveRow_legacyEncoding() {
1096                 $this->setMwGlobals( 'wgLegacyEncoding', 'windows-1252' );
1097                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1098                 $title = Title::newFromText( __METHOD__ );
1099                 $text = __METHOD__ . '-bä';
1100                 $page = WikiPage::factory( $title );
1101                 /** @var Revision $orig */
1102                 $orig = $page->doEditContent( new WikitextContent( $text ), __METHOD__ )
1103                         ->value['revision'];
1104                 $page->doDeleteArticle( __METHOD__ );
1105
1106                 $db = wfGetDB( DB_MASTER );
1107                 $arQuery = $store->getArchiveQueryInfo();
1108                 $res = $db->select(
1109                         $arQuery['tables'], $arQuery['fields'], [ 'ar_rev_id' => $orig->getId() ],
1110                         __METHOD__, [], $arQuery['joins']
1111                 );
1112                 $this->assertTrue( is_object( $res ), 'query failed' );
1113
1114                 $row = $res->fetchObject();
1115                 $res->free();
1116                 $record = $store->newRevisionFromArchiveRow( $row );
1117
1118                 $this->assertRevisionRecordMatchesRevision( $orig, $record );
1119                 $this->assertSame( $text, $record->getContent( SlotRecord::MAIN )->serialize() );
1120         }
1121
1122         /**
1123          * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromArchiveRow
1124          */
1125         public function testNewRevisionFromArchiveRow_no_user() {
1126                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1127
1128                 $row = (object)[
1129                         'ar_id' => '1',
1130                         'ar_page_id' => '2',
1131                         'ar_namespace' => '0',
1132                         'ar_title' => 'Something',
1133                         'ar_rev_id' => '2',
1134                         'ar_text_id' => '47',
1135                         'ar_timestamp' => '20180528192356',
1136                         'ar_minor_edit' => '0',
1137                         'ar_deleted' => '0',
1138                         'ar_len' => '78',
1139                         'ar_parent_id' => '0',
1140                         'ar_sha1' => 'deadbeef',
1141                         'ar_comment_text' => 'whatever',
1142                         'ar_comment_data' => null,
1143                         'ar_comment_cid' => null,
1144                         'ar_user' => '0',
1145                         'ar_user_text' => '', // this is the important bit
1146                         'ar_actor' => null,
1147                         'ar_content_format' => null,
1148                         'ar_content_model' => null,
1149                 ];
1150
1151                 \Wikimedia\suppressWarnings();
1152                 $record = $store->newRevisionFromArchiveRow( $row );
1153                 \Wikimedia\suppressWarnings( true );
1154
1155                 $this->assertInstanceOf( RevisionRecord::class, $record );
1156                 $this->assertInstanceOf( UserIdentityValue::class, $record->getUser() );
1157                 $this->assertSame( 'Unknown user', $record->getUser()->getName() );
1158         }
1159
1160         /**
1161          * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRow
1162          * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRowAndSlots
1163          */
1164         public function testNewRevisionFromRow_no_user() {
1165                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1166                 $title = Title::newFromText( __METHOD__ );
1167
1168                 $row = (object)[
1169                         'rev_id' => '2',
1170                         'rev_page' => '2',
1171                         'page_namespace' => '0',
1172                         'page_title' => $title->getText(),
1173                         'rev_text_id' => '47',
1174                         'rev_timestamp' => '20180528192356',
1175                         'rev_minor_edit' => '0',
1176                         'rev_deleted' => '0',
1177                         'rev_len' => '78',
1178                         'rev_parent_id' => '0',
1179                         'rev_sha1' => 'deadbeef',
1180                         'rev_comment_text' => 'whatever',
1181                         'rev_comment_data' => null,
1182                         'rev_comment_cid' => null,
1183                         'rev_user' => '0',
1184                         'rev_user_text' => '', // this is the important bit
1185                         'rev_actor' => null,
1186                         'rev_content_format' => null,
1187                         'rev_content_model' => null,
1188                 ];
1189
1190                 \Wikimedia\suppressWarnings();
1191                 $record = $store->newRevisionFromRow( $row, 0, $title );
1192                 \Wikimedia\suppressWarnings( true );
1193
1194                 $this->assertNotNull( $record );
1195                 $this->assertNotNull( $record->getUser() );
1196                 $this->assertNotEmpty( $record->getUser()->getName() );
1197         }
1198
1199         /**
1200          * @covers \MediaWiki\Revision\RevisionStore::insertRevisionOn
1201          */
1202         public function testInsertRevisionOn_archive() {
1203                 // This is a round trip test for deletion and undeletion of a
1204                 // revision row via the archive table.
1205
1206                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1207                 $title = Title::newFromText( __METHOD__ );
1208
1209                 $page = WikiPage::factory( $title );
1210                 /** @var Revision $origRev */
1211                 $page->doEditContent( new WikitextContent( "First" ), __METHOD__ . '-first' );
1212                 $origRev = $page->doEditContent( new WikitextContent( "Foo" ), __METHOD__ )
1213                         ->value['revision'];
1214                 $orig = $origRev->getRevisionRecord();
1215                 $page->doDeleteArticle( __METHOD__ );
1216
1217                 // re-create page, so we can later load revisions for it
1218                 $page->doEditContent( new WikitextContent( 'Two' ), __METHOD__ );
1219
1220                 $db = wfGetDB( DB_MASTER );
1221                 $arQuery = $store->getArchiveQueryInfo();
1222                 $row = $db->selectRow(
1223                         $arQuery['tables'], $arQuery['fields'], [ 'ar_rev_id' => $orig->getId() ],
1224                         __METHOD__, [], $arQuery['joins']
1225                 );
1226
1227                 $this->assertNotFalse( $row, 'query failed' );
1228
1229                 $record = $store->newRevisionFromArchiveRow(
1230                         $row,
1231                         0,
1232                         $title,
1233                         [ 'page_id' => $title->getArticleID() ]
1234                 );
1235
1236                 $restored = $store->insertRevisionOn( $record, $db );
1237
1238                 // is the new revision correct?
1239                 $this->assertRevisionCompleteness( $restored );
1240                 $this->assertRevisionRecordsEqual( $record, $restored );
1241
1242                 // does the new revision use the original slot?
1243                 $recMain = $record->getSlot( SlotRecord::MAIN );
1244                 $restMain = $restored->getSlot( SlotRecord::MAIN );
1245                 $this->assertSame( $recMain->getAddress(), $restMain->getAddress() );
1246                 $this->assertSame( $recMain->getContentId(), $restMain->getContentId() );
1247                 $this->assertSame( $recMain->getOrigin(), $restMain->getOrigin() );
1248                 $this->assertSame( 'Foo', $restMain->getContent()->serialize() );
1249
1250                 // can we load it from the store?
1251                 $loaded = $store->getRevisionById( $restored->getId() );
1252                 $this->assertNotNull( $loaded );
1253                 $this->assertRevisionCompleteness( $loaded );
1254                 $this->assertRevisionRecordsEqual( $restored, $loaded );
1255
1256                 // can we find it directly in the database?
1257                 $this->assertRevisionExistsInDatabase( $restored );
1258         }
1259
1260         /**
1261          * @covers \MediaWiki\Revision\RevisionStore::loadRevisionFromId
1262          */
1263         public function testLoadRevisionFromId() {
1264                 $title = Title::newFromText( __METHOD__ );
1265                 $page = WikiPage::factory( $title );
1266                 /** @var Revision $rev */
1267                 $rev = $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ )
1268                         ->value['revision'];
1269
1270                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1271                 $result = $store->loadRevisionFromId( wfGetDB( DB_MASTER ), $rev->getId() );
1272                 $this->assertRevisionRecordMatchesRevision( $rev, $result );
1273         }
1274
1275         /**
1276          * @covers \MediaWiki\Revision\RevisionStore::loadRevisionFromPageId
1277          */
1278         public function testLoadRevisionFromPageId() {
1279                 $title = Title::newFromText( __METHOD__ );
1280                 $page = WikiPage::factory( $title );
1281                 /** @var Revision $rev */
1282                 $rev = $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ )
1283                         ->value['revision'];
1284
1285                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1286                 $result = $store->loadRevisionFromPageId( wfGetDB( DB_MASTER ), $page->getId() );
1287                 $this->assertRevisionRecordMatchesRevision( $rev, $result );
1288         }
1289
1290         /**
1291          * @covers \MediaWiki\Revision\RevisionStore::loadRevisionFromTitle
1292          */
1293         public function testLoadRevisionFromTitle() {
1294                 $title = Title::newFromText( __METHOD__ );
1295                 $page = WikiPage::factory( $title );
1296                 /** @var Revision $rev */
1297                 $rev = $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ )
1298                         ->value['revision'];
1299
1300                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1301                 $result = $store->loadRevisionFromTitle( wfGetDB( DB_MASTER ), $title );
1302                 $this->assertRevisionRecordMatchesRevision( $rev, $result );
1303         }
1304
1305         /**
1306          * @covers \MediaWiki\Revision\RevisionStore::loadRevisionFromTimestamp
1307          */
1308         public function testLoadRevisionFromTimestamp() {
1309                 $title = Title::newFromText( __METHOD__ );
1310                 $page = WikiPage::factory( $title );
1311                 /** @var Revision $revOne */
1312                 $revOne = $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ )
1313                         ->value['revision'];
1314                 // Sleep to ensure different timestamps... )(evil)
1315                 sleep( 1 );
1316                 /** @var Revision $revTwo */
1317                 $revTwo = $page->doEditContent( new WikitextContent( __METHOD__ . 'a' ), '' )
1318                         ->value['revision'];
1319
1320                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1321                 $this->assertNull(
1322                         $store->loadRevisionFromTimestamp( wfGetDB( DB_MASTER ), $title, '20150101010101' )
1323                 );
1324                 $this->assertSame(
1325                         $revOne->getId(),
1326                         $store->loadRevisionFromTimestamp(
1327                                 wfGetDB( DB_MASTER ),
1328                                 $title,
1329                                 $revOne->getTimestamp()
1330                         )->getId()
1331                 );
1332                 $this->assertSame(
1333                         $revTwo->getId(),
1334                         $store->loadRevisionFromTimestamp(
1335                                 wfGetDB( DB_MASTER ),
1336                                 $title,
1337                                 $revTwo->getTimestamp()
1338                         )->getId()
1339                 );
1340         }
1341
1342         /**
1343          * @covers \MediaWiki\Revision\RevisionStore::listRevisionSizes
1344          */
1345         public function testGetParentLengths() {
1346                 $page = WikiPage::factory( Title::newFromText( __METHOD__ ) );
1347                 /** @var Revision $revOne */
1348                 $revOne = $page->doEditContent(
1349                         new WikitextContent( __METHOD__ ), __METHOD__
1350                 )->value['revision'];
1351                 /** @var Revision $revTwo */
1352                 $revTwo = $page->doEditContent(
1353                         new WikitextContent( __METHOD__ . '2' ), __METHOD__
1354                 )->value['revision'];
1355
1356                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1357                 $this->assertSame(
1358                         [
1359                                 $revOne->getId() => strlen( __METHOD__ ),
1360                         ],
1361                         $store->listRevisionSizes(
1362                                 wfGetDB( DB_MASTER ),
1363                                 [ $revOne->getId() ]
1364                         )
1365                 );
1366                 $this->assertSame(
1367                         [
1368                                 $revOne->getId() => strlen( __METHOD__ ),
1369                                 $revTwo->getId() => strlen( __METHOD__ ) + 1,
1370                         ],
1371                         $store->listRevisionSizes(
1372                                 wfGetDB( DB_MASTER ),
1373                                 [ $revOne->getId(), $revTwo->getId() ]
1374                         )
1375                 );
1376         }
1377
1378         /**
1379          * @covers \MediaWiki\Revision\RevisionStore::getPreviousRevision
1380          */
1381         public function testGetPreviousRevision() {
1382                 $page = WikiPage::factory( Title::newFromText( __METHOD__ ) );
1383                 /** @var Revision $revOne */
1384                 $revOne = $page->doEditContent(
1385                         new WikitextContent( __METHOD__ ), __METHOD__
1386                 )->value['revision'];
1387                 /** @var Revision $revTwo */
1388                 $revTwo = $page->doEditContent(
1389                         new WikitextContent( __METHOD__ . '2' ), __METHOD__
1390                 )->value['revision'];
1391
1392                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1393                 $this->assertNull(
1394                         $store->getPreviousRevision( $store->getRevisionById( $revOne->getId() ) )
1395                 );
1396                 $this->assertSame(
1397                         $revOne->getId(),
1398                         $store->getPreviousRevision( $store->getRevisionById( $revTwo->getId() ) )->getId()
1399                 );
1400         }
1401
1402         /**
1403          * @covers \MediaWiki\Revision\RevisionStore::getNextRevision
1404          */
1405         public function testGetNextRevision() {
1406                 $page = WikiPage::factory( Title::newFromText( __METHOD__ ) );
1407                 /** @var Revision $revOne */
1408                 $revOne = $page->doEditContent(
1409                         new WikitextContent( __METHOD__ ), __METHOD__
1410                 )->value['revision'];
1411                 /** @var Revision $revTwo */
1412                 $revTwo = $page->doEditContent(
1413                         new WikitextContent( __METHOD__ . '2' ), __METHOD__
1414                 )->value['revision'];
1415
1416                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1417                 $this->assertSame(
1418                         $revTwo->getId(),
1419                         $store->getNextRevision( $store->getRevisionById( $revOne->getId() ) )->getId()
1420                 );
1421                 $this->assertNull(
1422                         $store->getNextRevision( $store->getRevisionById( $revTwo->getId() ) )
1423                 );
1424         }
1425
1426         public function provideNonHistoryRevision() {
1427                 $title = Title::newFromText( __METHOD__ );
1428                 $rev = new MutableRevisionRecord( $title );
1429                 yield [ $rev ];
1430
1431                 $user = new UserIdentityValue( 7, 'Frank', 0 );
1432                 $comment = CommentStoreComment::newUnsavedComment( 'Test' );
1433                 $row = (object)[
1434                         'ar_id' => 3,
1435                         'ar_rev_id' => 34567,
1436                         'ar_page_id' => 5,
1437                         'ar_deleted' => 0,
1438                         'ar_minor_edit' => 0,
1439                         'ar_timestamp' => '20180101020202',
1440                 ];
1441                 $slots = new RevisionSlots( [] );
1442                 $rev = new RevisionArchiveRecord( $title, $user, $comment, $row, $slots );
1443                 yield [ $rev ];
1444         }
1445
1446         /**
1447          * @dataProvider provideNonHistoryRevision
1448          * @covers \MediaWiki\Revision\RevisionStore::getPreviousRevision
1449          */
1450         public function testGetPreviousRevision_bad( RevisionRecord $rev ) {
1451                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1452                 $this->assertNull( $store->getPreviousRevision( $rev ) );
1453         }
1454
1455         /**
1456          * @dataProvider provideNonHistoryRevision
1457          * @covers \MediaWiki\Revision\RevisionStore::getNextRevision
1458          */
1459         public function testGetNextRevision_bad( RevisionRecord $rev ) {
1460                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1461                 $this->assertNull( $store->getNextRevision( $rev ) );
1462         }
1463
1464         /**
1465          * @covers \MediaWiki\Revision\RevisionStore::getTimestampFromId
1466          */
1467         public function testGetTimestampFromId_found() {
1468                 $page = $this->getTestPage();
1469                 /** @var Revision $rev */
1470                 $rev = $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ )
1471                         ->value['revision'];
1472
1473                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1474                 $result = $store->getTimestampFromId( $rev->getId() );
1475
1476                 $this->assertSame( $rev->getTimestamp(), $result );
1477         }
1478
1479         /**
1480          * @covers \MediaWiki\Revision\RevisionStore::getTimestampFromId
1481          */
1482         public function testGetTimestampFromId_notFound() {
1483                 $page = $this->getTestPage();
1484                 /** @var Revision $rev */
1485                 $rev = $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ )
1486                         ->value['revision'];
1487
1488                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1489                 $result = $store->getTimestampFromId( $rev->getId() + 1 );
1490
1491                 $this->assertFalse( $result );
1492         }
1493
1494         /**
1495          * @covers \MediaWiki\Revision\RevisionStore::countRevisionsByPageId
1496          */
1497         public function testCountRevisionsByPageId() {
1498                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1499                 $page = WikiPage::factory( Title::newFromText( __METHOD__ ) );
1500
1501                 $this->assertSame(
1502                         0,
1503                         $store->countRevisionsByPageId( wfGetDB( DB_MASTER ), $page->getId() )
1504                 );
1505                 $page->doEditContent( new WikitextContent( 'a' ), 'a' );
1506                 $this->assertSame(
1507                         1,
1508                         $store->countRevisionsByPageId( wfGetDB( DB_MASTER ), $page->getId() )
1509                 );
1510                 $page->doEditContent( new WikitextContent( 'b' ), 'b' );
1511                 $this->assertSame(
1512                         2,
1513                         $store->countRevisionsByPageId( wfGetDB( DB_MASTER ), $page->getId() )
1514                 );
1515         }
1516
1517         /**
1518          * @covers \MediaWiki\Revision\RevisionStore::countRevisionsByTitle
1519          */
1520         public function testCountRevisionsByTitle() {
1521                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1522                 $page = WikiPage::factory( Title::newFromText( __METHOD__ ) );
1523
1524                 $this->assertSame(
1525                         0,
1526                         $store->countRevisionsByTitle( wfGetDB( DB_MASTER ), $page->getTitle() )
1527                 );
1528                 $page->doEditContent( new WikitextContent( 'a' ), 'a' );
1529                 $this->assertSame(
1530                         1,
1531                         $store->countRevisionsByTitle( wfGetDB( DB_MASTER ), $page->getTitle() )
1532                 );
1533                 $page->doEditContent( new WikitextContent( 'b' ), 'b' );
1534                 $this->assertSame(
1535                         2,
1536                         $store->countRevisionsByTitle( wfGetDB( DB_MASTER ), $page->getTitle() )
1537                 );
1538         }
1539
1540         /**
1541          * @covers \MediaWiki\Revision\RevisionStore::userWasLastToEdit
1542          */
1543         public function testUserWasLastToEdit_false() {
1544                 $sysop = $this->getTestSysop()->getUser();
1545                 $page = $this->getTestPage();
1546                 $page->doEditContent( new WikitextContent( __METHOD__ ), __METHOD__ );
1547
1548                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1549                 $result = $store->userWasLastToEdit(
1550                         wfGetDB( DB_MASTER ),
1551                         $page->getId(),
1552                         $sysop->getId(),
1553                         '20160101010101'
1554                 );
1555                 $this->assertFalse( $result );
1556         }
1557
1558         /**
1559          * @covers \MediaWiki\Revision\RevisionStore::userWasLastToEdit
1560          */
1561         public function testUserWasLastToEdit_true() {
1562                 $startTime = wfTimestampNow();
1563                 $sysop = $this->getTestSysop()->getUser();
1564                 $page = $this->getTestPage();
1565                 $page->doEditContent(
1566                         new WikitextContent( __METHOD__ ),
1567                         __METHOD__,
1568                         0,
1569                         false,
1570                         $sysop
1571                 );
1572
1573                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1574                 $result = $store->userWasLastToEdit(
1575                         wfGetDB( DB_MASTER ),
1576                         $page->getId(),
1577                         $sysop->getId(),
1578                         $startTime
1579                 );
1580                 $this->assertTrue( $result );
1581         }
1582
1583         /**
1584          * @covers \MediaWiki\Revision\RevisionStore::getKnownCurrentRevision
1585          */
1586         public function testGetKnownCurrentRevision() {
1587                 $page = $this->getTestPage();
1588                 /** @var Revision $rev */
1589                 $rev = $page->doEditContent(
1590                         new WikitextContent( __METHOD__ . 'b' ),
1591                         __METHOD__ . 'b',
1592                         0,
1593                         false,
1594                         $this->getTestUser()->getUser()
1595                 )->value['revision'];
1596
1597                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1598                 $record = $store->getKnownCurrentRevision(
1599                         $page->getTitle(),
1600                         $rev->getId()
1601                 );
1602
1603                 $this->assertRevisionRecordMatchesRevision( $rev, $record );
1604         }
1605
1606         public function provideNewMutableRevisionFromArray() {
1607                 yield 'Basic array, content object' => [
1608                         [
1609                                 'id' => 2,
1610                                 'page' => 1,
1611                                 'timestamp' => '20171017114835',
1612                                 'user_text' => '111.0.1.2',
1613                                 'user' => 0,
1614                                 'minor_edit' => false,
1615                                 'deleted' => 0,
1616                                 'len' => 46,
1617                                 'parent_id' => 1,
1618                                 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1619                                 'comment' => 'Goat Comment!',
1620                                 'content' => new WikitextContent( 'Some Content' ),
1621                         ]
1622                 ];
1623                 yield 'Basic array, serialized text' => [
1624                         [
1625                                 'id' => 2,
1626                                 'page' => 1,
1627                                 'timestamp' => '20171017114835',
1628                                 'user_text' => '111.0.1.2',
1629                                 'user' => 0,
1630                                 'minor_edit' => false,
1631                                 'deleted' => 0,
1632                                 'len' => 46,
1633                                 'parent_id' => 1,
1634                                 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1635                                 'comment' => 'Goat Comment!',
1636                                 'text' => ( new WikitextContent( 'Söme Content' ) )->serialize(),
1637                         ]
1638                 ];
1639                 yield 'Basic array, serialized text, utf-8 flags' => [
1640                         [
1641                                 'id' => 2,
1642                                 'page' => 1,
1643                                 'timestamp' => '20171017114835',
1644                                 'user_text' => '111.0.1.2',
1645                                 'user' => 0,
1646                                 'minor_edit' => false,
1647                                 'deleted' => 0,
1648                                 'len' => 46,
1649                                 'parent_id' => 1,
1650                                 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1651                                 'comment' => 'Goat Comment!',
1652                                 'text' => ( new WikitextContent( 'Söme Content' ) )->serialize(),
1653                                 'flags' => 'utf-8',
1654                         ]
1655                 ];
1656                 yield 'Basic array, with title' => [
1657                         [
1658                                 'title' => Title::newFromText( 'SomeText' ),
1659                                 'timestamp' => '20171017114835',
1660                                 'user_text' => '111.0.1.2',
1661                                 'user' => 0,
1662                                 'minor_edit' => false,
1663                                 'deleted' => 0,
1664                                 'len' => 46,
1665                                 'parent_id' => 1,
1666                                 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1667                                 'comment' => 'Goat Comment!',
1668                                 'content' => new WikitextContent( 'Some Content' ),
1669                         ]
1670                 ];
1671                 yield 'Basic array, no user field' => [
1672                         [
1673                                 'id' => 2,
1674                                 'page' => 1,
1675                                 'timestamp' => '20171017114835',
1676                                 'user_text' => '111.0.1.3',
1677                                 'minor_edit' => false,
1678                                 'deleted' => 0,
1679                                 'len' => 46,
1680                                 'parent_id' => 1,
1681                                 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1682                                 'comment' => 'Goat Comment!',
1683                                 'content' => new WikitextContent( 'Some Content' ),
1684                         ]
1685                 ];
1686         }
1687
1688         /**
1689          * @dataProvider provideNewMutableRevisionFromArray
1690          * @covers \MediaWiki\Revision\RevisionStore::newMutableRevisionFromArray
1691          */
1692         public function testNewMutableRevisionFromArray( array $array ) {
1693                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1694
1695                 // HACK: if $array['page'] is given, make sure that the page exists
1696                 if ( isset( $array['page'] ) ) {
1697                         $t = Title::newFromID( $array['page'] );
1698                         if ( !$t || !$t->exists() ) {
1699                                 $t = Title::makeTitle( NS_MAIN, __METHOD__ );
1700                                 $info = $this->insertPage( $t );
1701                                 $array['page'] = $info['id'];
1702                         }
1703                 }
1704
1705                 $result = $store->newMutableRevisionFromArray( $array );
1706
1707                 if ( isset( $array['id'] ) ) {
1708                         $this->assertSame( $array['id'], $result->getId() );
1709                 }
1710                 if ( isset( $array['page'] ) ) {
1711                         $this->assertSame( $array['page'], $result->getPageId() );
1712                 }
1713                 $this->assertSame( $array['timestamp'], $result->getTimestamp() );
1714                 $this->assertSame( $array['user_text'], $result->getUser()->getName() );
1715                 if ( isset( $array['user'] ) ) {
1716                         $this->assertSame( $array['user'], $result->getUser()->getId() );
1717                 }
1718                 $this->assertSame( (bool)$array['minor_edit'], $result->isMinor() );
1719                 $this->assertSame( $array['deleted'], $result->getVisibility() );
1720                 $this->assertSame( $array['len'], $result->getSize() );
1721                 $this->assertSame( $array['parent_id'], $result->getParentId() );
1722                 $this->assertSame( $array['sha1'], $result->getSha1() );
1723                 $this->assertSame( $array['comment'], $result->getComment()->text );
1724                 if ( isset( $array['content'] ) ) {
1725                         foreach ( $array['content'] as $role => $content ) {
1726                                 $this->assertTrue(
1727                                         $result->getContent( $role )->equals( $content )
1728                                 );
1729                         }
1730                 } elseif ( isset( $array['text'] ) ) {
1731                         $this->assertSame( $array['text'],
1732                                 $result->getSlot( SlotRecord::MAIN )->getContent()->serialize() );
1733                 } elseif ( isset( $array['content_format'] ) ) {
1734                         $this->assertSame(
1735                                 $array['content_format'],
1736                                 $result->getSlot( SlotRecord::MAIN )->getContent()->getDefaultFormat()
1737                         );
1738                         $this->assertSame( $array['content_model'], $result->getSlot( SlotRecord::MAIN )->getModel() );
1739                 }
1740         }
1741
1742         /**
1743          * @dataProvider provideNewMutableRevisionFromArray
1744          * @covers \MediaWiki\Revision\RevisionStore::newMutableRevisionFromArray
1745          */
1746         public function testNewMutableRevisionFromArray_legacyEncoding( array $array ) {
1747                 $cache = new WANObjectCache( [ 'cache' => new HashBagOStuff() ] );
1748                 $services = MediaWikiServices::getInstance();
1749                 $lb = $services->getDBLoadBalancer();
1750                 $access = $services->getExternalStoreAccess();
1751                 $blobStore = new SqlBlobStore( $lb, $access, $cache );
1752                 $blobStore->setLegacyEncoding( 'windows-1252', Language::factory( 'en' ) );
1753
1754                 $factory = $this->getMockBuilder( BlobStoreFactory::class )
1755                         ->setMethods( [ 'newBlobStore', 'newSqlBlobStore' ] )
1756                         ->disableOriginalConstructor()
1757                         ->getMock();
1758                 $factory->expects( $this->any() )
1759                         ->method( 'newBlobStore' )
1760                         ->willReturn( $blobStore );
1761                 $factory->expects( $this->any() )
1762                         ->method( 'newSqlBlobStore' )
1763                         ->willReturn( $blobStore );
1764
1765                 $this->setService( 'BlobStoreFactory', $factory );
1766
1767                 $this->testNewMutableRevisionFromArray( $array );
1768         }
1769
1770         /**
1771          * Creates a new revision for testing caching behavior
1772          *
1773          * @param WikiPage $page the page for the new revision
1774          * @param RevisionStore $store store object to use for creating the revision
1775          * @return bool|RevisionStoreRecord the revision created, or false if missing
1776          */
1777         private function createRevisionStoreCacheRecord( $page, $store ) {
1778                 $user = MediaWikiTestCase::getMutableTestUser()->getUser();
1779                 $updater = $page->newPageUpdater( $user );
1780                 $updater->setContent( SlotRecord::MAIN, new WikitextContent( __METHOD__ ) );
1781                 $summary = CommentStoreComment::newUnsavedComment( __METHOD__ );
1782                 $rev = $updater->saveRevision( $summary, EDIT_NEW );
1783                 return $store->getKnownCurrentRevision( $page->getTitle(), $rev->getId() );
1784         }
1785
1786         /**
1787          * @covers \MediaWiki\Revision\RevisionStore::getKnownCurrentRevision
1788          */
1789         public function testGetKnownCurrentRevision_userNameChange() {
1790                 global $wgActorTableSchemaMigrationStage;
1791
1792                 $cache = new WANObjectCache( [ 'cache' => new HashBagOStuff() ] );
1793                 $this->setService( 'MainWANObjectCache', $cache );
1794
1795                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1796                 $page = $this->getNonexistingTestPage();
1797                 $rev = $this->createRevisionStoreCacheRecord( $page, $store );
1798
1799                 // Grab the user name
1800                 $userNameBefore = $rev->getUser()->getName();
1801
1802                 // Change the user name in the database, "behind the back" of the cache
1803                 $newUserName = "Renamed $userNameBefore";
1804                 $this->db->update( 'revision',
1805                         [ 'rev_user_text' => $newUserName ],
1806                         [ 'rev_id' => $rev->getId() ] );
1807                 $this->db->update( 'user',
1808                         [ 'user_name' => $newUserName ],
1809                         [ 'user_id' => $rev->getUser()->getId() ] );
1810                 if ( $wgActorTableSchemaMigrationStage & SCHEMA_COMPAT_WRITE_NEW ) {
1811                         $this->db->update( 'actor',
1812                                 [ 'actor_name' => $newUserName ],
1813                                 [ 'actor_user' => $rev->getUser()->getId() ] );
1814                 }
1815
1816                 // Reload the revision and regrab the user name.
1817                 $revAfter = $store->getKnownCurrentRevision( $page->getTitle(), $rev->getId() );
1818                 $userNameAfter = $revAfter->getUser()->getName();
1819
1820                 // The two user names should be different.
1821                 // If they are the same, we are seeing a cached value, which is bad.
1822                 $this->assertNotSame( $userNameBefore, $userNameAfter );
1823
1824                 // This is implied by the above assertion, but explicitly check it, for completeness
1825                 $this->assertSame( $newUserName, $userNameAfter );
1826         }
1827
1828         /**
1829          * @covers \MediaWiki\Revision\RevisionStore::getKnownCurrentRevision
1830          */
1831         public function testGetKnownCurrentRevision_revDelete() {
1832                 $cache = new WANObjectCache( [ 'cache' => new HashBagOStuff() ] );
1833                 $this->setService( 'MainWANObjectCache', $cache );
1834
1835                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1836                 $page = $this->getNonexistingTestPage();
1837                 $rev = $this->createRevisionStoreCacheRecord( $page, $store );
1838
1839                 // Grab the deleted bitmask
1840                 $deletedBefore = $rev->getVisibility();
1841
1842                 // Change the deleted bitmask in the database, "behind the back" of the cache
1843                 $this->db->update( 'revision',
1844                         [ 'rev_deleted' => RevisionRecord::DELETED_TEXT ],
1845                         [ 'rev_id' => $rev->getId() ] );
1846
1847                 // Reload the revision and regrab the visibility flag.
1848                 $revAfter = $store->getKnownCurrentRevision( $page->getTitle(), $rev->getId() );
1849                 $deletedAfter = $revAfter->getVisibility();
1850
1851                 // The two deleted flags should be different.
1852                 // If they are the same, we are seeing a cached value, which is bad.
1853                 $this->assertNotSame( $deletedBefore, $deletedAfter );
1854
1855                 // This is implied by the above assertion, but explicitly check it, for completeness
1856                 $this->assertSame( RevisionRecord::DELETED_TEXT, $deletedAfter );
1857         }
1858
1859         /**
1860          * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRow
1861          */
1862         public function testNewRevisionFromRow_userNameChange() {
1863                 global $wgActorTableSchemaMigrationStage;
1864
1865                 $page = $this->getTestPage();
1866                 $text = __METHOD__;
1867                 /** @var Revision $rev */
1868                 $rev = $page->doEditContent(
1869                         new WikitextContent( $text ),
1870                         __METHOD__,
1871                         0,
1872                         false,
1873                         $this->getMutableTestUser()->getUser()
1874                 )->value['revision'];
1875
1876                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1877                 $record = $store->newRevisionFromRow(
1878                         $this->revisionToRow( $rev ),
1879                         [],
1880                         $page->getTitle()
1881                 );
1882
1883                 // Grab the user name
1884                 $userNameBefore = $record->getUser()->getName();
1885
1886                 // Change the user name in the database
1887                 $newUserName = "Renamed $userNameBefore";
1888                 $this->db->update( 'revision',
1889                         [ 'rev_user_text' => $newUserName ],
1890                         [ 'rev_id' => $record->getId() ] );
1891                 $this->db->update( 'user',
1892                         [ 'user_name' => $newUserName ],
1893                         [ 'user_id' => $record->getUser()->getId() ] );
1894                 if ( $wgActorTableSchemaMigrationStage & SCHEMA_COMPAT_WRITE_NEW ) {
1895                         $this->db->update( 'actor',
1896                                 [ 'actor_name' => $newUserName ],
1897                                 [ 'actor_user' => $record->getUser()->getId() ] );
1898                 }
1899
1900                 // Reload the record, passing $fromCache as true to force fresh info from the db,
1901                 // and regrab the user name
1902                 $recordAfter = $store->newRevisionFromRow(
1903                         $this->revisionToRow( $rev ),
1904                         [],
1905                         $page->getTitle(),
1906                         true
1907                 );
1908                 $userNameAfter = $recordAfter->getUser()->getName();
1909
1910                 // The two user names should be different.
1911                 // If they are the same, we are seeing a cached value, which is bad.
1912                 $this->assertNotSame( $userNameBefore, $userNameAfter );
1913
1914                 // This is implied by the above assertion, but explicitly check it, for completeness
1915                 $this->assertSame( $newUserName, $userNameAfter );
1916         }
1917
1918         /**
1919          * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRow
1920          */
1921         public function testNewRevisionFromRow_revDelete() {
1922                 $page = $this->getTestPage();
1923                 $text = __METHOD__;
1924                 /** @var Revision $rev */
1925                 $rev = $page->doEditContent(
1926                         new WikitextContent( $text ),
1927                         __METHOD__
1928                 )->value['revision'];
1929
1930                 $store = MediaWikiServices::getInstance()->getRevisionStore();
1931                 $record = $store->newRevisionFromRow(
1932                         $this->revisionToRow( $rev ),
1933                         [],
1934                         $page->getTitle()
1935                 );
1936
1937                 // Grab the deleted bitmask
1938                 $deletedBefore = $record->getVisibility();
1939
1940                 // Change the deleted bitmask in the database
1941                 $this->db->update( 'revision',
1942                         [ 'rev_deleted' => RevisionRecord::DELETED_TEXT ],
1943                         [ 'rev_id' => $record->getId() ] );
1944
1945                 // Reload the record, passing $fromCache as true to force fresh info from the db,
1946                 // and regrab the deleted bitmask
1947                 $recordAfter = $store->newRevisionFromRow(
1948                         $this->revisionToRow( $rev ),
1949                         [],
1950                         $page->getTitle(),
1951                         true
1952                 );
1953                 $deletedAfter = $recordAfter->getVisibility();
1954
1955                 // The two deleted flags should be different, because we modified the database.
1956                 $this->assertNotSame( $deletedBefore, $deletedAfter );
1957
1958                 // This is implied by the above assertion, but explicitly check it, for completeness
1959                 $this->assertSame( RevisionRecord::DELETED_TEXT, $deletedAfter );
1960         }
1961
1962 }