3 namespace MediaWiki\Tests\Storage
;
5 use CommentStoreComment
;
8 use InvalidArgumentException
;
9 use MediaWiki\Linker\LinkTarget
;
10 use MediaWiki\MediaWikiServices
;
11 use MediaWiki\Storage\IncompleteRevisionException
;
12 use MediaWiki\Storage\MutableRevisionRecord
;
13 use MediaWiki\Storage\RevisionRecord
;
14 use MediaWiki\Storage\RevisionStore
;
15 use MediaWiki\Storage\SlotRecord
;
16 use MediaWiki\Storage\SqlBlobStore
;
17 use MediaWikiTestCase
;
22 use Wikimedia\Rdbms\Database
;
23 use Wikimedia\Rdbms\DatabaseSqlite
;
24 use Wikimedia\Rdbms\FakeResultWrapper
;
25 use Wikimedia\Rdbms\LoadBalancer
;
26 use Wikimedia\Rdbms\TransactionProfiler
;
33 class RevisionStoreDbTest
extends MediaWikiTestCase
{
36 * @return LoadBalancer
38 private function getLoadBalancerMock( array $server ) {
39 $lb = $this->getMockBuilder( LoadBalancer
::class )
40 ->setMethods( [ 'reallyOpenConnection' ] )
41 ->setConstructorArgs( [ [ 'servers' => [ $server ] ] ] )
44 $lb->method( 'reallyOpenConnection' )->willReturnCallback(
45 function ( array $server, $dbNameOverride = false ) {
46 return $this->getDatabaseMock( $server );
56 private function getDatabaseMock( array $params ) {
57 $db = $this->getMockBuilder( DatabaseSqlite
::class )
58 ->setMethods( [ 'select', 'doQuery', 'open', 'closeConnection', 'isOpen' ] )
59 ->setConstructorArgs( [ $params ] )
62 $db->method( 'select' )->willReturn( new FakeResultWrapper( [] ) );
63 $db->method( 'isOpen' )->willReturn( true );
68 public function provideDomainCheck() {
69 yield
[ false, 'test', '' ];
70 yield
[ 'test', 'test', '' ];
72 yield
[ false, 'test', 'foo_' ];
73 yield
[ 'test-foo_', 'test', 'foo_' ];
75 yield
[ false, 'dash-test', '' ];
76 yield
[ 'dash-test', 'dash-test', '' ];
78 yield
[ false, 'underscore_test', 'foo_' ];
79 yield
[ 'underscore_test-foo_', 'underscore_test', 'foo_' ];
83 * @dataProvider provideDomainCheck
84 * @covers \MediaWiki\Storage\RevisionStore::checkDatabaseWikiId
86 public function testDomainCheck( $wikiId, $dbName, $dbPrefix ) {
89 'wgDBname' => $dbName,
90 'wgDBprefix' => $dbPrefix,
94 $loadBalancer = $this->getLoadBalancerMock(
97 'dbDirectory' => '*dummy*',
107 'trxProfiler' => new TransactionProfiler(),
108 'connLogger' => new \Psr\Log\
NullLogger(),
109 'queryLogger' => new \Psr\Log\
NullLogger(),
110 'errorLogger' => new \Psr\Log\
NullLogger(),
113 'tablePrefix' => $dbPrefix,
116 $db = $loadBalancer->getConnection( DB_REPLICA
);
118 $blobStore = $this->getMockBuilder( SqlBlobStore
::class )
119 ->disableOriginalConstructor()
122 $store = new RevisionStore(
125 new WANObjectCache( [ 'cache' => new HashBagOStuff() ] ),
129 $count = $store->countRevisionsByPageId( $db, 0 );
131 // Dummy check to make PhpUnit happy. We are really only interested in
132 // countRevisionsByPageId not failing due to the DB domain check.
133 $this->assertSame( 0, $count );
136 private function assertLinkTargetsEqual( LinkTarget
$l1, LinkTarget
$l2 ) {
137 $this->assertEquals( $l1->getDBkey(), $l2->getDBkey() );
138 $this->assertEquals( $l1->getNamespace(), $l2->getNamespace() );
139 $this->assertEquals( $l1->getFragment(), $l2->getFragment() );
140 $this->assertEquals( $l1->getInterwiki(), $l2->getInterwiki() );
143 private function assertRevisionRecordsEqual( RevisionRecord
$r1, RevisionRecord
$r2 ) {
144 $this->assertEquals( $r1->getUser()->getName(), $r2->getUser()->getName() );
145 $this->assertEquals( $r1->getUser()->getId(), $r2->getUser()->getId() );
146 $this->assertEquals( $r1->getComment(), $r2->getComment() );
147 $this->assertEquals( $r1->getPageAsLinkTarget(), $r2->getPageAsLinkTarget() );
148 $this->assertEquals( $r1->getTimestamp(), $r2->getTimestamp() );
149 $this->assertEquals( $r1->getVisibility(), $r2->getVisibility() );
150 $this->assertEquals( $r1->getSha1(), $r2->getSha1() );
151 $this->assertEquals( $r1->getParentId(), $r2->getParentId() );
152 $this->assertEquals( $r1->getSize(), $r2->getSize() );
153 $this->assertEquals( $r1->getPageId(), $r2->getPageId() );
154 $this->assertEquals( $r1->getSlotRoles(), $r2->getSlotRoles() );
155 $this->assertEquals( $r1->getWikiId(), $r2->getWikiId() );
156 $this->assertEquals( $r1->isMinor(), $r2->isMinor() );
157 foreach ( $r1->getSlotRoles() as $role ) {
158 $this->assertEquals( $r1->getSlot( $role ), $r2->getSlot( $role ) );
159 $this->assertEquals( $r1->getContent( $role ), $r2->getContent( $role ) );
162 RevisionRecord
::DELETED_TEXT
,
163 RevisionRecord
::DELETED_COMMENT
,
164 RevisionRecord
::DELETED_USER
,
165 RevisionRecord
::DELETED_RESTRICTED
,
167 $this->assertEquals( $r1->isDeleted( $field ), $r2->isDeleted( $field ) );
172 * @param mixed[] $details
174 * @return RevisionRecord
176 private function getRevisionRecordFromDetailsArray( $title, $details = [] ) {
177 // Convert some values that can't be provided by dataProviders
178 $page = WikiPage
::factory( $title );
179 if ( isset( $details['user'] ) && $details['user'] === true ) {
180 $details['user'] = $this->getTestUser()->getUser();
182 if ( isset( $details['page'] ) && $details['page'] === true ) {
183 $details['page'] = $page->getId();
185 if ( isset( $details['parent'] ) && $details['parent'] === true ) {
186 $details['parent'] = $page->getLatest();
189 // Create the RevisionRecord with any available data
190 $rev = new MutableRevisionRecord( $title );
191 isset( $details['slot'] ) ?
$rev->setSlot( $details['slot'] ) : null;
192 isset( $details['parent'] ) ?
$rev->setParentId( $details['parent'] ) : null;
193 isset( $details['page'] ) ?
$rev->setPageId( $details['page'] ) : null;
194 isset( $details['size'] ) ?
$rev->setSize( $details['size'] ) : null;
195 isset( $details['sha1'] ) ?
$rev->setSha1( $details['sha1'] ) : null;
196 isset( $details['comment'] ) ?
$rev->setComment( $details['comment'] ) : null;
197 isset( $details['timestamp'] ) ?
$rev->setTimestamp( $details['timestamp'] ) : null;
198 isset( $details['minor'] ) ?
$rev->setMinorEdit( $details['minor'] ) : null;
199 isset( $details['user'] ) ?
$rev->setUser( $details['user'] ) : null;
200 isset( $details['visibility'] ) ?
$rev->setVisibility( $details['visibility'] ) : null;
201 isset( $details['id'] ) ?
$rev->setId( $details['id'] ) : null;
206 private function getRandomCommentStoreComment() {
207 return CommentStoreComment
::newUnsavedComment( __METHOD__
. '.' . rand( 0, 1000 ) );
210 public function provideInsertRevisionOn_successes() {
211 yield
'Bare minimum revision insertion' => [
212 Title
::newFromText( 'UTPage' ),
214 'slot' => SlotRecord
::newUnsaved( 'main', new WikitextContent( 'Chicken' ) ),
216 'comment' => $this->getRandomCommentStoreComment(),
217 'timestamp' => '20171117010101',
221 yield
'Detailed revision insertion' => [
222 Title
::newFromText( 'UTPage' ),
224 'slot' => SlotRecord
::newUnsaved( 'main', new WikitextContent( 'Chicken' ) ),
227 'comment' => $this->getRandomCommentStoreComment(),
228 'timestamp' => '20171117010101',
231 'visibility' => RevisionRecord
::DELETED_RESTRICTED
,
237 * @dataProvider provideInsertRevisionOn_successes
238 * @covers \MediaWiki\Storage\RevisionStore::insertRevisionOn
240 public function testInsertRevisionOn_successes( Title
$title, array $revDetails = [] ) {
241 $rev = $this->getRevisionRecordFromDetailsArray( $title, $revDetails );
243 $store = MediaWikiServices
::getInstance()->getRevisionStore();
244 $return = $store->insertRevisionOn( $rev, wfGetDB( DB_MASTER
) );
246 $this->assertLinkTargetsEqual( $title, $return->getPageAsLinkTarget() );
247 $this->assertRevisionRecordsEqual( $rev, $return );
251 * @covers \MediaWiki\Storage\RevisionStore::insertRevisionOn
253 public function testInsertRevisionOn_blobAddressExists() {
254 $title = Title
::newFromText( 'UTPage' );
256 'slot' => SlotRecord
::newUnsaved( 'main', new WikitextContent( 'Chicken' ) ),
258 'comment' => $this->getRandomCommentStoreComment(),
259 'timestamp' => '20171117010101',
263 $store = MediaWikiServices
::getInstance()->getRevisionStore();
265 // Insert the first revision
266 $revOne = $this->getRevisionRecordFromDetailsArray( $title, $revDetails );
267 $firstReturn = $store->insertRevisionOn( $revOne, wfGetDB( DB_MASTER
) );
268 $this->assertLinkTargetsEqual( $title, $firstReturn->getPageAsLinkTarget() );
269 $this->assertRevisionRecordsEqual( $revOne, $firstReturn );
271 // Insert a second revision inheriting the same blob address
272 $revDetails['slot'] = SlotRecord
::newInherited( $firstReturn->getSlot( 'main' ) );
273 $revTwo = $this->getRevisionRecordFromDetailsArray( $title, $revDetails );
274 $secondReturn = $store->insertRevisionOn( $revTwo, wfGetDB( DB_MASTER
) );
275 $this->assertLinkTargetsEqual( $title, $secondReturn->getPageAsLinkTarget() );
276 $this->assertRevisionRecordsEqual( $revTwo, $secondReturn );
278 // Assert that the same blob address has been used.
280 $firstReturn->getSlot( 'main' )->getAddress(),
281 $secondReturn->getSlot( 'main' )->getAddress()
283 // And that different revisions have been created.
284 $this->assertNotSame(
285 $firstReturn->getId(),
286 $secondReturn->getId()
290 public function provideInsertRevisionOn_failures() {
292 Title
::newFromText( 'UTPage' ),
294 'comment' => $this->getRandomCommentStoreComment(),
295 'timestamp' => '20171117010101',
298 new InvalidArgumentException( 'At least one slot needs to be defined!' )
300 yield
'slot that is not main slot' => [
301 Title
::newFromText( 'UTPage' ),
303 'slot' => SlotRecord
::newUnsaved( 'lalala', new WikitextContent( 'Chicken' ) ),
304 'comment' => $this->getRandomCommentStoreComment(),
305 'timestamp' => '20171117010101',
308 new InvalidArgumentException( 'Only the main slot is supported for now!' )
310 yield
'no timestamp' => [
311 Title
::newFromText( 'UTPage' ),
313 'slot' => SlotRecord
::newUnsaved( 'main', new WikitextContent( 'Chicken' ) ),
314 'comment' => $this->getRandomCommentStoreComment(),
317 new IncompleteRevisionException( 'timestamp field must not be NULL!' )
319 yield
'no comment' => [
320 Title
::newFromText( 'UTPage' ),
322 'slot' => SlotRecord
::newUnsaved( 'main', new WikitextContent( 'Chicken' ) ),
323 'timestamp' => '20171117010101',
326 new IncompleteRevisionException( 'comment must not be NULL!' )
329 Title
::newFromText( 'UTPage' ),
331 'slot' => SlotRecord
::newUnsaved( 'main', new WikitextContent( 'Chicken' ) ),
332 'comment' => $this->getRandomCommentStoreComment(),
333 'timestamp' => '20171117010101',
335 new IncompleteRevisionException( 'user must not be NULL!' )
340 * @dataProvider provideInsertRevisionOn_failures
341 * @covers \MediaWiki\Storage\RevisionStore::insertRevisionOn
343 public function testInsertRevisionOn_failures(
345 array $revDetails = [],
346 Exception
$exception ) {
347 $rev = $this->getRevisionRecordFromDetailsArray( $title, $revDetails );
349 $store = MediaWikiServices
::getInstance()->getRevisionStore();
351 $this->setExpectedException(
352 get_class( $exception ),
353 $exception->getMessage(),
354 $exception->getCode()
356 $store->insertRevisionOn( $rev, wfGetDB( DB_MASTER
) );
359 public function provideNewNullRevision() {
361 Title
::newFromText( 'UTPage' ),
362 CommentStoreComment
::newUnsavedComment( __METHOD__
. ' comment1' ),
366 Title
::newFromText( 'UTPage' ),
367 CommentStoreComment
::newUnsavedComment( __METHOD__
. ' comment2', [ 'a' => 1 ] ),
373 * @dataProvider provideNewNullRevision
374 * @covers \MediaWiki\Storage\RevisionStore::newNullRevision
376 public function testNewNullRevision( Title
$title, $comment, $minor ) {
377 $store = MediaWikiServices
::getInstance()->getRevisionStore();
378 $user = TestUserRegistry
::getMutableTestUser( __METHOD__
)->getUser();
379 $record = $store->newNullRevision(
380 wfGetDB( DB_MASTER
),
387 $this->assertEquals( $title->getNamespace(), $record->getPageAsLinkTarget()->getNamespace() );
388 $this->assertEquals( $title->getDBkey(), $record->getPageAsLinkTarget()->getDBkey() );
389 $this->assertEquals( $comment, $record->getComment() );
390 $this->assertEquals( $minor, $record->isMinor() );
391 $this->assertEquals( $user->getName(), $record->getUser()->getName() );
395 * @covers \MediaWiki\Storage\RevisionStore::newNullRevision
397 public function testNewNullRevision_nonExistingTitle() {
398 $store = MediaWikiServices
::getInstance()->getRevisionStore();
399 $record = $store->newNullRevision(
400 wfGetDB( DB_MASTER
),
401 Title
::newFromText( __METHOD__
. '.iDontExist!' ),
402 CommentStoreComment
::newUnsavedComment( __METHOD__
. ' comment' ),
404 TestUserRegistry
::getMutableTestUser( __METHOD__
)->getUser()
406 $this->assertNull( $record );
410 * @covers \MediaWiki\Storage\RevisionStore::getRcIdIfUnpatrolled
412 public function testGetRcIdIfUnpatrolled_returnsRecentChangesId() {
413 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
414 $status = $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
);
415 /** @var Revision $rev */
416 $rev = $status->value
['revision'];
418 $store = MediaWikiServices
::getInstance()->getRevisionStore();
419 $revisionRecord = $store->getRevisionById( $rev->getId() );
420 $result = $store->getRcIdIfUnpatrolled( $revisionRecord );
422 $this->assertGreaterThan( 0, $result );
424 $page->getRevision()->getRecentChange()->getAttribute( 'rc_id' ),
430 * @covers \MediaWiki\Storage\RevisionStore::getRcIdIfUnpatrolled
432 public function testGetRcIdIfUnpatrolled_returnsZeroIfPatrolled() {
433 // This assumes that sysops are auto patrolled
434 $sysop = $this->getTestSysop()->getUser();
435 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
436 $status = $page->doEditContent(
437 new WikitextContent( __METHOD__
),
443 /** @var Revision $rev */
444 $rev = $status->value
['revision'];
446 $store = MediaWikiServices
::getInstance()->getRevisionStore();
447 $revisionRecord = $store->getRevisionById( $rev->getId() );
448 $result = $store->getRcIdIfUnpatrolled( $revisionRecord );
450 $this->assertSame( 0, $result );
454 * @covers \MediaWiki\Storage\RevisionStore::getRecentChange
456 public function testGetRecentChange() {
457 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
458 $content = new WikitextContent( __METHOD__
);
459 $status = $page->doEditContent( $content, __METHOD__
);
460 /** @var Revision $rev */
461 $rev = $status->value
['revision'];
463 $store = MediaWikiServices
::getInstance()->getRevisionStore();
464 $revRecord = $store->getRevisionById( $rev->getId() );
465 $recentChange = $store->getRecentChange( $revRecord );
467 $this->assertEquals( $rev->getId(), $recentChange->getAttribute( 'rc_this_oldid' ) );
468 $this->assertEquals( $rev->getRecentChange(), $recentChange );
472 * @covers \MediaWiki\Storage\RevisionStore::getRevisionById
474 public function testGetRevisionById() {
475 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
476 $content = new WikitextContent( __METHOD__
);
477 $status = $page->doEditContent( $content, __METHOD__
);
478 /** @var Revision $rev */
479 $rev = $status->value
['revision'];
481 $store = MediaWikiServices
::getInstance()->getRevisionStore();
482 $revRecord = $store->getRevisionById( $rev->getId() );
484 $this->assertSame( $rev->getId(), $revRecord->getId() );
485 $this->assertTrue( $revRecord->getSlot( 'main' )->getContent()->equals( $content ) );
486 $this->assertSame( __METHOD__
, $revRecord->getComment()->text
);
490 * @covers \MediaWiki\Storage\RevisionStore::getRevisionByTitle
492 public function testGetRevisionByTitle() {
493 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
494 $content = new WikitextContent( __METHOD__
);
495 $status = $page->doEditContent( $content, __METHOD__
);
496 /** @var Revision $rev */
497 $rev = $status->value
['revision'];
499 $store = MediaWikiServices
::getInstance()->getRevisionStore();
500 $revRecord = $store->getRevisionByTitle( $page->getTitle() );
502 $this->assertSame( $rev->getId(), $revRecord->getId() );
503 $this->assertTrue( $revRecord->getSlot( 'main' )->getContent()->equals( $content ) );
504 $this->assertSame( __METHOD__
, $revRecord->getComment()->text
);
508 * @covers \MediaWiki\Storage\RevisionStore::getRevisionByPageId
510 public function testGetRevisionByPageId() {
511 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
512 $content = new WikitextContent( __METHOD__
);
513 $status = $page->doEditContent( $content, __METHOD__
);
514 /** @var Revision $rev */
515 $rev = $status->value
['revision'];
517 $store = MediaWikiServices
::getInstance()->getRevisionStore();
518 $revRecord = $store->getRevisionByPageId( $page->getId() );
520 $this->assertSame( $rev->getId(), $revRecord->getId() );
521 $this->assertTrue( $revRecord->getSlot( 'main' )->getContent()->equals( $content ) );
522 $this->assertSame( __METHOD__
, $revRecord->getComment()->text
);
526 * @covers \MediaWiki\Storage\RevisionStore::getRevisionByTimestamp
528 public function testGetRevisionByTimestamp() {
529 // Make sure there is 1 second between the last revision and the rev we create...
530 // Otherwise we might not get the correct revision and the test may fail...
533 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
534 $content = new WikitextContent( __METHOD__
);
535 $status = $page->doEditContent( $content, __METHOD__
);
536 /** @var Revision $rev */
537 $rev = $status->value
['revision'];
539 $store = MediaWikiServices
::getInstance()->getRevisionStore();
540 $revRecord = $store->getRevisionByTimestamp(
545 $this->assertSame( $rev->getId(), $revRecord->getId() );
546 $this->assertTrue( $revRecord->getSlot( 'main' )->getContent()->equals( $content ) );
547 $this->assertSame( __METHOD__
, $revRecord->getComment()->text
);
550 private function revisionToRow( Revision
$rev ) {
551 $page = WikiPage
::factory( $rev->getTitle() );
554 'rev_id' => (string)$rev->getId(),
555 'rev_page' => (string)$rev->getPage(),
556 'rev_text_id' => (string)$rev->getTextId(),
557 'rev_timestamp' => (string)$rev->getTimestamp(),
558 'rev_user_text' => (string)$rev->getUserText(),
559 'rev_user' => (string)$rev->getUser(),
560 'rev_minor_edit' => $rev->isMinor() ?
'1' : '0',
561 'rev_deleted' => (string)$rev->getVisibility(),
562 'rev_len' => (string)$rev->getSize(),
563 'rev_parent_id' => (string)$rev->getParentId(),
564 'rev_sha1' => (string)$rev->getSha1(),
565 'rev_comment_text' => $rev->getComment(),
566 'rev_comment_data' => null,
567 'rev_comment_cid' => null,
568 'rev_content_format' => $rev->getContentFormat(),
569 'rev_content_model' => $rev->getContentModel(),
570 'page_namespace' => (string)$page->getTitle()->getNamespace(),
571 'page_title' => $page->getTitle()->getDBkey(),
572 'page_id' => (string)$page->getId(),
573 'page_latest' => (string)$page->getLatest(),
574 'page_is_redirect' => $page->isRedirect() ?
'1' : '0',
575 'page_len' => (string)$page->getContent()->getSize(),
576 'user_name' => (string)$rev->getUserText(),
580 private function assertRevisionRecordMatchesRevision(
582 RevisionRecord
$record
584 $this->assertSame( $rev->getId(), $record->getId() );
585 $this->assertSame( $rev->getPage(), $record->getPageId() );
586 $this->assertSame( $rev->getTimestamp(), $record->getTimestamp() );
587 $this->assertSame( $rev->getUserText(), $record->getUser()->getName() );
588 $this->assertSame( $rev->getUser(), $record->getUser()->getId() );
589 $this->assertSame( $rev->isMinor(), $record->isMinor() );
590 $this->assertSame( $rev->getVisibility(), $record->getVisibility() );
591 $this->assertSame( $rev->getSize(), $record->getSize() );
593 * @note As of MW 1.31, the database schema allows the parent ID to be
594 * NULL to indicate that it is unknown.
596 $expectedParent = $rev->getParentId();
597 if ( $expectedParent === null ) {
600 $this->assertSame( $expectedParent, $record->getParentId() );
601 $this->assertSame( $rev->getSha1(), $record->getSha1() );
602 $this->assertSame( $rev->getComment(), $record->getComment()->text
);
603 $this->assertSame( $rev->getContentFormat(), $record->getContent( 'main' )->getDefaultFormat() );
604 $this->assertSame( $rev->getContentModel(), $record->getContent( 'main' )->getModel() );
605 $this->assertLinkTargetsEqual( $rev->getTitle(), $record->getPageAsLinkTarget() );
609 * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow
610 * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow_1_29
612 public function testNewRevisionFromRow_anonEdit() {
613 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
614 /** @var Revision $rev */
615 $rev = $page->doEditContent(
616 new WikitextContent( __METHOD__
. 'a' ),
618 )->value
['revision'];
620 $store = MediaWikiServices
::getInstance()->getRevisionStore();
621 $record = $store->newRevisionFromRow(
622 $this->revisionToRow( $rev ),
626 $this->assertRevisionRecordMatchesRevision( $rev, $record );
630 * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow
631 * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow_1_29
633 public function testNewRevisionFromRow_userEdit() {
634 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
635 /** @var Revision $rev */
636 $rev = $page->doEditContent(
637 new WikitextContent( __METHOD__
. 'b' ),
641 $this->getTestUser()->getUser()
642 )->value
['revision'];
644 $store = MediaWikiServices
::getInstance()->getRevisionStore();
645 $record = $store->newRevisionFromRow(
646 $this->revisionToRow( $rev ),
650 $this->assertRevisionRecordMatchesRevision( $rev, $record );
654 * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromArchiveRow
656 public function testNewRevisionFromArchiveRow() {
657 $store = MediaWikiServices
::getInstance()->getRevisionStore();
658 $title = Title
::newFromText( __METHOD__
);
659 $page = WikiPage
::factory( $title );
660 /** @var Revision $orig */
661 $orig = $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
)
663 $page->doDeleteArticle( __METHOD__
);
665 $db = wfGetDB( DB_MASTER
);
666 $arQuery = $store->getArchiveQueryInfo();
668 $arQuery['tables'], $arQuery['fields'], [ 'ar_rev_id' => $orig->getId() ],
669 __METHOD__
, [], $arQuery['joins']
671 $this->assertTrue( is_object( $res ), 'query failed' );
673 $row = $res->fetchObject();
675 $record = $store->newRevisionFromArchiveRow( $row );
677 $this->assertRevisionRecordMatchesRevision( $orig, $record );
681 * @covers \MediaWiki\Storage\RevisionStore::loadRevisionFromId
683 public function testLoadRevisionFromId() {
684 $title = Title
::newFromText( __METHOD__
);
685 $page = WikiPage
::factory( $title );
686 /** @var Revision $rev */
687 $rev = $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
)
690 $store = MediaWikiServices
::getInstance()->getRevisionStore();
691 $result = $store->loadRevisionFromId( wfGetDB( DB_MASTER
), $rev->getId() );
692 $this->assertRevisionRecordMatchesRevision( $rev, $result );
696 * @covers \MediaWiki\Storage\RevisionStore::loadRevisionFromPageId
698 public function testLoadRevisionFromPageId() {
699 $title = Title
::newFromText( __METHOD__
);
700 $page = WikiPage
::factory( $title );
701 /** @var Revision $rev */
702 $rev = $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
)
705 $store = MediaWikiServices
::getInstance()->getRevisionStore();
706 $result = $store->loadRevisionFromPageId( wfGetDB( DB_MASTER
), $page->getId() );
707 $this->assertRevisionRecordMatchesRevision( $rev, $result );
711 * @covers \MediaWiki\Storage\RevisionStore::loadRevisionFromTitle
713 public function testLoadRevisionFromTitle() {
714 $title = Title
::newFromText( __METHOD__
);
715 $page = WikiPage
::factory( $title );
716 /** @var Revision $rev */
717 $rev = $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
)
720 $store = MediaWikiServices
::getInstance()->getRevisionStore();
721 $result = $store->loadRevisionFromTitle( wfGetDB( DB_MASTER
), $title );
722 $this->assertRevisionRecordMatchesRevision( $rev, $result );
726 * @covers \MediaWiki\Storage\RevisionStore::loadRevisionFromTimestamp
728 public function testLoadRevisionFromTimestamp() {
729 $title = Title
::newFromText( __METHOD__
);
730 $page = WikiPage
::factory( $title );
731 /** @var Revision $revOne */
732 $revOne = $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
)
734 // Sleep to ensure different timestamps... )(evil)
736 /** @var Revision $revTwo */
737 $revTwo = $page->doEditContent( new WikitextContent( __METHOD__
. 'a' ), '' )
740 $store = MediaWikiServices
::getInstance()->getRevisionStore();
742 $store->loadRevisionFromTimestamp( wfGetDB( DB_MASTER
), $title, '20150101010101' )
746 $store->loadRevisionFromTimestamp(
747 wfGetDB( DB_MASTER
),
749 $revOne->getTimestamp()
754 $store->loadRevisionFromTimestamp(
755 wfGetDB( DB_MASTER
),
757 $revTwo->getTimestamp()
763 * @covers \MediaWiki\Storage\RevisionStore::listRevisionSizes
765 public function testGetParentLengths() {
766 $page = WikiPage
::factory( Title
::newFromText( __METHOD__
) );
767 /** @var Revision $revOne */
768 $revOne = $page->doEditContent(
769 new WikitextContent( __METHOD__
), __METHOD__
770 )->value
['revision'];
771 /** @var Revision $revTwo */
772 $revTwo = $page->doEditContent(
773 new WikitextContent( __METHOD__
. '2' ), __METHOD__
774 )->value
['revision'];
776 $store = MediaWikiServices
::getInstance()->getRevisionStore();
779 $revOne->getId() => strlen( __METHOD__
),
781 $store->listRevisionSizes(
782 wfGetDB( DB_MASTER
),
788 $revOne->getId() => strlen( __METHOD__
),
789 $revTwo->getId() => strlen( __METHOD__
) +
1,
791 $store->listRevisionSizes(
792 wfGetDB( DB_MASTER
),
793 [ $revOne->getId(), $revTwo->getId() ]
799 * @covers \MediaWiki\Storage\RevisionStore::getPreviousRevision
801 public function testGetPreviousRevision() {
802 $page = WikiPage
::factory( Title
::newFromText( __METHOD__
) );
803 /** @var Revision $revOne */
804 $revOne = $page->doEditContent(
805 new WikitextContent( __METHOD__
), __METHOD__
806 )->value
['revision'];
807 /** @var Revision $revTwo */
808 $revTwo = $page->doEditContent(
809 new WikitextContent( __METHOD__
. '2' ), __METHOD__
810 )->value
['revision'];
812 $store = MediaWikiServices
::getInstance()->getRevisionStore();
814 $store->getPreviousRevision( $store->getRevisionById( $revOne->getId() ) )
818 $store->getPreviousRevision( $store->getRevisionById( $revTwo->getId() ) )->getId()
823 * @covers \MediaWiki\Storage\RevisionStore::getNextRevision
825 public function testGetNextRevision() {
826 $page = WikiPage
::factory( Title
::newFromText( __METHOD__
) );
827 /** @var Revision $revOne */
828 $revOne = $page->doEditContent(
829 new WikitextContent( __METHOD__
), __METHOD__
830 )->value
['revision'];
831 /** @var Revision $revTwo */
832 $revTwo = $page->doEditContent(
833 new WikitextContent( __METHOD__
. '2' ), __METHOD__
834 )->value
['revision'];
836 $store = MediaWikiServices
::getInstance()->getRevisionStore();
839 $store->getNextRevision( $store->getRevisionById( $revOne->getId() ) )->getId()
842 $store->getNextRevision( $store->getRevisionById( $revTwo->getId() ) )
847 * @covers \MediaWiki\Storage\RevisionStore::getTimestampFromId
849 public function testGetTimestampFromId_found() {
850 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
851 /** @var Revision $rev */
852 $rev = $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
)
855 $store = MediaWikiServices
::getInstance()->getRevisionStore();
856 $result = $store->getTimestampFromId(
861 $this->assertSame( $rev->getTimestamp(), $result );
865 * @covers \MediaWiki\Storage\RevisionStore::getTimestampFromId
867 public function testGetTimestampFromId_notFound() {
868 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
869 /** @var Revision $rev */
870 $rev = $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
)
873 $store = MediaWikiServices
::getInstance()->getRevisionStore();
874 $result = $store->getTimestampFromId(
879 $this->assertFalse( $result );
883 * @covers \MediaWiki\Storage\RevisionStore::countRevisionsByPageId
885 public function testCountRevisionsByPageId() {
886 $store = MediaWikiServices
::getInstance()->getRevisionStore();
887 $page = WikiPage
::factory( Title
::newFromText( __METHOD__
) );
891 $store->countRevisionsByPageId( wfGetDB( DB_MASTER
), $page->getId() )
893 $page->doEditContent( new WikitextContent( 'a' ), 'a' );
896 $store->countRevisionsByPageId( wfGetDB( DB_MASTER
), $page->getId() )
898 $page->doEditContent( new WikitextContent( 'b' ), 'b' );
901 $store->countRevisionsByPageId( wfGetDB( DB_MASTER
), $page->getId() )
906 * @covers \MediaWiki\Storage\RevisionStore::countRevisionsByTitle
908 public function testCountRevisionsByTitle() {
909 $store = MediaWikiServices
::getInstance()->getRevisionStore();
910 $page = WikiPage
::factory( Title
::newFromText( __METHOD__
) );
914 $store->countRevisionsByTitle( wfGetDB( DB_MASTER
), $page->getTitle() )
916 $page->doEditContent( new WikitextContent( 'a' ), 'a' );
919 $store->countRevisionsByTitle( wfGetDB( DB_MASTER
), $page->getTitle() )
921 $page->doEditContent( new WikitextContent( 'b' ), 'b' );
924 $store->countRevisionsByTitle( wfGetDB( DB_MASTER
), $page->getTitle() )
929 * @covers \MediaWiki\Storage\RevisionStore::userWasLastToEdit
931 public function testUserWasLastToEdit_false() {
932 $sysop = $this->getTestSysop()->getUser();
933 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
934 $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
);
936 $store = MediaWikiServices
::getInstance()->getRevisionStore();
937 $result = $store->userWasLastToEdit(
938 wfGetDB( DB_MASTER
),
943 $this->assertFalse( $result );
947 * @covers \MediaWiki\Storage\RevisionStore::userWasLastToEdit
949 public function testUserWasLastToEdit_true() {
950 $startTime = wfTimestampNow();
951 $sysop = $this->getTestSysop()->getUser();
952 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
953 $page->doEditContent(
954 new WikitextContent( __METHOD__
),
961 $store = MediaWikiServices
::getInstance()->getRevisionStore();
962 $result = $store->userWasLastToEdit(
963 wfGetDB( DB_MASTER
),
968 $this->assertTrue( $result );
972 * @covers \MediaWiki\Storage\RevisionStore::getKnownCurrentRevision
974 public function testGetKnownCurrentRevision() {
975 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
976 /** @var Revision $rev */
977 $rev = $page->doEditContent(
978 new WikitextContent( __METHOD__
. 'b' ),
982 $this->getTestUser()->getUser()
983 )->value
['revision'];
985 $store = MediaWikiServices
::getInstance()->getRevisionStore();
986 $record = $store->getKnownCurrentRevision(
991 $this->assertRevisionRecordMatchesRevision( $rev, $record );
994 public function provideNewMutableRevisionFromArray() {
995 yield
'Basic array, with page & id' => [
1000 'timestamp' => '20171017114835',
1001 'user_text' => '111.0.1.2',
1003 'minor_edit' => false,
1007 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1008 'comment' => 'Goat Comment!',
1009 'content_format' => 'text/x-wiki',
1010 'content_model' => 'wikitext',
1013 yield
'Basic array, content object' => [
1017 'timestamp' => '20171017114835',
1018 'user_text' => '111.0.1.2',
1020 'minor_edit' => false,
1024 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1025 'comment' => 'Goat Comment!',
1026 'content' => new WikitextContent( 'Some Content' ),
1029 yield
'Basic array, with title' => [
1031 'title' => Title
::newFromText( 'SomeText' ),
1033 'timestamp' => '20171017114835',
1034 'user_text' => '111.0.1.2',
1036 'minor_edit' => false,
1040 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1041 'comment' => 'Goat Comment!',
1042 'content_format' => 'text/x-wiki',
1043 'content_model' => 'wikitext',
1046 yield
'Basic array, no user field' => [
1051 'timestamp' => '20171017114835',
1052 'user_text' => '111.0.1.3',
1053 'minor_edit' => false,
1057 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1058 'comment' => 'Goat Comment!',
1059 'content_format' => 'text/x-wiki',
1060 'content_model' => 'wikitext',
1066 * @dataProvider provideNewMutableRevisionFromArray
1067 * @covers \MediaWiki\Storage\RevisionStore::newMutableRevisionFromArray
1069 public function testNewMutableRevisionFromArray( array $array ) {
1070 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1072 $result = $store->newMutableRevisionFromArray( $array );
1074 if ( isset( $array['id'] ) ) {
1075 $this->assertSame( $array['id'], $result->getId() );
1077 if ( isset( $array['page'] ) ) {
1078 $this->assertSame( $array['page'], $result->getPageId() );
1080 $this->assertSame( $array['timestamp'], $result->getTimestamp() );
1081 $this->assertSame( $array['user_text'], $result->getUser()->getName() );
1082 if ( isset( $array['user'] ) ) {
1083 $this->assertSame( $array['user'], $result->getUser()->getId() );
1085 $this->assertSame( (bool)$array['minor_edit'], $result->isMinor() );
1086 $this->assertSame( $array['deleted'], $result->getVisibility() );
1087 $this->assertSame( $array['len'], $result->getSize() );
1088 $this->assertSame( $array['parent_id'], $result->getParentId() );
1089 $this->assertSame( $array['sha1'], $result->getSha1() );
1090 $this->assertSame( $array['comment'], $result->getComment()->text
);
1091 if ( isset( $array['content'] ) ) {
1093 $result->getSlot( 'main' )->getContent()->equals( $array['content'] )
1097 $array['content_format'],
1098 $result->getSlot( 'main' )->getContent()->getDefaultFormat()
1100 $this->assertSame( $array['content_model'], $result->getSlot( 'main' )->getModel() );