3 namespace MediaWiki\Tests\Revision
;
5 use CommentStoreComment
;
9 use InvalidArgumentException
;
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
;
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
;
41 * @group RevisionStore
43 abstract class RevisionStoreDbTestBase
extends MediaWikiTestCase
{
48 private $testPageTitle;
58 abstract protected function getMcrMigrationStage();
63 protected function getContentHandlerUseDB() {
70 abstract protected function getMcrTablesToReset();
72 public function setUp() {
74 $this->tablesUsed
[] = 'archive';
75 $this->tablesUsed
[] = 'page';
76 $this->tablesUsed
[] = 'revision';
77 $this->tablesUsed
[] = 'comment';
79 $this->tablesUsed +
= $this->getMcrTablesToReset();
81 $this->setMwGlobals( [
82 'wgMultiContentRevisionSchemaMigrationStage' => $this->getMcrMigrationStage(),
83 'wgContentHandlerUseDB' => $this->getContentHandlerUseDB(),
84 'wgActorTableSchemaMigrationStage' => SCHEMA_COMPAT_NEW
,
88 protected function addCoreDBData() {
89 // Blank out. This would fail with a modified schema, and we don't need it.
95 protected function getTestPageTitle() {
96 if ( $this->testPageTitle
) {
97 return $this->testPageTitle
;
100 $this->testPageTitle
= Title
::newFromText( 'UTPage-' . __CLASS__
);
101 return $this->testPageTitle
;
107 protected function getTestPage() {
108 if ( $this->testPage
) {
109 return $this->testPage
;
112 $title = $this->getTestPageTitle();
113 $this->testPage
= WikiPage
::factory( $title );
115 if ( !$this->testPage
->exists() ) {
116 // Make sure we don't write to the live db.
117 $this->ensureMockDatabaseConnection( wfGetDB( DB_MASTER
) );
119 $user = static::getTestSysop()->getUser();
121 $this->testPage
->doEditContent(
122 new WikitextContent( 'UTContent-' . __CLASS__
),
123 'UTPageSummary-' . __CLASS__
,
124 EDIT_NEW | EDIT_SUPPRESS_RC
,
130 return $this->testPage
;
134 * @return LoadBalancer|PHPUnit_Framework_MockObject_MockObject
136 private function getLoadBalancerMock( array $server ) {
137 $domain = new DatabaseDomain( $server['dbname'], null, $server['tablePrefix'] );
139 $lb = $this->getMockBuilder( LoadBalancer
::class )
140 ->setMethods( [ 'reallyOpenConnection' ] )
141 ->setConstructorArgs( [
142 [ 'servers' => [ $server ], 'localDomain' => $domain ]
146 $lb->method( 'reallyOpenConnection' )->willReturnCallback(
147 function ( array $server, $dbNameOverride ) {
148 return $this->getDatabaseMock( $server );
156 * @return Database|PHPUnit_Framework_MockObject_MockObject
158 private function getDatabaseMock( array $params ) {
159 $db = $this->getMockBuilder( DatabaseSqlite
::class )
160 ->setMethods( [ 'select', 'doQuery', 'open', 'closeConnection', 'isOpen' ] )
161 ->setConstructorArgs( [ $params ] )
164 $db->method( 'select' )->willReturn( new FakeResultWrapper( [] ) );
165 $db->method( 'isOpen' )->willReturn( true );
170 public function provideDomainCheck() {
171 yield
[ false, 'test', '' ];
172 yield
[ 'test', 'test', '' ];
174 yield
[ false, 'test', 'foo_' ];
175 yield
[ 'test-foo_', 'test', 'foo_' ];
177 yield
[ false, 'dash-test', '' ];
178 yield
[ 'dash-test', 'dash-test', '' ];
180 yield
[ false, 'underscore_test', 'foo_' ];
181 yield
[ 'underscore_test-foo_', 'underscore_test', 'foo_' ];
185 * @dataProvider provideDomainCheck
186 * @covers \MediaWiki\Revision\RevisionStore::checkDatabaseDomain
188 public function testDomainCheck( $wikiId, $dbName, $dbPrefix ) {
191 'wgDBname' => $dbName,
192 'wgDBprefix' => $dbPrefix,
196 $loadBalancer = $this->getLoadBalancerMock(
199 'dbDirectory' => '*dummy*',
201 'password' => 'test',
209 'trxProfiler' => new TransactionProfiler(),
210 'connLogger' => new \Psr\Log\
NullLogger(),
211 'queryLogger' => new \Psr\Log\
NullLogger(),
212 'errorLogger' => function () {
214 'deprecationLogger' => function () {
218 'tablePrefix' => $dbPrefix,
221 $db = $loadBalancer->getConnection( DB_REPLICA
);
223 /** @var SqlBlobStore $blobStore */
224 $blobStore = $this->getMockBuilder( SqlBlobStore
::class )
225 ->disableOriginalConstructor()
228 $store = new RevisionStore(
231 new WANObjectCache( [ 'cache' => new HashBagOStuff() ] ),
232 MediaWikiServices
::getInstance()->getCommentStore(),
233 MediaWikiServices
::getInstance()->getContentModelStore(),
234 MediaWikiServices
::getInstance()->getSlotRoleStore(),
235 MediaWikiServices
::getInstance()->getSlotRoleRegistry(),
236 $this->getMcrMigrationStage(),
237 MediaWikiServices
::getInstance()->getActorMigration(),
241 $count = $store->countRevisionsByPageId( $db, 0 );
243 // Dummy check to make PhpUnit happy. We are really only interested in
244 // countRevisionsByPageId not failing due to the DB domain check.
245 $this->assertSame( 0, $count );
248 protected function assertLinkTargetsEqual( LinkTarget
$l1, LinkTarget
$l2 ) {
249 $this->assertEquals( $l1->getDBkey(), $l2->getDBkey() );
250 $this->assertEquals( $l1->getNamespace(), $l2->getNamespace() );
251 $this->assertEquals( $l1->getFragment(), $l2->getFragment() );
252 $this->assertEquals( $l1->getInterwiki(), $l2->getInterwiki() );
255 protected function assertRevisionRecordsEqual( RevisionRecord
$r1, RevisionRecord
$r2 ) {
257 $r1->getPageAsLinkTarget()->getNamespace(),
258 $r2->getPageAsLinkTarget()->getNamespace()
262 $r1->getPageAsLinkTarget()->getText(),
263 $r2->getPageAsLinkTarget()->getText()
266 if ( $r1->getParentId() ) {
267 $this->assertEquals( $r1->getParentId(), $r2->getParentId() );
270 $this->assertEquals( $r1->getUser()->getName(), $r2->getUser()->getName() );
271 $this->assertEquals( $r1->getUser()->getId(), $r2->getUser()->getId() );
272 $this->assertEquals( $r1->getComment(), $r2->getComment() );
273 $this->assertEquals( $r1->getTimestamp(), $r2->getTimestamp() );
274 $this->assertEquals( $r1->getVisibility(), $r2->getVisibility() );
275 $this->assertEquals( $r1->getSha1(), $r2->getSha1() );
276 $this->assertEquals( $r1->getSize(), $r2->getSize() );
277 $this->assertEquals( $r1->getPageId(), $r2->getPageId() );
278 $this->assertArrayEquals( $r1->getSlotRoles(), $r2->getSlotRoles() );
279 $this->assertEquals( $r1->getWikiId(), $r2->getWikiId() );
280 $this->assertEquals( $r1->isMinor(), $r2->isMinor() );
281 foreach ( $r1->getSlotRoles() as $role ) {
282 $this->assertSlotRecordsEqual( $r1->getSlot( $role ), $r2->getSlot( $role ) );
283 $this->assertTrue( $r1->getContent( $role )->equals( $r2->getContent( $role ) ) );
286 RevisionRecord
::DELETED_TEXT
,
287 RevisionRecord
::DELETED_COMMENT
,
288 RevisionRecord
::DELETED_USER
,
289 RevisionRecord
::DELETED_RESTRICTED
,
291 $this->assertEquals( $r1->isDeleted( $field ), $r2->isDeleted( $field ) );
295 protected function assertSlotRecordsEqual( SlotRecord
$s1, SlotRecord
$s2 ) {
296 $this->assertSame( $s1->getRole(), $s2->getRole() );
297 $this->assertSame( $s1->getModel(), $s2->getModel() );
298 $this->assertSame( $s1->getFormat(), $s2->getFormat() );
299 $this->assertSame( $s1->getSha1(), $s2->getSha1() );
300 $this->assertSame( $s1->getSize(), $s2->getSize() );
301 $this->assertTrue( $s1->getContent()->equals( $s2->getContent() ) );
303 $s1->hasRevision() ?
$this->assertSame( $s1->getRevision(), $s2->getRevision() ) : null;
304 $s1->hasAddress() ?
$this->assertSame( $s1->hasAddress(), $s2->hasAddress() ) : null;
307 protected function assertRevisionCompleteness( RevisionRecord
$r ) {
308 $this->assertTrue( $r->hasSlot( SlotRecord
::MAIN
) );
309 $this->assertInstanceOf( SlotRecord
::class, $r->getSlot( SlotRecord
::MAIN
) );
310 $this->assertInstanceOf( Content
::class, $r->getContent( SlotRecord
::MAIN
) );
312 foreach ( $r->getSlotRoles() as $role ) {
313 $this->assertSlotCompleteness( $r, $r->getSlot( $role ) );
317 protected function assertSlotCompleteness( RevisionRecord
$r, SlotRecord
$slot ) {
318 $this->assertTrue( $slot->hasAddress() );
319 $this->assertSame( $r->getId(), $slot->getRevision() );
321 $this->assertInstanceOf( Content
::class, $slot->getContent() );
325 * @param mixed[] $details
327 * @return RevisionRecord
329 private function getRevisionRecordFromDetailsArray( $details = [] ) {
330 // Convert some values that can't be provided by dataProviders
331 if ( isset( $details['user'] ) && $details['user'] === true ) {
332 $details['user'] = $this->getTestUser()->getUser();
334 if ( isset( $details['page'] ) && $details['page'] === true ) {
335 $details['page'] = $this->getTestPage()->getId();
337 if ( isset( $details['parent'] ) && $details['parent'] === true ) {
338 $details['parent'] = $this->getTestPage()->getLatest();
341 // Create the RevisionRecord with any available data
342 $rev = new MutableRevisionRecord( $this->getTestPageTitle() );
343 isset( $details['slot'] ) ?
$rev->setSlot( $details['slot'] ) : null;
344 isset( $details['parent'] ) ?
$rev->setParentId( $details['parent'] ) : null;
345 isset( $details['page'] ) ?
$rev->setPageId( $details['page'] ) : null;
346 isset( $details['size'] ) ?
$rev->setSize( $details['size'] ) : null;
347 isset( $details['sha1'] ) ?
$rev->setSha1( $details['sha1'] ) : null;
348 isset( $details['comment'] ) ?
$rev->setComment( $details['comment'] ) : null;
349 isset( $details['timestamp'] ) ?
$rev->setTimestamp( $details['timestamp'] ) : null;
350 isset( $details['minor'] ) ?
$rev->setMinorEdit( $details['minor'] ) : null;
351 isset( $details['user'] ) ?
$rev->setUser( $details['user'] ) : null;
352 isset( $details['visibility'] ) ?
$rev->setVisibility( $details['visibility'] ) : null;
353 isset( $details['id'] ) ?
$rev->setId( $details['id'] ) : null;
355 if ( isset( $details['content'] ) ) {
356 foreach ( $details['content'] as $role => $content ) {
357 $rev->setContent( $role, $content );
364 public function provideInsertRevisionOn_successes() {
365 yield
'Bare minimum revision insertion' => [
367 'slot' => SlotRecord
::newUnsaved( SlotRecord
::MAIN
, new WikitextContent( 'Chicken' ) ),
369 'comment' => $this->getRandomCommentStoreComment(),
370 'timestamp' => '20171117010101',
374 yield
'Detailed revision insertion' => [
376 'slot' => SlotRecord
::newUnsaved( SlotRecord
::MAIN
, new WikitextContent( 'Chicken' ) ),
379 'comment' => $this->getRandomCommentStoreComment(),
380 'timestamp' => '20171117010101',
383 'visibility' => RevisionRecord
::DELETED_RESTRICTED
,
388 protected function getRandomCommentStoreComment() {
389 return CommentStoreComment
::newUnsavedComment( __METHOD__
. '.' . rand( 0, 1000 ) );
393 * @dataProvider provideInsertRevisionOn_successes
394 * @covers \MediaWiki\Revision\RevisionStore::insertRevisionOn
395 * @covers \MediaWiki\Revision\RevisionStore::insertSlotRowOn
396 * @covers \MediaWiki\Revision\RevisionStore::insertContentRowOn
398 public function testInsertRevisionOn_successes(
399 array $revDetails = []
401 $title = $this->getTestPageTitle();
402 $rev = $this->getRevisionRecordFromDetailsArray( $revDetails );
404 $store = MediaWikiServices
::getInstance()->getRevisionStore();
405 $return = $store->insertRevisionOn( $rev, wfGetDB( DB_MASTER
) );
407 // is the new revision correct?
408 $this->assertRevisionCompleteness( $return );
409 $this->assertLinkTargetsEqual( $title, $return->getPageAsLinkTarget() );
410 $this->assertRevisionRecordsEqual( $rev, $return );
412 // can we load it from the store?
413 $loaded = $store->getRevisionById( $return->getId() );
414 $this->assertRevisionCompleteness( $loaded );
415 $this->assertRevisionRecordsEqual( $return, $loaded );
417 // can we find it directly in the database?
418 $this->assertRevisionExistsInDatabase( $return );
421 protected function assertRevisionExistsInDatabase( RevisionRecord
$rev ) {
422 $row = $this->revisionToRow( new Revision( $rev ), [] );
424 // unset nulled fields
425 unset( $row->rev_content_model
);
426 unset( $row->rev_content_format
);
429 unset( $row->rev_comment_text
);
430 unset( $row->rev_comment_data
);
431 unset( $row->rev_comment_cid
);
432 unset( $row->rev_comment_id
);
434 $store = MediaWikiServices
::getInstance()->getRevisionStore();
435 $queryInfo = $store->getQueryInfo( [ 'user' ] );
437 $row = get_object_vars( $row );
439 // Use aliased fields from $queryInfo, e.g. rev_user
440 $keys = array_keys( $row );
441 $keys = array_combine( $keys, $keys );
442 $fields = array_intersect_key( $queryInfo['fields'], $keys ) +
$keys;
444 // assertSelect() fails unless the orders match.
449 $queryInfo['tables'],
451 [ 'rev_id' => $rev->getId() ],
452 [ array_values( $row ) ],
459 * @param SlotRecord $a
460 * @param SlotRecord $b
462 protected function assertSameSlotContent( SlotRecord
$a, SlotRecord
$b ) {
463 // Assert that the same blob address has been used.
464 $this->assertSame( $a->getAddress(), $b->getAddress() );
468 * @covers \MediaWiki\Revision\RevisionStore::insertRevisionOn
470 public function testInsertRevisionOn_blobAddressExists() {
471 $title = $this->getTestPageTitle();
473 'slot' => SlotRecord
::newUnsaved( SlotRecord
::MAIN
, new WikitextContent( 'Chicken' ) ),
475 'comment' => $this->getRandomCommentStoreComment(),
476 'timestamp' => '20171117010101',
480 $store = MediaWikiServices
::getInstance()->getRevisionStore();
482 // Insert the first revision
483 $revOne = $this->getRevisionRecordFromDetailsArray( $revDetails );
484 $firstReturn = $store->insertRevisionOn( $revOne, wfGetDB( DB_MASTER
) );
485 $this->assertLinkTargetsEqual( $title, $firstReturn->getPageAsLinkTarget() );
486 $this->assertRevisionRecordsEqual( $revOne, $firstReturn );
488 // Insert a second revision inheriting the same blob address
489 $revDetails['slot'] = SlotRecord
::newInherited( $firstReturn->getSlot( SlotRecord
::MAIN
) );
490 $revTwo = $this->getRevisionRecordFromDetailsArray( $revDetails );
491 $secondReturn = $store->insertRevisionOn( $revTwo, wfGetDB( DB_MASTER
) );
492 $this->assertLinkTargetsEqual( $title, $secondReturn->getPageAsLinkTarget() );
493 $this->assertRevisionRecordsEqual( $revTwo, $secondReturn );
495 $firstMainSlot = $firstReturn->getSlot( SlotRecord
::MAIN
);
496 $secondMainSlot = $secondReturn->getSlot( SlotRecord
::MAIN
);
498 $this->assertSameSlotContent( $firstMainSlot, $secondMainSlot );
500 // And that different revisions have been created.
501 $this->assertNotSame( $firstReturn->getId(), $secondReturn->getId() );
503 // Make sure the slot rows reference the correct revision
504 $this->assertSame( $firstReturn->getId(), $firstMainSlot->getRevision() );
505 $this->assertSame( $secondReturn->getId(), $secondMainSlot->getRevision() );
508 public function provideInsertRevisionOn_failures() {
511 'comment' => $this->getRandomCommentStoreComment(),
512 'timestamp' => '20171117010101',
515 new InvalidArgumentException( 'main slot must be provided' )
517 yield
'no main slot' => [
519 'slot' => SlotRecord
::newUnsaved( 'aux', new WikitextContent( 'Turkey' ) ),
520 'comment' => $this->getRandomCommentStoreComment(),
521 'timestamp' => '20171117010101',
524 new InvalidArgumentException( 'main slot must be provided' )
526 yield
'no timestamp' => [
528 'slot' => SlotRecord
::newUnsaved( SlotRecord
::MAIN
, new WikitextContent( 'Chicken' ) ),
529 'comment' => $this->getRandomCommentStoreComment(),
532 new IncompleteRevisionException( 'timestamp field must not be NULL!' )
534 yield
'no comment' => [
536 'slot' => SlotRecord
::newUnsaved( SlotRecord
::MAIN
, new WikitextContent( 'Chicken' ) ),
537 'timestamp' => '20171117010101',
540 new IncompleteRevisionException( 'comment must not be NULL!' )
544 'slot' => SlotRecord
::newUnsaved( SlotRecord
::MAIN
, new WikitextContent( 'Chicken' ) ),
545 'comment' => $this->getRandomCommentStoreComment(),
546 'timestamp' => '20171117010101',
548 new IncompleteRevisionException( 'user must not be NULL!' )
553 * @dataProvider provideInsertRevisionOn_failures
554 * @covers \MediaWiki\Revision\RevisionStore::insertRevisionOn
556 public function testInsertRevisionOn_failures(
557 array $revDetails = [],
560 $rev = $this->getRevisionRecordFromDetailsArray( $revDetails );
562 $store = MediaWikiServices
::getInstance()->getRevisionStore();
564 $this->setExpectedException(
565 get_class( $exception ),
566 $exception->getMessage(),
567 $exception->getCode()
569 $store->insertRevisionOn( $rev, wfGetDB( DB_MASTER
) );
572 public function provideNewNullRevision() {
574 Title
::newFromText( 'UTPage_notAutoCreated' ),
575 [ 'content' => [ 'main' => new WikitextContent( 'Flubber1' ) ] ],
576 CommentStoreComment
::newUnsavedComment( __METHOD__
. ' comment1' ),
580 Title
::newFromText( 'UTPage_notAutoCreated' ),
581 [ 'content' => [ 'main' => new WikitextContent( 'Flubber2' ) ] ],
582 CommentStoreComment
::newUnsavedComment( __METHOD__
. ' comment2', [ 'a' => 1 ] ),
588 * @dataProvider provideNewNullRevision
589 * @covers \MediaWiki\Revision\RevisionStore::newNullRevision
590 * @covers \MediaWiki\Revision\RevisionStore::findSlotContentId
592 public function testNewNullRevision( Title
$title, $revDetails, $comment, $minor = false ) {
593 $user = TestUserRegistry
::getMutableTestUser( __METHOD__
)->getUser();
594 $page = WikiPage
::factory( $title );
596 if ( !$page->exists() ) {
597 $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
, EDIT_NEW
);
600 $revDetails['page'] = $page->getId();
601 $revDetails['timestamp'] = wfTimestampNow();
602 $revDetails['comment'] = CommentStoreComment
::newUnsavedComment( 'Base' );
603 $revDetails['user'] = $user;
605 $baseRev = $this->getRevisionRecordFromDetailsArray( $revDetails );
606 $store = MediaWikiServices
::getInstance()->getRevisionStore();
608 $dbw = wfGetDB( DB_MASTER
);
609 $baseRev = $store->insertRevisionOn( $baseRev, $dbw );
610 $page->updateRevisionOn( $dbw, new Revision( $baseRev ), $page->getLatest() );
612 $record = $store->newNullRevision(
613 wfGetDB( DB_MASTER
),
620 $this->assertEquals( $title->getNamespace(), $record->getPageAsLinkTarget()->getNamespace() );
621 $this->assertEquals( $title->getDBkey(), $record->getPageAsLinkTarget()->getDBkey() );
622 $this->assertEquals( $comment, $record->getComment() );
623 $this->assertEquals( $minor, $record->isMinor() );
624 $this->assertEquals( $user->getName(), $record->getUser()->getName() );
625 $this->assertEquals( $baseRev->getId(), $record->getParentId() );
627 $this->assertArrayEquals(
628 $baseRev->getSlotRoles(),
629 $record->getSlotRoles()
632 foreach ( $baseRev->getSlotRoles() as $role ) {
633 $parentSlot = $baseRev->getSlot( $role );
634 $slot = $record->getSlot( $role );
636 $this->assertTrue( $slot->isInherited(), 'isInherited' );
637 $this->assertSame( $parentSlot->getOrigin(), $slot->getOrigin(), 'getOrigin' );
638 $this->assertSameSlotContent( $parentSlot, $slot );
643 * @covers \MediaWiki\Revision\RevisionStore::newNullRevision
645 public function testNewNullRevision_nonExistingTitle() {
646 $store = MediaWikiServices
::getInstance()->getRevisionStore();
647 $record = $store->newNullRevision(
648 wfGetDB( DB_MASTER
),
649 Title
::newFromText( __METHOD__
. '.iDontExist!' ),
650 CommentStoreComment
::newUnsavedComment( __METHOD__
. ' comment' ),
652 TestUserRegistry
::getMutableTestUser( __METHOD__
)->getUser()
654 $this->assertNull( $record );
658 * @covers \MediaWiki\Revision\RevisionStore::getRcIdIfUnpatrolled
660 public function testGetRcIdIfUnpatrolled_returnsRecentChangesId() {
661 $page = $this->getTestPage();
662 $status = $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
);
663 /** @var Revision $rev */
664 $rev = $status->value
['revision'];
666 $store = MediaWikiServices
::getInstance()->getRevisionStore();
667 $revisionRecord = $store->getRevisionById( $rev->getId() );
668 $result = $store->getRcIdIfUnpatrolled( $revisionRecord );
670 $this->assertGreaterThan( 0, $result );
672 $store->getRecentChange( $revisionRecord )->getAttribute( 'rc_id' ),
678 * @covers \MediaWiki\Revision\RevisionStore::getRcIdIfUnpatrolled
680 public function testGetRcIdIfUnpatrolled_returnsZeroIfPatrolled() {
681 // This assumes that sysops are auto patrolled
682 $sysop = $this->getTestSysop()->getUser();
683 $page = $this->getTestPage();
684 $status = $page->doEditContent(
685 new WikitextContent( __METHOD__
),
691 /** @var Revision $rev */
692 $rev = $status->value
['revision'];
694 $store = MediaWikiServices
::getInstance()->getRevisionStore();
695 $revisionRecord = $store->getRevisionById( $rev->getId() );
696 $result = $store->getRcIdIfUnpatrolled( $revisionRecord );
698 $this->assertSame( 0, $result );
702 * @covers \MediaWiki\Revision\RevisionStore::getRecentChange
704 public function testGetRecentChange() {
705 $page = $this->getTestPage();
706 $content = new WikitextContent( __METHOD__
);
707 $status = $page->doEditContent( $content, __METHOD__
);
708 /** @var Revision $rev */
709 $rev = $status->value
['revision'];
711 $store = MediaWikiServices
::getInstance()->getRevisionStore();
712 $revRecord = $store->getRevisionById( $rev->getId() );
713 $recentChange = $store->getRecentChange( $revRecord );
715 $this->assertEquals( $rev->getId(), $recentChange->getAttribute( 'rc_this_oldid' ) );
716 $this->assertEquals( $rev->getRecentChange(), $recentChange );
720 * @covers \MediaWiki\Revision\RevisionStore::getRevisionById
722 public function testGetRevisionById() {
723 $page = $this->getTestPage();
724 $content = new WikitextContent( __METHOD__
);
725 $status = $page->doEditContent( $content, __METHOD__
);
726 /** @var Revision $rev */
727 $rev = $status->value
['revision'];
729 $store = MediaWikiServices
::getInstance()->getRevisionStore();
730 $revRecord = $store->getRevisionById( $rev->getId() );
732 $this->assertSame( $rev->getId(), $revRecord->getId() );
733 $this->assertTrue( $revRecord->getSlot( SlotRecord
::MAIN
)->getContent()->equals( $content ) );
734 $this->assertSame( __METHOD__
, $revRecord->getComment()->text
);
738 * @covers \MediaWiki\Revision\RevisionStore::getRevisionByTitle
740 public function testGetRevisionByTitle() {
741 $page = $this->getTestPage();
742 $content = new WikitextContent( __METHOD__
);
743 $status = $page->doEditContent( $content, __METHOD__
);
744 /** @var Revision $rev */
745 $rev = $status->value
['revision'];
747 $store = MediaWikiServices
::getInstance()->getRevisionStore();
748 $revRecord = $store->getRevisionByTitle( $page->getTitle() );
750 $this->assertSame( $rev->getId(), $revRecord->getId() );
751 $this->assertTrue( $revRecord->getSlot( SlotRecord
::MAIN
)->getContent()->equals( $content ) );
752 $this->assertSame( __METHOD__
, $revRecord->getComment()->text
);
756 * @covers \MediaWiki\Revision\RevisionStore::getRevisionByPageId
758 public function testGetRevisionByPageId() {
759 $page = $this->getTestPage();
760 $content = new WikitextContent( __METHOD__
);
761 $status = $page->doEditContent( $content, __METHOD__
);
762 /** @var Revision $rev */
763 $rev = $status->value
['revision'];
765 $store = MediaWikiServices
::getInstance()->getRevisionStore();
766 $revRecord = $store->getRevisionByPageId( $page->getId() );
768 $this->assertSame( $rev->getId(), $revRecord->getId() );
769 $this->assertTrue( $revRecord->getSlot( SlotRecord
::MAIN
)->getContent()->equals( $content ) );
770 $this->assertSame( __METHOD__
, $revRecord->getComment()->text
);
774 * @covers \MediaWiki\Revision\RevisionStore::getRevisionByTimestamp
776 public function testGetRevisionByTimestamp() {
777 // Make sure there is 1 second between the last revision and the rev we create...
778 // Otherwise we might not get the correct revision and the test may fail...
780 $page = $this->getTestPage();
782 $content = new WikitextContent( __METHOD__
);
783 $status = $page->doEditContent( $content, __METHOD__
);
784 /** @var Revision $rev */
785 $rev = $status->value
['revision'];
787 $store = MediaWikiServices
::getInstance()->getRevisionStore();
788 $revRecord = $store->getRevisionByTimestamp(
793 $this->assertSame( $rev->getId(), $revRecord->getId() );
794 $this->assertTrue( $revRecord->getSlot( SlotRecord
::MAIN
)->getContent()->equals( $content ) );
795 $this->assertSame( __METHOD__
, $revRecord->getComment()->text
);
798 protected function revisionToRow( Revision
$rev, $options = [ 'page', 'user', 'comment' ] ) {
799 // XXX: the WikiPage object loads another RevisionRecord from the database. Not great.
800 $page = WikiPage
::factory( $rev->getTitle() );
803 'rev_id' => (string)$rev->getId(),
804 'rev_page' => (string)$rev->getPage(),
805 'rev_timestamp' => $this->db
->timestamp( $rev->getTimestamp() ),
806 'rev_user_text' => (string)$rev->getUserText(),
807 'rev_user' => (string)$rev->getUser() ?
: null,
808 'rev_minor_edit' => $rev->isMinor() ?
'1' : '0',
809 'rev_deleted' => (string)$rev->getVisibility(),
810 'rev_len' => (string)$rev->getSize(),
811 'rev_parent_id' => (string)$rev->getParentId(),
812 'rev_sha1' => (string)$rev->getSha1(),
815 if ( in_array( 'page', $options ) ) {
817 'page_namespace' => (string)$page->getTitle()->getNamespace(),
818 'page_title' => $page->getTitle()->getDBkey(),
819 'page_id' => (string)$page->getId(),
820 'page_latest' => (string)$page->getLatest(),
821 'page_is_redirect' => $page->isRedirect() ?
'1' : '0',
822 'page_len' => (string)$page->getContent()->getSize(),
826 if ( in_array( 'user', $options ) ) {
828 'user_name' => (string)$rev->getUserText(),
832 if ( in_array( 'comment', $options ) ) {
834 'rev_comment_text' => $rev->getComment(),
835 'rev_comment_data' => null,
836 'rev_comment_cid' => null,
840 if ( $rev->getId() ) {
842 'rev_id' => (string)$rev->getId(),
846 return (object)$fields;
849 protected function assertRevisionRecordMatchesRevision(
851 RevisionRecord
$record
853 $this->assertSame( $rev->getId(), $record->getId() );
854 $this->assertSame( $rev->getPage(), $record->getPageId() );
855 $this->assertSame( $rev->getTimestamp(), $record->getTimestamp() );
856 $this->assertSame( $rev->getUserText(), $record->getUser()->getName() );
857 $this->assertSame( $rev->getUser(), $record->getUser()->getId() );
858 $this->assertSame( $rev->isMinor(), $record->isMinor() );
859 $this->assertSame( $rev->getVisibility(), $record->getVisibility() );
860 $this->assertSame( $rev->getSize(), $record->getSize() );
862 * @note As of MW 1.31, the database schema allows the parent ID to be
863 * NULL to indicate that it is unknown.
865 $expectedParent = $rev->getParentId();
866 if ( $expectedParent === null ) {
869 $this->assertSame( $expectedParent, $record->getParentId() );
870 $this->assertSame( $rev->getSha1(), $record->getSha1() );
871 $this->assertSame( $rev->getComment(), $record->getComment()->text
);
872 $this->assertSame( $rev->getContentFormat(),
873 $record->getContent( SlotRecord
::MAIN
)->getDefaultFormat() );
874 $this->assertSame( $rev->getContentModel(), $record->getContent( SlotRecord
::MAIN
)->getModel() );
875 $this->assertLinkTargetsEqual( $rev->getTitle(), $record->getPageAsLinkTarget() );
877 $revRec = $rev->getRevisionRecord();
878 $revMain = $revRec->getSlot( SlotRecord
::MAIN
);
879 $recMain = $record->getSlot( SlotRecord
::MAIN
);
881 $this->assertSame( $revMain->hasOrigin(), $recMain->hasOrigin(), 'hasOrigin' );
882 $this->assertSame( $revMain->hasAddress(), $recMain->hasAddress(), 'hasAddress' );
883 $this->assertSame( $revMain->hasContentId(), $recMain->hasContentId(), 'hasContentId' );
885 if ( $revMain->hasOrigin() ) {
886 $this->assertSame( $revMain->getOrigin(), $recMain->getOrigin(), 'getOrigin' );
889 if ( $revMain->hasAddress() ) {
890 $this->assertSame( $revMain->getAddress(), $recMain->getAddress(), 'getAddress' );
893 if ( $revMain->hasContentId() ) {
894 // XXX: the content ID value is ill-defined when SCHEMA_COMPAT_WRITE_BOTH and
895 // SCHEMA_COMPAT_READ_OLD is set, since revision insertion will report the
896 // content ID used with the new schema, while loading the revision from the
897 // old schema will report an emulated ID.
898 if ( $this->getMcrMigrationStage() & SCHEMA_COMPAT_READ_NEW
) {
899 $this->assertSame( $revMain->getContentId(), $recMain->getContentId(), 'getContentId' );
905 * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRowAndSlots
906 * @covers \MediaWiki\Revision\RevisionStore::getQueryInfo
908 public function testNewRevisionFromRowAndSlot_getQueryInfo() {
909 $page = $this->getTestPage();
910 $text = __METHOD__
. 'o-ö';
911 /** @var Revision $rev */
912 $rev = $page->doEditContent(
913 new WikitextContent( $text ),
915 )->value
['revision'];
917 $store = MediaWikiServices
::getInstance()->getRevisionStore();
918 $info = $store->getQueryInfo();
919 $row = $this->db
->selectRow(
922 [ 'rev_id' => $rev->getId() ],
928 $info = $store->getSlotsQueryInfo( [ 'content' ] );
929 $slotRows = $this->db
->select(
932 $this->getSlotRevisionConditions( $rev->getId() ),
938 $record = $store->newRevisionFromRowAndSlots(
940 iterator_to_array( $slotRows ),
944 $this->assertRevisionRecordMatchesRevision( $rev, $record );
945 $this->assertSame( $text, $rev->getContent()->serialize() );
949 * Conditions to use together with getSlotsQueryInfo() when selecting slot rows for a given
954 abstract protected function getSlotRevisionConditions( $revId );
957 * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRow
958 * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRowAndSlots
959 * @covers \MediaWiki\Revision\RevisionStore::getQueryInfo
961 public function testNewRevisionFromRow_getQueryInfo() {
962 $page = $this->getTestPage();
963 $text = __METHOD__
. 'a-ä';
964 /** @var Revision $rev */
965 $rev = $page->doEditContent(
966 new WikitextContent( $text ),
968 )->value
['revision'];
970 $store = MediaWikiServices
::getInstance()->getRevisionStore();
971 $info = $store->getQueryInfo();
972 $row = $this->db
->selectRow(
975 [ 'rev_id' => $rev->getId() ],
980 $record = $store->newRevisionFromRow(
985 $this->assertRevisionRecordMatchesRevision( $rev, $record );
986 $this->assertSame( $text, $rev->getContent()->serialize() );
990 * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRow
991 * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRowAndSlots
993 public function testNewRevisionFromRow_anonEdit() {
994 $page = $this->getTestPage();
995 $text = __METHOD__
. 'a-ä';
996 /** @var Revision $rev */
997 $rev = $page->doEditContent(
998 new WikitextContent( $text ),
1000 )->value
['revision'];
1002 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1003 $record = $store->newRevisionFromRow(
1004 $this->revisionToRow( $rev ),
1008 $this->assertRevisionRecordMatchesRevision( $rev, $record );
1009 $this->assertSame( $text, $rev->getContent()->serialize() );
1013 * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRow
1014 * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRowAndSlots
1016 public function testNewRevisionFromRow_anonEdit_legacyEncoding() {
1017 $this->setMwGlobals( 'wgLegacyEncoding', 'windows-1252' );
1018 $page = $this->getTestPage();
1019 $text = __METHOD__
. 'a-ä';
1020 /** @var Revision $rev */
1021 $rev = $page->doEditContent(
1022 new WikitextContent( $text ),
1024 )->value
['revision'];
1026 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1027 $record = $store->newRevisionFromRow(
1028 $this->revisionToRow( $rev ),
1032 $this->assertRevisionRecordMatchesRevision( $rev, $record );
1033 $this->assertSame( $text, $rev->getContent()->serialize() );
1037 * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRow
1038 * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRowAndSlots
1040 public function testNewRevisionFromRow_userEdit() {
1041 $page = $this->getTestPage();
1042 $text = __METHOD__
. 'b-ä';
1043 /** @var Revision $rev */
1044 $rev = $page->doEditContent(
1045 new WikitextContent( $text ),
1049 $this->getTestUser()->getUser()
1050 )->value
['revision'];
1052 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1053 $record = $store->newRevisionFromRow(
1054 $this->revisionToRow( $rev ),
1058 $this->assertRevisionRecordMatchesRevision( $rev, $record );
1059 $this->assertSame( $text, $rev->getContent()->serialize() );
1063 * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromArchiveRow
1064 * @covers \MediaWiki\Revision\RevisionStore::getArchiveQueryInfo
1066 public function testNewRevisionFromArchiveRow_getArchiveQueryInfo() {
1067 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1068 $title = Title
::newFromText( __METHOD__
);
1069 $text = __METHOD__
. '-bä';
1070 $page = WikiPage
::factory( $title );
1071 /** @var Revision $orig */
1072 $orig = $page->doEditContent( new WikitextContent( $text ), __METHOD__
)
1073 ->value
['revision'];
1074 $page->doDeleteArticle( __METHOD__
);
1076 $db = wfGetDB( DB_MASTER
);
1077 $arQuery = $store->getArchiveQueryInfo();
1079 $arQuery['tables'], $arQuery['fields'], [ 'ar_rev_id' => $orig->getId() ],
1080 __METHOD__
, [], $arQuery['joins']
1082 $this->assertTrue( is_object( $res ), 'query failed' );
1084 $row = $res->fetchObject();
1086 $record = $store->newRevisionFromArchiveRow( $row );
1088 $this->assertRevisionRecordMatchesRevision( $orig, $record );
1089 $this->assertSame( $text, $record->getContent( SlotRecord
::MAIN
)->serialize() );
1093 * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromArchiveRow
1095 public function testNewRevisionFromArchiveRow_legacyEncoding() {
1096 $this->setMwGlobals( 'wgLegacyEncoding', 'windows-1252' );
1097 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1098 $title = Title
::newFromText( __METHOD__
);
1099 $text = __METHOD__
. '-bä';
1100 $page = WikiPage
::factory( $title );
1101 /** @var Revision $orig */
1102 $orig = $page->doEditContent( new WikitextContent( $text ), __METHOD__
)
1103 ->value
['revision'];
1104 $page->doDeleteArticle( __METHOD__
);
1106 $db = wfGetDB( DB_MASTER
);
1107 $arQuery = $store->getArchiveQueryInfo();
1109 $arQuery['tables'], $arQuery['fields'], [ 'ar_rev_id' => $orig->getId() ],
1110 __METHOD__
, [], $arQuery['joins']
1112 $this->assertTrue( is_object( $res ), 'query failed' );
1114 $row = $res->fetchObject();
1116 $record = $store->newRevisionFromArchiveRow( $row );
1118 $this->assertRevisionRecordMatchesRevision( $orig, $record );
1119 $this->assertSame( $text, $record->getContent( SlotRecord
::MAIN
)->serialize() );
1123 * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromArchiveRow
1125 public function testNewRevisionFromArchiveRow_no_user() {
1126 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1130 'ar_page_id' => '2',
1131 'ar_namespace' => '0',
1132 'ar_title' => 'Something',
1134 'ar_text_id' => '47',
1135 'ar_timestamp' => '20180528192356',
1136 'ar_minor_edit' => '0',
1137 'ar_deleted' => '0',
1139 'ar_parent_id' => '0',
1140 'ar_sha1' => 'deadbeef',
1141 'ar_comment_text' => 'whatever',
1142 'ar_comment_data' => null,
1143 'ar_comment_cid' => null,
1145 'ar_user_text' => '', // this is the important bit
1147 'ar_content_format' => null,
1148 'ar_content_model' => null,
1151 \Wikimedia\
suppressWarnings();
1152 $record = $store->newRevisionFromArchiveRow( $row );
1153 \Wikimedia\
suppressWarnings( true );
1155 $this->assertInstanceOf( RevisionRecord
::class, $record );
1156 $this->assertInstanceOf( UserIdentityValue
::class, $record->getUser() );
1157 $this->assertSame( 'Unknown user', $record->getUser()->getName() );
1161 * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRow
1162 * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRowAndSlots
1164 public function testNewRevisionFromRow_no_user() {
1165 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1166 $title = Title
::newFromText( __METHOD__
);
1171 'page_namespace' => '0',
1172 'page_title' => $title->getText(),
1173 'rev_text_id' => '47',
1174 'rev_timestamp' => '20180528192356',
1175 'rev_minor_edit' => '0',
1176 'rev_deleted' => '0',
1178 'rev_parent_id' => '0',
1179 'rev_sha1' => 'deadbeef',
1180 'rev_comment_text' => 'whatever',
1181 'rev_comment_data' => null,
1182 'rev_comment_cid' => null,
1184 'rev_user_text' => '', // this is the important bit
1185 'rev_actor' => null,
1186 'rev_content_format' => null,
1187 'rev_content_model' => null,
1190 \Wikimedia\
suppressWarnings();
1191 $record = $store->newRevisionFromRow( $row, 0, $title );
1192 \Wikimedia\
suppressWarnings( true );
1194 $this->assertNotNull( $record );
1195 $this->assertNotNull( $record->getUser() );
1196 $this->assertNotEmpty( $record->getUser()->getName() );
1200 * @covers \MediaWiki\Revision\RevisionStore::insertRevisionOn
1202 public function testInsertRevisionOn_archive() {
1203 // This is a round trip test for deletion and undeletion of a
1204 // revision row via the archive table.
1206 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1207 $title = Title
::newFromText( __METHOD__
);
1209 $page = WikiPage
::factory( $title );
1210 /** @var Revision $origRev */
1211 $page->doEditContent( new WikitextContent( "First" ), __METHOD__
. '-first' );
1212 $origRev = $page->doEditContent( new WikitextContent( "Foo" ), __METHOD__
)
1213 ->value
['revision'];
1214 $orig = $origRev->getRevisionRecord();
1215 $page->doDeleteArticle( __METHOD__
);
1217 // re-create page, so we can later load revisions for it
1218 $page->doEditContent( new WikitextContent( 'Two' ), __METHOD__
);
1220 $db = wfGetDB( DB_MASTER
);
1221 $arQuery = $store->getArchiveQueryInfo();
1222 $row = $db->selectRow(
1223 $arQuery['tables'], $arQuery['fields'], [ 'ar_rev_id' => $orig->getId() ],
1224 __METHOD__
, [], $arQuery['joins']
1227 $this->assertNotFalse( $row, 'query failed' );
1229 $record = $store->newRevisionFromArchiveRow(
1233 [ 'page_id' => $title->getArticleID() ]
1236 $restored = $store->insertRevisionOn( $record, $db );
1238 // is the new revision correct?
1239 $this->assertRevisionCompleteness( $restored );
1240 $this->assertRevisionRecordsEqual( $record, $restored );
1242 // does the new revision use the original slot?
1243 $recMain = $record->getSlot( SlotRecord
::MAIN
);
1244 $restMain = $restored->getSlot( SlotRecord
::MAIN
);
1245 $this->assertSame( $recMain->getAddress(), $restMain->getAddress() );
1246 $this->assertSame( $recMain->getContentId(), $restMain->getContentId() );
1247 $this->assertSame( $recMain->getOrigin(), $restMain->getOrigin() );
1248 $this->assertSame( 'Foo', $restMain->getContent()->serialize() );
1250 // can we load it from the store?
1251 $loaded = $store->getRevisionById( $restored->getId() );
1252 $this->assertNotNull( $loaded );
1253 $this->assertRevisionCompleteness( $loaded );
1254 $this->assertRevisionRecordsEqual( $restored, $loaded );
1256 // can we find it directly in the database?
1257 $this->assertRevisionExistsInDatabase( $restored );
1261 * @covers \MediaWiki\Revision\RevisionStore::loadRevisionFromId
1263 public function testLoadRevisionFromId() {
1264 $title = Title
::newFromText( __METHOD__
);
1265 $page = WikiPage
::factory( $title );
1266 /** @var Revision $rev */
1267 $rev = $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
)
1268 ->value
['revision'];
1270 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1271 $result = $store->loadRevisionFromId( wfGetDB( DB_MASTER
), $rev->getId() );
1272 $this->assertRevisionRecordMatchesRevision( $rev, $result );
1276 * @covers \MediaWiki\Revision\RevisionStore::loadRevisionFromPageId
1278 public function testLoadRevisionFromPageId() {
1279 $title = Title
::newFromText( __METHOD__
);
1280 $page = WikiPage
::factory( $title );
1281 /** @var Revision $rev */
1282 $rev = $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
)
1283 ->value
['revision'];
1285 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1286 $result = $store->loadRevisionFromPageId( wfGetDB( DB_MASTER
), $page->getId() );
1287 $this->assertRevisionRecordMatchesRevision( $rev, $result );
1291 * @covers \MediaWiki\Revision\RevisionStore::loadRevisionFromTitle
1293 public function testLoadRevisionFromTitle() {
1294 $title = Title
::newFromText( __METHOD__
);
1295 $page = WikiPage
::factory( $title );
1296 /** @var Revision $rev */
1297 $rev = $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
)
1298 ->value
['revision'];
1300 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1301 $result = $store->loadRevisionFromTitle( wfGetDB( DB_MASTER
), $title );
1302 $this->assertRevisionRecordMatchesRevision( $rev, $result );
1306 * @covers \MediaWiki\Revision\RevisionStore::loadRevisionFromTimestamp
1308 public function testLoadRevisionFromTimestamp() {
1309 $title = Title
::newFromText( __METHOD__
);
1310 $page = WikiPage
::factory( $title );
1311 /** @var Revision $revOne */
1312 $revOne = $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
)
1313 ->value
['revision'];
1314 // Sleep to ensure different timestamps... )(evil)
1316 /** @var Revision $revTwo */
1317 $revTwo = $page->doEditContent( new WikitextContent( __METHOD__
. 'a' ), '' )
1318 ->value
['revision'];
1320 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1322 $store->loadRevisionFromTimestamp( wfGetDB( DB_MASTER
), $title, '20150101010101' )
1326 $store->loadRevisionFromTimestamp(
1327 wfGetDB( DB_MASTER
),
1329 $revOne->getTimestamp()
1334 $store->loadRevisionFromTimestamp(
1335 wfGetDB( DB_MASTER
),
1337 $revTwo->getTimestamp()
1343 * @covers \MediaWiki\Revision\RevisionStore::listRevisionSizes
1345 public function testGetParentLengths() {
1346 $page = WikiPage
::factory( Title
::newFromText( __METHOD__
) );
1347 /** @var Revision $revOne */
1348 $revOne = $page->doEditContent(
1349 new WikitextContent( __METHOD__
), __METHOD__
1350 )->value
['revision'];
1351 /** @var Revision $revTwo */
1352 $revTwo = $page->doEditContent(
1353 new WikitextContent( __METHOD__
. '2' ), __METHOD__
1354 )->value
['revision'];
1356 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1359 $revOne->getId() => strlen( __METHOD__
),
1361 $store->listRevisionSizes(
1362 wfGetDB( DB_MASTER
),
1363 [ $revOne->getId() ]
1368 $revOne->getId() => strlen( __METHOD__
),
1369 $revTwo->getId() => strlen( __METHOD__
) +
1,
1371 $store->listRevisionSizes(
1372 wfGetDB( DB_MASTER
),
1373 [ $revOne->getId(), $revTwo->getId() ]
1379 * @covers \MediaWiki\Revision\RevisionStore::getPreviousRevision
1381 public function testGetPreviousRevision() {
1382 $page = WikiPage
::factory( Title
::newFromText( __METHOD__
) );
1383 /** @var Revision $revOne */
1384 $revOne = $page->doEditContent(
1385 new WikitextContent( __METHOD__
), __METHOD__
1386 )->value
['revision'];
1387 /** @var Revision $revTwo */
1388 $revTwo = $page->doEditContent(
1389 new WikitextContent( __METHOD__
. '2' ), __METHOD__
1390 )->value
['revision'];
1392 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1394 $store->getPreviousRevision( $store->getRevisionById( $revOne->getId() ) )
1398 $store->getPreviousRevision( $store->getRevisionById( $revTwo->getId() ) )->getId()
1403 * @covers \MediaWiki\Revision\RevisionStore::getNextRevision
1405 public function testGetNextRevision() {
1406 $page = WikiPage
::factory( Title
::newFromText( __METHOD__
) );
1407 /** @var Revision $revOne */
1408 $revOne = $page->doEditContent(
1409 new WikitextContent( __METHOD__
), __METHOD__
1410 )->value
['revision'];
1411 /** @var Revision $revTwo */
1412 $revTwo = $page->doEditContent(
1413 new WikitextContent( __METHOD__
. '2' ), __METHOD__
1414 )->value
['revision'];
1416 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1419 $store->getNextRevision( $store->getRevisionById( $revOne->getId() ) )->getId()
1422 $store->getNextRevision( $store->getRevisionById( $revTwo->getId() ) )
1426 public function provideNonHistoryRevision() {
1427 $title = Title
::newFromText( __METHOD__
);
1428 $rev = new MutableRevisionRecord( $title );
1431 $user = new UserIdentityValue( 7, 'Frank', 0 );
1432 $comment = CommentStoreComment
::newUnsavedComment( 'Test' );
1435 'ar_rev_id' => 34567,
1438 'ar_minor_edit' => 0,
1439 'ar_timestamp' => '20180101020202',
1441 $slots = new RevisionSlots( [] );
1442 $rev = new RevisionArchiveRecord( $title, $user, $comment, $row, $slots );
1447 * @dataProvider provideNonHistoryRevision
1448 * @covers \MediaWiki\Revision\RevisionStore::getPreviousRevision
1450 public function testGetPreviousRevision_bad( RevisionRecord
$rev ) {
1451 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1452 $this->assertNull( $store->getPreviousRevision( $rev ) );
1456 * @dataProvider provideNonHistoryRevision
1457 * @covers \MediaWiki\Revision\RevisionStore::getNextRevision
1459 public function testGetNextRevision_bad( RevisionRecord
$rev ) {
1460 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1461 $this->assertNull( $store->getNextRevision( $rev ) );
1465 * @covers \MediaWiki\Revision\RevisionStore::getTimestampFromId
1467 public function testGetTimestampFromId_found() {
1468 $page = $this->getTestPage();
1469 /** @var Revision $rev */
1470 $rev = $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
)
1471 ->value
['revision'];
1473 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1474 $result = $store->getTimestampFromId( $rev->getId() );
1476 $this->assertSame( $rev->getTimestamp(), $result );
1480 * @covers \MediaWiki\Revision\RevisionStore::getTimestampFromId
1482 public function testGetTimestampFromId_notFound() {
1483 $page = $this->getTestPage();
1484 /** @var Revision $rev */
1485 $rev = $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
)
1486 ->value
['revision'];
1488 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1489 $result = $store->getTimestampFromId( $rev->getId() +
1 );
1491 $this->assertFalse( $result );
1495 * @covers \MediaWiki\Revision\RevisionStore::countRevisionsByPageId
1497 public function testCountRevisionsByPageId() {
1498 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1499 $page = WikiPage
::factory( Title
::newFromText( __METHOD__
) );
1503 $store->countRevisionsByPageId( wfGetDB( DB_MASTER
), $page->getId() )
1505 $page->doEditContent( new WikitextContent( 'a' ), 'a' );
1508 $store->countRevisionsByPageId( wfGetDB( DB_MASTER
), $page->getId() )
1510 $page->doEditContent( new WikitextContent( 'b' ), 'b' );
1513 $store->countRevisionsByPageId( wfGetDB( DB_MASTER
), $page->getId() )
1518 * @covers \MediaWiki\Revision\RevisionStore::countRevisionsByTitle
1520 public function testCountRevisionsByTitle() {
1521 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1522 $page = WikiPage
::factory( Title
::newFromText( __METHOD__
) );
1526 $store->countRevisionsByTitle( wfGetDB( DB_MASTER
), $page->getTitle() )
1528 $page->doEditContent( new WikitextContent( 'a' ), 'a' );
1531 $store->countRevisionsByTitle( wfGetDB( DB_MASTER
), $page->getTitle() )
1533 $page->doEditContent( new WikitextContent( 'b' ), 'b' );
1536 $store->countRevisionsByTitle( wfGetDB( DB_MASTER
), $page->getTitle() )
1541 * @covers \MediaWiki\Revision\RevisionStore::userWasLastToEdit
1543 public function testUserWasLastToEdit_false() {
1544 $sysop = $this->getTestSysop()->getUser();
1545 $page = $this->getTestPage();
1546 $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
);
1548 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1549 $result = $store->userWasLastToEdit(
1550 wfGetDB( DB_MASTER
),
1555 $this->assertFalse( $result );
1559 * @covers \MediaWiki\Revision\RevisionStore::userWasLastToEdit
1561 public function testUserWasLastToEdit_true() {
1562 $startTime = wfTimestampNow();
1563 $sysop = $this->getTestSysop()->getUser();
1564 $page = $this->getTestPage();
1565 $page->doEditContent(
1566 new WikitextContent( __METHOD__
),
1573 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1574 $result = $store->userWasLastToEdit(
1575 wfGetDB( DB_MASTER
),
1580 $this->assertTrue( $result );
1584 * @covers \MediaWiki\Revision\RevisionStore::getKnownCurrentRevision
1586 public function testGetKnownCurrentRevision() {
1587 $page = $this->getTestPage();
1588 /** @var Revision $rev */
1589 $rev = $page->doEditContent(
1590 new WikitextContent( __METHOD__
. 'b' ),
1594 $this->getTestUser()->getUser()
1595 )->value
['revision'];
1597 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1598 $record = $store->getKnownCurrentRevision(
1603 $this->assertRevisionRecordMatchesRevision( $rev, $record );
1606 public function provideNewMutableRevisionFromArray() {
1607 yield
'Basic array, content object' => [
1611 'timestamp' => '20171017114835',
1612 'user_text' => '111.0.1.2',
1614 'minor_edit' => false,
1618 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1619 'comment' => 'Goat Comment!',
1620 'content' => new WikitextContent( 'Some Content' ),
1623 yield
'Basic array, serialized text' => [
1627 'timestamp' => '20171017114835',
1628 'user_text' => '111.0.1.2',
1630 'minor_edit' => false,
1634 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1635 'comment' => 'Goat Comment!',
1636 'text' => ( new WikitextContent( 'Söme Content' ) )->serialize(),
1639 yield
'Basic array, serialized text, utf-8 flags' => [
1643 'timestamp' => '20171017114835',
1644 'user_text' => '111.0.1.2',
1646 'minor_edit' => false,
1650 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1651 'comment' => 'Goat Comment!',
1652 'text' => ( new WikitextContent( 'Söme Content' ) )->serialize(),
1656 yield
'Basic array, with title' => [
1658 'title' => Title
::newFromText( 'SomeText' ),
1659 'timestamp' => '20171017114835',
1660 'user_text' => '111.0.1.2',
1662 'minor_edit' => false,
1666 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1667 'comment' => 'Goat Comment!',
1668 'content' => new WikitextContent( 'Some Content' ),
1671 yield
'Basic array, no user field' => [
1675 'timestamp' => '20171017114835',
1676 'user_text' => '111.0.1.3',
1677 'minor_edit' => false,
1681 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1682 'comment' => 'Goat Comment!',
1683 'content' => new WikitextContent( 'Some Content' ),
1689 * @dataProvider provideNewMutableRevisionFromArray
1690 * @covers \MediaWiki\Revision\RevisionStore::newMutableRevisionFromArray
1692 public function testNewMutableRevisionFromArray( array $array ) {
1693 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1695 // HACK: if $array['page'] is given, make sure that the page exists
1696 if ( isset( $array['page'] ) ) {
1697 $t = Title
::newFromID( $array['page'] );
1698 if ( !$t ||
!$t->exists() ) {
1699 $t = Title
::makeTitle( NS_MAIN
, __METHOD__
);
1700 $info = $this->insertPage( $t );
1701 $array['page'] = $info['id'];
1705 $result = $store->newMutableRevisionFromArray( $array );
1707 if ( isset( $array['id'] ) ) {
1708 $this->assertSame( $array['id'], $result->getId() );
1710 if ( isset( $array['page'] ) ) {
1711 $this->assertSame( $array['page'], $result->getPageId() );
1713 $this->assertSame( $array['timestamp'], $result->getTimestamp() );
1714 $this->assertSame( $array['user_text'], $result->getUser()->getName() );
1715 if ( isset( $array['user'] ) ) {
1716 $this->assertSame( $array['user'], $result->getUser()->getId() );
1718 $this->assertSame( (bool)$array['minor_edit'], $result->isMinor() );
1719 $this->assertSame( $array['deleted'], $result->getVisibility() );
1720 $this->assertSame( $array['len'], $result->getSize() );
1721 $this->assertSame( $array['parent_id'], $result->getParentId() );
1722 $this->assertSame( $array['sha1'], $result->getSha1() );
1723 $this->assertSame( $array['comment'], $result->getComment()->text
);
1724 if ( isset( $array['content'] ) ) {
1725 foreach ( $array['content'] as $role => $content ) {
1727 $result->getContent( $role )->equals( $content )
1730 } elseif ( isset( $array['text'] ) ) {
1731 $this->assertSame( $array['text'],
1732 $result->getSlot( SlotRecord
::MAIN
)->getContent()->serialize() );
1733 } elseif ( isset( $array['content_format'] ) ) {
1735 $array['content_format'],
1736 $result->getSlot( SlotRecord
::MAIN
)->getContent()->getDefaultFormat()
1738 $this->assertSame( $array['content_model'], $result->getSlot( SlotRecord
::MAIN
)->getModel() );
1743 * @dataProvider provideNewMutableRevisionFromArray
1744 * @covers \MediaWiki\Revision\RevisionStore::newMutableRevisionFromArray
1746 public function testNewMutableRevisionFromArray_legacyEncoding( array $array ) {
1747 $cache = new WANObjectCache( [ 'cache' => new HashBagOStuff() ] );
1748 $services = MediaWikiServices
::getInstance();
1749 $lb = $services->getDBLoadBalancer();
1750 $access = $services->getExternalStoreAccess();
1751 $blobStore = new SqlBlobStore( $lb, $access, $cache );
1752 $blobStore->setLegacyEncoding( 'windows-1252', Language
::factory( 'en' ) );
1754 $factory = $this->getMockBuilder( BlobStoreFactory
::class )
1755 ->setMethods( [ 'newBlobStore', 'newSqlBlobStore' ] )
1756 ->disableOriginalConstructor()
1758 $factory->expects( $this->any() )
1759 ->method( 'newBlobStore' )
1760 ->willReturn( $blobStore );
1761 $factory->expects( $this->any() )
1762 ->method( 'newSqlBlobStore' )
1763 ->willReturn( $blobStore );
1765 $this->setService( 'BlobStoreFactory', $factory );
1767 $this->testNewMutableRevisionFromArray( $array );
1771 * Creates a new revision for testing caching behavior
1773 * @param WikiPage $page the page for the new revision
1774 * @param RevisionStore $store store object to use for creating the revision
1775 * @return bool|RevisionStoreRecord the revision created, or false if missing
1777 private function createRevisionStoreCacheRecord( $page, $store ) {
1778 $user = MediaWikiTestCase
::getMutableTestUser()->getUser();
1779 $updater = $page->newPageUpdater( $user );
1780 $updater->setContent( SlotRecord
::MAIN
, new WikitextContent( __METHOD__
) );
1781 $summary = CommentStoreComment
::newUnsavedComment( __METHOD__
);
1782 $rev = $updater->saveRevision( $summary, EDIT_NEW
);
1783 return $store->getKnownCurrentRevision( $page->getTitle(), $rev->getId() );
1787 * @covers \MediaWiki\Revision\RevisionStore::getKnownCurrentRevision
1789 public function testGetKnownCurrentRevision_userNameChange() {
1790 global $wgActorTableSchemaMigrationStage;
1792 $cache = new WANObjectCache( [ 'cache' => new HashBagOStuff() ] );
1793 $this->setService( 'MainWANObjectCache', $cache );
1795 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1796 $page = $this->getNonexistingTestPage();
1797 $rev = $this->createRevisionStoreCacheRecord( $page, $store );
1799 // Grab the user name
1800 $userNameBefore = $rev->getUser()->getName();
1802 // Change the user name in the database, "behind the back" of the cache
1803 $newUserName = "Renamed $userNameBefore";
1804 $this->db
->update( 'revision',
1805 [ 'rev_user_text' => $newUserName ],
1806 [ 'rev_id' => $rev->getId() ] );
1807 $this->db
->update( 'user',
1808 [ 'user_name' => $newUserName ],
1809 [ 'user_id' => $rev->getUser()->getId() ] );
1810 if ( $wgActorTableSchemaMigrationStage & SCHEMA_COMPAT_WRITE_NEW
) {
1811 $this->db
->update( 'actor',
1812 [ 'actor_name' => $newUserName ],
1813 [ 'actor_user' => $rev->getUser()->getId() ] );
1816 // Reload the revision and regrab the user name.
1817 $revAfter = $store->getKnownCurrentRevision( $page->getTitle(), $rev->getId() );
1818 $userNameAfter = $revAfter->getUser()->getName();
1820 // The two user names should be different.
1821 // If they are the same, we are seeing a cached value, which is bad.
1822 $this->assertNotSame( $userNameBefore, $userNameAfter );
1824 // This is implied by the above assertion, but explicitly check it, for completeness
1825 $this->assertSame( $newUserName, $userNameAfter );
1829 * @covers \MediaWiki\Revision\RevisionStore::getKnownCurrentRevision
1831 public function testGetKnownCurrentRevision_revDelete() {
1832 $cache = new WANObjectCache( [ 'cache' => new HashBagOStuff() ] );
1833 $this->setService( 'MainWANObjectCache', $cache );
1835 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1836 $page = $this->getNonexistingTestPage();
1837 $rev = $this->createRevisionStoreCacheRecord( $page, $store );
1839 // Grab the deleted bitmask
1840 $deletedBefore = $rev->getVisibility();
1842 // Change the deleted bitmask in the database, "behind the back" of the cache
1843 $this->db
->update( 'revision',
1844 [ 'rev_deleted' => RevisionRecord
::DELETED_TEXT
],
1845 [ 'rev_id' => $rev->getId() ] );
1847 // Reload the revision and regrab the visibility flag.
1848 $revAfter = $store->getKnownCurrentRevision( $page->getTitle(), $rev->getId() );
1849 $deletedAfter = $revAfter->getVisibility();
1851 // The two deleted flags should be different.
1852 // If they are the same, we are seeing a cached value, which is bad.
1853 $this->assertNotSame( $deletedBefore, $deletedAfter );
1855 // This is implied by the above assertion, but explicitly check it, for completeness
1856 $this->assertSame( RevisionRecord
::DELETED_TEXT
, $deletedAfter );
1860 * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRow
1862 public function testNewRevisionFromRow_userNameChange() {
1863 global $wgActorTableSchemaMigrationStage;
1865 $page = $this->getTestPage();
1867 /** @var Revision $rev */
1868 $rev = $page->doEditContent(
1869 new WikitextContent( $text ),
1873 $this->getMutableTestUser()->getUser()
1874 )->value
['revision'];
1876 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1877 $record = $store->newRevisionFromRow(
1878 $this->revisionToRow( $rev ),
1883 // Grab the user name
1884 $userNameBefore = $record->getUser()->getName();
1886 // Change the user name in the database
1887 $newUserName = "Renamed $userNameBefore";
1888 $this->db
->update( 'revision',
1889 [ 'rev_user_text' => $newUserName ],
1890 [ 'rev_id' => $record->getId() ] );
1891 $this->db
->update( 'user',
1892 [ 'user_name' => $newUserName ],
1893 [ 'user_id' => $record->getUser()->getId() ] );
1894 if ( $wgActorTableSchemaMigrationStage & SCHEMA_COMPAT_WRITE_NEW
) {
1895 $this->db
->update( 'actor',
1896 [ 'actor_name' => $newUserName ],
1897 [ 'actor_user' => $record->getUser()->getId() ] );
1900 // Reload the record, passing $fromCache as true to force fresh info from the db,
1901 // and regrab the user name
1902 $recordAfter = $store->newRevisionFromRow(
1903 $this->revisionToRow( $rev ),
1908 $userNameAfter = $recordAfter->getUser()->getName();
1910 // The two user names should be different.
1911 // If they are the same, we are seeing a cached value, which is bad.
1912 $this->assertNotSame( $userNameBefore, $userNameAfter );
1914 // This is implied by the above assertion, but explicitly check it, for completeness
1915 $this->assertSame( $newUserName, $userNameAfter );
1919 * @covers \MediaWiki\Revision\RevisionStore::newRevisionFromRow
1921 public function testNewRevisionFromRow_revDelete() {
1922 $page = $this->getTestPage();
1924 /** @var Revision $rev */
1925 $rev = $page->doEditContent(
1926 new WikitextContent( $text ),
1928 )->value
['revision'];
1930 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1931 $record = $store->newRevisionFromRow(
1932 $this->revisionToRow( $rev ),
1937 // Grab the deleted bitmask
1938 $deletedBefore = $record->getVisibility();
1940 // Change the deleted bitmask in the database
1941 $this->db
->update( 'revision',
1942 [ 'rev_deleted' => RevisionRecord
::DELETED_TEXT
],
1943 [ 'rev_id' => $record->getId() ] );
1945 // Reload the record, passing $fromCache as true to force fresh info from the db,
1946 // and regrab the deleted bitmask
1947 $recordAfter = $store->newRevisionFromRow(
1948 $this->revisionToRow( $rev ),
1953 $deletedAfter = $recordAfter->getVisibility();
1955 // The two deleted flags should be different, because we modified the database.
1956 $this->assertNotSame( $deletedBefore, $deletedAfter );
1958 // This is implied by the above assertion, but explicitly check it, for completeness
1959 $this->assertSame( RevisionRecord
::DELETED_TEXT
, $deletedAfter );