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