3 namespace MediaWiki\Tests\Storage
;
5 use CommentStoreComment
;
8 use InvalidArgumentException
;
10 use MediaWiki\Linker\LinkTarget
;
11 use MediaWiki\MediaWikiServices
;
12 use MediaWiki\Storage\BlobStoreFactory
;
13 use MediaWiki\Storage\IncompleteRevisionException
;
14 use MediaWiki\Storage\MutableRevisionRecord
;
15 use MediaWiki\Storage\RevisionRecord
;
16 use MediaWiki\Storage\RevisionStore
;
17 use MediaWiki\Storage\SlotRecord
;
18 use MediaWiki\Storage\SqlBlobStore
;
19 use MediaWikiTestCase
;
20 use PHPUnit_Framework_MockObject_MockObject
;
25 use Wikimedia\Rdbms\Database
;
26 use Wikimedia\Rdbms\DatabaseSqlite
;
27 use Wikimedia\Rdbms\FakeResultWrapper
;
28 use Wikimedia\Rdbms\LoadBalancer
;
29 use Wikimedia\Rdbms\TransactionProfiler
;
35 * @group RevisionStore
37 abstract class RevisionStoreDbTestBase
extends MediaWikiTestCase
{
42 abstract protected function getMcrMigrationStage();
47 protected function getContentHandlerUseDB() {
54 abstract protected function getMcrTablesToReset();
56 public function needsDB() {
60 public function setUp() {
62 $this->tablesUsed
[] = 'archive';
63 $this->tablesUsed
[] = 'page';
64 $this->tablesUsed
[] = 'revision';
65 $this->tablesUsed
[] = 'comment';
67 $this->tablesUsed +
= $this->getMcrTablesToReset();
70 'wgMultiContentRevisionSchemaMigrationStage',
71 $this->getMcrMigrationStage()
75 'wgContentHandlerUseDB',
76 $this->getContentHandlerUseDB()
79 $this->overrideMwServices();
83 * @return LoadBalancer|PHPUnit_Framework_MockObject_MockObject
85 private function getLoadBalancerMock( array $server ) {
86 $lb = $this->getMockBuilder( LoadBalancer
::class )
87 ->setMethods( [ 'reallyOpenConnection' ] )
88 ->setConstructorArgs( [ [ 'servers' => [ $server ] ] ] )
91 $lb->method( 'reallyOpenConnection' )->willReturnCallback(
92 function ( array $server, $dbNameOverride ) {
93 return $this->getDatabaseMock( $server );
101 * @return Database|PHPUnit_Framework_MockObject_MockObject
103 private function getDatabaseMock( array $params ) {
104 $db = $this->getMockBuilder( DatabaseSqlite
::class )
105 ->setMethods( [ 'select', 'doQuery', 'open', 'closeConnection', 'isOpen' ] )
106 ->setConstructorArgs( [ $params ] )
109 $db->method( 'select' )->willReturn( new FakeResultWrapper( [] ) );
110 $db->method( 'isOpen' )->willReturn( true );
115 public function provideDomainCheck() {
116 yield
[ false, 'test', '' ];
117 yield
[ 'test', 'test', '' ];
119 yield
[ false, 'test', 'foo_' ];
120 yield
[ 'test-foo_', 'test', 'foo_' ];
122 yield
[ false, 'dash-test', '' ];
123 yield
[ 'dash-test', 'dash-test', '' ];
125 yield
[ false, 'underscore_test', 'foo_' ];
126 yield
[ 'underscore_test-foo_', 'underscore_test', 'foo_' ];
130 * @dataProvider provideDomainCheck
131 * @covers \MediaWiki\Storage\RevisionStore::checkDatabaseWikiId
133 public function testDomainCheck( $wikiId, $dbName, $dbPrefix ) {
136 'wgDBname' => $dbName,
137 'wgDBprefix' => $dbPrefix,
141 $loadBalancer = $this->getLoadBalancerMock(
144 'dbDirectory' => '*dummy*',
146 'password' => 'test',
154 'trxProfiler' => new TransactionProfiler(),
155 'connLogger' => new \Psr\Log\
NullLogger(),
156 'queryLogger' => new \Psr\Log\
NullLogger(),
157 'errorLogger' => function () {
159 'deprecationLogger' => function () {
163 'tablePrefix' => $dbPrefix,
166 $db = $loadBalancer->getConnection( DB_REPLICA
);
168 /** @var SqlBlobStore $blobStore */
169 $blobStore = $this->getMockBuilder( SqlBlobStore
::class )
170 ->disableOriginalConstructor()
173 $store = new RevisionStore(
176 new WANObjectCache( [ 'cache' => new HashBagOStuff() ] ),
177 MediaWikiServices
::getInstance()->getCommentStore(),
178 MediaWikiServices
::getInstance()->getActorMigration(),
182 $count = $store->countRevisionsByPageId( $db, 0 );
184 // Dummy check to make PhpUnit happy. We are really only interested in
185 // countRevisionsByPageId not failing due to the DB domain check.
186 $this->assertSame( 0, $count );
189 private function assertLinkTargetsEqual( LinkTarget
$l1, LinkTarget
$l2 ) {
190 $this->assertEquals( $l1->getDBkey(), $l2->getDBkey() );
191 $this->assertEquals( $l1->getNamespace(), $l2->getNamespace() );
192 $this->assertEquals( $l1->getFragment(), $l2->getFragment() );
193 $this->assertEquals( $l1->getInterwiki(), $l2->getInterwiki() );
196 private function assertRevisionRecordsEqual( RevisionRecord
$r1, RevisionRecord
$r2 ) {
197 $this->assertEquals( $r1->getUser()->getName(), $r2->getUser()->getName() );
198 $this->assertEquals( $r1->getUser()->getId(), $r2->getUser()->getId() );
199 $this->assertEquals( $r1->getComment(), $r2->getComment() );
200 $this->assertEquals( $r1->getPageAsLinkTarget(), $r2->getPageAsLinkTarget() );
201 $this->assertEquals( $r1->getTimestamp(), $r2->getTimestamp() );
202 $this->assertEquals( $r1->getVisibility(), $r2->getVisibility() );
203 $this->assertEquals( $r1->getSha1(), $r2->getSha1() );
204 $this->assertEquals( $r1->getParentId(), $r2->getParentId() );
205 $this->assertEquals( $r1->getSize(), $r2->getSize() );
206 $this->assertEquals( $r1->getPageId(), $r2->getPageId() );
207 $this->assertEquals( $r1->getSlotRoles(), $r2->getSlotRoles() );
208 $this->assertEquals( $r1->getWikiId(), $r2->getWikiId() );
209 $this->assertEquals( $r1->isMinor(), $r2->isMinor() );
210 foreach ( $r1->getSlotRoles() as $role ) {
211 $this->assertSlotRecordsEqual( $r1->getSlot( $role ), $r2->getSlot( $role ) );
212 $this->assertTrue( $r1->getContent( $role )->equals( $r2->getContent( $role ) ) );
215 RevisionRecord
::DELETED_TEXT
,
216 RevisionRecord
::DELETED_COMMENT
,
217 RevisionRecord
::DELETED_USER
,
218 RevisionRecord
::DELETED_RESTRICTED
,
220 $this->assertEquals( $r1->isDeleted( $field ), $r2->isDeleted( $field ) );
224 private function assertSlotRecordsEqual( SlotRecord
$s1, SlotRecord
$s2 ) {
225 $this->assertSame( $s1->getRole(), $s2->getRole() );
226 $this->assertSame( $s1->getModel(), $s2->getModel() );
227 $this->assertSame( $s1->getFormat(), $s2->getFormat() );
228 $this->assertSame( $s1->getSha1(), $s2->getSha1() );
229 $this->assertSame( $s1->getSize(), $s2->getSize() );
230 $this->assertTrue( $s1->getContent()->equals( $s2->getContent() ) );
232 $s1->hasRevision() ?
$this->assertSame( $s1->getRevision(), $s2->getRevision() ) : null;
233 $s1->hasAddress() ?
$this->assertSame( $s1->hasAddress(), $s2->hasAddress() ) : null;
236 private function assertRevisionCompleteness( RevisionRecord
$r ) {
237 foreach ( $r->getSlotRoles() as $role ) {
238 $this->assertSlotCompleteness( $r, $r->getSlot( $role ) );
242 private function assertSlotCompleteness( RevisionRecord
$r, SlotRecord
$slot ) {
243 $this->assertTrue( $slot->hasAddress() );
244 $this->assertSame( $r->getId(), $slot->getRevision() );
248 * @param mixed[] $details
250 * @return RevisionRecord
252 private function getRevisionRecordFromDetailsArray( $title, $details = [] ) {
253 // Convert some values that can't be provided by dataProviders
254 $page = WikiPage
::factory( $title );
255 if ( isset( $details['user'] ) && $details['user'] === true ) {
256 $details['user'] = $this->getTestUser()->getUser();
258 if ( isset( $details['page'] ) && $details['page'] === true ) {
259 $details['page'] = $page->getId();
261 if ( isset( $details['parent'] ) && $details['parent'] === true ) {
262 $details['parent'] = $page->getLatest();
265 // Create the RevisionRecord with any available data
266 $rev = new MutableRevisionRecord( $title );
267 isset( $details['slot'] ) ?
$rev->setSlot( $details['slot'] ) : null;
268 isset( $details['parent'] ) ?
$rev->setParentId( $details['parent'] ) : null;
269 isset( $details['page'] ) ?
$rev->setPageId( $details['page'] ) : null;
270 isset( $details['size'] ) ?
$rev->setSize( $details['size'] ) : null;
271 isset( $details['sha1'] ) ?
$rev->setSha1( $details['sha1'] ) : null;
272 isset( $details['comment'] ) ?
$rev->setComment( $details['comment'] ) : null;
273 isset( $details['timestamp'] ) ?
$rev->setTimestamp( $details['timestamp'] ) : null;
274 isset( $details['minor'] ) ?
$rev->setMinorEdit( $details['minor'] ) : null;
275 isset( $details['user'] ) ?
$rev->setUser( $details['user'] ) : null;
276 isset( $details['visibility'] ) ?
$rev->setVisibility( $details['visibility'] ) : null;
277 isset( $details['id'] ) ?
$rev->setId( $details['id'] ) : null;
282 public function provideInsertRevisionOn_successes() {
283 yield
'Bare minimum revision insertion' => [
284 Title
::newFromText( 'UTPage' ),
286 'slot' => SlotRecord
::newUnsaved( 'main', new WikitextContent( 'Chicken' ) ),
288 'comment' => $this->getRandomCommentStoreComment(),
289 'timestamp' => '20171117010101',
293 yield
'Detailed revision insertion' => [
294 Title
::newFromText( 'UTPage' ),
296 'slot' => SlotRecord
::newUnsaved( 'main', new WikitextContent( 'Chicken' ) ),
299 'comment' => $this->getRandomCommentStoreComment(),
300 'timestamp' => '20171117010101',
303 'visibility' => RevisionRecord
::DELETED_RESTRICTED
,
308 private function getRandomCommentStoreComment() {
309 return CommentStoreComment
::newUnsavedComment( __METHOD__
. '.' . rand( 0, 1000 ) );
313 * @dataProvider provideInsertRevisionOn_successes
314 * @covers \MediaWiki\Storage\RevisionStore::insertRevisionOn
316 public function testInsertRevisionOn_successes(
318 array $revDetails = []
320 $rev = $this->getRevisionRecordFromDetailsArray( $title, $revDetails );
322 $this->overrideMwServices();
323 $store = MediaWikiServices
::getInstance()->getRevisionStore();
324 $return = $store->insertRevisionOn( $rev, wfGetDB( DB_MASTER
) );
326 $this->assertLinkTargetsEqual( $title, $return->getPageAsLinkTarget() );
327 $this->assertRevisionRecordsEqual( $rev, $return );
328 $this->assertRevisionCompleteness( $return );
329 $this->assertRevisionExistsInDatabase( $return );
332 protected function assertRevisionExistsInDatabase( RevisionRecord
$rev ) {
334 'revision', [ 'count(*)' ], [ 'rev_id' => $rev->getId() ], [ [ '1' ] ]
339 * @param SlotRecord $a
340 * @param SlotRecord $b
342 protected function assertSameSlotContent( SlotRecord
$a, SlotRecord
$b ) {
343 // Assert that the same blob address has been used.
344 $this->assertSame( $a->getAddress(), $b->getAddress() );
348 * @covers \MediaWiki\Storage\RevisionStore::insertRevisionOn
350 public function testInsertRevisionOn_blobAddressExists() {
351 $title = Title
::newFromText( 'UTPage' );
353 'slot' => SlotRecord
::newUnsaved( 'main', new WikitextContent( 'Chicken' ) ),
355 'comment' => $this->getRandomCommentStoreComment(),
356 'timestamp' => '20171117010101',
360 $this->overrideMwServices();
361 $store = MediaWikiServices
::getInstance()->getRevisionStore();
363 // Insert the first revision
364 $revOne = $this->getRevisionRecordFromDetailsArray( $title, $revDetails );
365 $firstReturn = $store->insertRevisionOn( $revOne, wfGetDB( DB_MASTER
) );
366 $this->assertLinkTargetsEqual( $title, $firstReturn->getPageAsLinkTarget() );
367 $this->assertRevisionRecordsEqual( $revOne, $firstReturn );
369 // Insert a second revision inheriting the same blob address
370 $revDetails['slot'] = SlotRecord
::newInherited( $firstReturn->getSlot( 'main' ) );
371 $revTwo = $this->getRevisionRecordFromDetailsArray( $title, $revDetails );
372 $secondReturn = $store->insertRevisionOn( $revTwo, wfGetDB( DB_MASTER
) );
373 $this->assertLinkTargetsEqual( $title, $secondReturn->getPageAsLinkTarget() );
374 $this->assertRevisionRecordsEqual( $revTwo, $secondReturn );
376 $firstMainSlot = $firstReturn->getSlot( 'main' );
377 $secondMainSlot = $secondReturn->getSlot( 'main' );
379 $this->assertSameSlotContent( $firstMainSlot, $secondMainSlot );
381 // And that different revisions have been created.
382 $this->assertNotSame( $firstReturn->getId(), $secondReturn->getId() );
384 // Make sure the slot rows reference the correct revision
385 $this->assertSame( $firstReturn->getId(), $firstMainSlot->getRevision() );
386 $this->assertSame( $secondReturn->getId(), $secondMainSlot->getRevision() );
389 public function provideInsertRevisionOn_failures() {
391 Title
::newFromText( 'UTPage' ),
393 'comment' => $this->getRandomCommentStoreComment(),
394 'timestamp' => '20171117010101',
397 new InvalidArgumentException( 'At least one slot needs to be defined!' )
399 yield
'slot that is not main slot' => [
400 Title
::newFromText( 'UTPage' ),
402 'slot' => SlotRecord
::newUnsaved( 'lalala', new WikitextContent( 'Chicken' ) ),
403 'comment' => $this->getRandomCommentStoreComment(),
404 'timestamp' => '20171117010101',
407 new InvalidArgumentException( 'Only the main slot is supported for now!' )
409 yield
'no timestamp' => [
410 Title
::newFromText( 'UTPage' ),
412 'slot' => SlotRecord
::newUnsaved( 'main', new WikitextContent( 'Chicken' ) ),
413 'comment' => $this->getRandomCommentStoreComment(),
416 new IncompleteRevisionException( 'timestamp field must not be NULL!' )
418 yield
'no comment' => [
419 Title
::newFromText( 'UTPage' ),
421 'slot' => SlotRecord
::newUnsaved( 'main', new WikitextContent( 'Chicken' ) ),
422 'timestamp' => '20171117010101',
425 new IncompleteRevisionException( 'comment must not be NULL!' )
428 Title
::newFromText( 'UTPage' ),
430 'slot' => SlotRecord
::newUnsaved( 'main', new WikitextContent( 'Chicken' ) ),
431 'comment' => $this->getRandomCommentStoreComment(),
432 'timestamp' => '20171117010101',
434 new IncompleteRevisionException( 'user must not be NULL!' )
439 * @dataProvider provideInsertRevisionOn_failures
440 * @covers \MediaWiki\Storage\RevisionStore::insertRevisionOn
442 public function testInsertRevisionOn_failures(
444 array $revDetails = [],
447 $rev = $this->getRevisionRecordFromDetailsArray( $title, $revDetails );
449 $store = MediaWikiServices
::getInstance()->getRevisionStore();
451 $this->setExpectedException(
452 get_class( $exception ),
453 $exception->getMessage(),
454 $exception->getCode()
456 $store->insertRevisionOn( $rev, wfGetDB( DB_MASTER
) );
459 public function provideNewNullRevision() {
461 Title
::newFromText( 'UTPage_notAutoCreated' ),
462 CommentStoreComment
::newUnsavedComment( __METHOD__
. ' comment1' ),
466 Title
::newFromText( 'UTPage_notAutoCreated' ),
467 CommentStoreComment
::newUnsavedComment( __METHOD__
. ' comment2', [ 'a' => 1 ] ),
473 * @dataProvider provideNewNullRevision
474 * @covers \MediaWiki\Storage\RevisionStore::newNullRevision
476 public function testNewNullRevision( Title
$title, $comment, $minor ) {
477 $this->overrideMwServices();
479 $page = WikiPage
::factory( $title );
480 $status = $page->doEditContent(
481 new WikitextContent( __METHOD__
),
486 /** @var Revision $rev */
487 $rev = $status->value
['revision'];
489 $store = MediaWikiServices
::getInstance()->getRevisionStore();
490 $user = TestUserRegistry
::getMutableTestUser( __METHOD__
)->getUser();
492 $parent = $store->getRevisionById( $rev->getId() );
493 $record = $store->newNullRevision(
494 wfGetDB( DB_MASTER
),
501 $this->assertEquals( $title->getNamespace(), $record->getPageAsLinkTarget()->getNamespace() );
502 $this->assertEquals( $title->getDBkey(), $record->getPageAsLinkTarget()->getDBkey() );
503 $this->assertEquals( $comment, $record->getComment() );
504 $this->assertEquals( $minor, $record->isMinor() );
505 $this->assertEquals( $user->getName(), $record->getUser()->getName() );
506 $this->assertEquals( $parent->getId(), $record->getParentId() );
508 $parentSlot = $parent->getSlot( 'main' );
509 $slot = $record->getSlot( 'main' );
511 $this->assertTrue( $slot->isInherited(), 'isInherited' );
512 $this->assertSame( $parentSlot->getOrigin(), $slot->getOrigin(), 'getOrigin' );
513 $this->assertSameSlotContent( $parentSlot, $slot );
517 * @covers \MediaWiki\Storage\RevisionStore::newNullRevision
519 public function testNewNullRevision_nonExistingTitle() {
520 $store = MediaWikiServices
::getInstance()->getRevisionStore();
521 $record = $store->newNullRevision(
522 wfGetDB( DB_MASTER
),
523 Title
::newFromText( __METHOD__
. '.iDontExist!' ),
524 CommentStoreComment
::newUnsavedComment( __METHOD__
. ' comment' ),
526 TestUserRegistry
::getMutableTestUser( __METHOD__
)->getUser()
528 $this->assertNull( $record );
532 * @covers \MediaWiki\Storage\RevisionStore::getRcIdIfUnpatrolled
534 public function testGetRcIdIfUnpatrolled_returnsRecentChangesId() {
535 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
536 $status = $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
);
537 /** @var Revision $rev */
538 $rev = $status->value
['revision'];
540 $store = MediaWikiServices
::getInstance()->getRevisionStore();
541 $revisionRecord = $store->getRevisionById( $rev->getId() );
542 $result = $store->getRcIdIfUnpatrolled( $revisionRecord );
544 $this->assertGreaterThan( 0, $result );
546 $page->getRevision()->getRecentChange()->getAttribute( 'rc_id' ),
552 * @covers \MediaWiki\Storage\RevisionStore::getRcIdIfUnpatrolled
554 public function testGetRcIdIfUnpatrolled_returnsZeroIfPatrolled() {
555 // This assumes that sysops are auto patrolled
556 $sysop = $this->getTestSysop()->getUser();
557 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
558 $status = $page->doEditContent(
559 new WikitextContent( __METHOD__
),
565 /** @var Revision $rev */
566 $rev = $status->value
['revision'];
568 $store = MediaWikiServices
::getInstance()->getRevisionStore();
569 $revisionRecord = $store->getRevisionById( $rev->getId() );
570 $result = $store->getRcIdIfUnpatrolled( $revisionRecord );
572 $this->assertSame( 0, $result );
576 * @covers \MediaWiki\Storage\RevisionStore::getRecentChange
578 public function testGetRecentChange() {
579 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
580 $content = new WikitextContent( __METHOD__
);
581 $status = $page->doEditContent( $content, __METHOD__
);
582 /** @var Revision $rev */
583 $rev = $status->value
['revision'];
585 $store = MediaWikiServices
::getInstance()->getRevisionStore();
586 $revRecord = $store->getRevisionById( $rev->getId() );
587 $recentChange = $store->getRecentChange( $revRecord );
589 $this->assertEquals( $rev->getId(), $recentChange->getAttribute( 'rc_this_oldid' ) );
590 $this->assertEquals( $rev->getRecentChange(), $recentChange );
594 * @covers \MediaWiki\Storage\RevisionStore::getRevisionById
596 public function testGetRevisionById() {
597 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
598 $content = new WikitextContent( __METHOD__
);
599 $status = $page->doEditContent( $content, __METHOD__
);
600 /** @var Revision $rev */
601 $rev = $status->value
['revision'];
603 $store = MediaWikiServices
::getInstance()->getRevisionStore();
604 $revRecord = $store->getRevisionById( $rev->getId() );
606 $this->assertSame( $rev->getId(), $revRecord->getId() );
607 $this->assertTrue( $revRecord->getSlot( 'main' )->getContent()->equals( $content ) );
608 $this->assertSame( __METHOD__
, $revRecord->getComment()->text
);
612 * @covers \MediaWiki\Storage\RevisionStore::getRevisionByTitle
614 public function testGetRevisionByTitle() {
615 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
616 $content = new WikitextContent( __METHOD__
);
617 $status = $page->doEditContent( $content, __METHOD__
);
618 /** @var Revision $rev */
619 $rev = $status->value
['revision'];
621 $store = MediaWikiServices
::getInstance()->getRevisionStore();
622 $revRecord = $store->getRevisionByTitle( $page->getTitle() );
624 $this->assertSame( $rev->getId(), $revRecord->getId() );
625 $this->assertTrue( $revRecord->getSlot( 'main' )->getContent()->equals( $content ) );
626 $this->assertSame( __METHOD__
, $revRecord->getComment()->text
);
630 * @covers \MediaWiki\Storage\RevisionStore::getRevisionByPageId
632 public function testGetRevisionByPageId() {
633 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
634 $content = new WikitextContent( __METHOD__
);
635 $status = $page->doEditContent( $content, __METHOD__
);
636 /** @var Revision $rev */
637 $rev = $status->value
['revision'];
639 $store = MediaWikiServices
::getInstance()->getRevisionStore();
640 $revRecord = $store->getRevisionByPageId( $page->getId() );
642 $this->assertSame( $rev->getId(), $revRecord->getId() );
643 $this->assertTrue( $revRecord->getSlot( 'main' )->getContent()->equals( $content ) );
644 $this->assertSame( __METHOD__
, $revRecord->getComment()->text
);
648 * @covers \MediaWiki\Storage\RevisionStore::getRevisionByTimestamp
650 public function testGetRevisionByTimestamp() {
651 // Make sure there is 1 second between the last revision and the rev we create...
652 // Otherwise we might not get the correct revision and the test may fail...
655 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
656 $content = new WikitextContent( __METHOD__
);
657 $status = $page->doEditContent( $content, __METHOD__
);
658 /** @var Revision $rev */
659 $rev = $status->value
['revision'];
661 $store = MediaWikiServices
::getInstance()->getRevisionStore();
662 $revRecord = $store->getRevisionByTimestamp(
667 $this->assertSame( $rev->getId(), $revRecord->getId() );
668 $this->assertTrue( $revRecord->getSlot( 'main' )->getContent()->equals( $content ) );
669 $this->assertSame( __METHOD__
, $revRecord->getComment()->text
);
672 protected function revisionToRow( Revision
$rev ) {
673 $page = WikiPage
::factory( $rev->getTitle() );
676 'rev_id' => (string)$rev->getId(),
677 'rev_page' => (string)$rev->getPage(),
678 'rev_text_id' => (string)$rev->getTextId(),
679 'rev_timestamp' => $this->db
->timestamp( $rev->getTimestamp() ),
680 'rev_user_text' => (string)$rev->getUserText(),
681 'rev_user' => (string)$rev->getUser(),
682 'rev_minor_edit' => $rev->isMinor() ?
'1' : '0',
683 'rev_deleted' => (string)$rev->getVisibility(),
684 'rev_len' => (string)$rev->getSize(),
685 'rev_parent_id' => (string)$rev->getParentId(),
686 'rev_sha1' => (string)$rev->getSha1(),
687 'rev_comment_text' => $rev->getComment(),
688 'rev_comment_data' => null,
689 'rev_comment_cid' => null,
690 'rev_content_format' => $rev->getContentFormat(),
691 'rev_content_model' => $rev->getContentModel(),
692 'page_namespace' => (string)$page->getTitle()->getNamespace(),
693 'page_title' => $page->getTitle()->getDBkey(),
694 'page_id' => (string)$page->getId(),
695 'page_latest' => (string)$page->getLatest(),
696 'page_is_redirect' => $page->isRedirect() ?
'1' : '0',
697 'page_len' => (string)$page->getContent()->getSize(),
698 'user_name' => (string)$rev->getUserText(),
702 private function assertRevisionRecordMatchesRevision(
704 RevisionRecord
$record
706 $this->assertSame( $rev->getId(), $record->getId() );
707 $this->assertSame( $rev->getPage(), $record->getPageId() );
708 $this->assertSame( $rev->getTimestamp(), $record->getTimestamp() );
709 $this->assertSame( $rev->getUserText(), $record->getUser()->getName() );
710 $this->assertSame( $rev->getUser(), $record->getUser()->getId() );
711 $this->assertSame( $rev->isMinor(), $record->isMinor() );
712 $this->assertSame( $rev->getVisibility(), $record->getVisibility() );
713 $this->assertSame( $rev->getSize(), $record->getSize() );
715 * @note As of MW 1.31, the database schema allows the parent ID to be
716 * NULL to indicate that it is unknown.
718 $expectedParent = $rev->getParentId();
719 if ( $expectedParent === null ) {
722 $this->assertSame( $expectedParent, $record->getParentId() );
723 $this->assertSame( $rev->getSha1(), $record->getSha1() );
724 $this->assertSame( $rev->getComment(), $record->getComment()->text
);
725 $this->assertSame( $rev->getContentFormat(), $record->getContent( 'main' )->getDefaultFormat() );
726 $this->assertSame( $rev->getContentModel(), $record->getContent( 'main' )->getModel() );
727 $this->assertLinkTargetsEqual( $rev->getTitle(), $record->getPageAsLinkTarget() );
731 * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow
732 * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow_1_29
734 public function testNewRevisionFromRow_anonEdit() {
735 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
736 $text = __METHOD__
. 'a-ä';
737 /** @var Revision $rev */
738 $rev = $page->doEditContent(
739 new WikitextContent( $text ),
741 )->value
['revision'];
743 $store = MediaWikiServices
::getInstance()->getRevisionStore();
744 $record = $store->newRevisionFromRow(
745 $this->revisionToRow( $rev ),
749 $this->assertRevisionRecordMatchesRevision( $rev, $record );
750 $this->assertSame( $text, $rev->getContent()->serialize() );
754 * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow
755 * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow_1_29
757 public function testNewRevisionFromRow_anonEdit_legacyEncoding() {
758 $this->setMwGlobals( 'wgLegacyEncoding', 'windows-1252' );
759 $this->overrideMwServices();
760 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
761 $text = __METHOD__
. 'a-ä';
762 /** @var Revision $rev */
763 $rev = $page->doEditContent(
764 new WikitextContent( $text ),
766 )->value
['revision'];
768 $store = MediaWikiServices
::getInstance()->getRevisionStore();
769 $record = $store->newRevisionFromRow(
770 $this->revisionToRow( $rev ),
774 $this->assertRevisionRecordMatchesRevision( $rev, $record );
775 $this->assertSame( $text, $rev->getContent()->serialize() );
779 * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow
780 * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromRow_1_29
782 public function testNewRevisionFromRow_userEdit() {
783 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
784 $text = __METHOD__
. 'b-ä';
785 /** @var Revision $rev */
786 $rev = $page->doEditContent(
787 new WikitextContent( $text ),
791 $this->getTestUser()->getUser()
792 )->value
['revision'];
794 $store = MediaWikiServices
::getInstance()->getRevisionStore();
795 $record = $store->newRevisionFromRow(
796 $this->revisionToRow( $rev ),
800 $this->assertRevisionRecordMatchesRevision( $rev, $record );
801 $this->assertSame( $text, $rev->getContent()->serialize() );
805 * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromArchiveRow
807 public function testNewRevisionFromArchiveRow() {
808 $store = MediaWikiServices
::getInstance()->getRevisionStore();
809 $title = Title
::newFromText( __METHOD__
);
810 $text = __METHOD__
. '-bä';
811 $page = WikiPage
::factory( $title );
812 /** @var Revision $orig */
813 $orig = $page->doEditContent( new WikitextContent( $text ), __METHOD__
)
815 $page->doDeleteArticle( __METHOD__
);
817 $db = wfGetDB( DB_MASTER
);
818 $arQuery = $store->getArchiveQueryInfo();
820 $arQuery['tables'], $arQuery['fields'], [ 'ar_rev_id' => $orig->getId() ],
821 __METHOD__
, [], $arQuery['joins']
823 $this->assertTrue( is_object( $res ), 'query failed' );
825 $row = $res->fetchObject();
827 $record = $store->newRevisionFromArchiveRow( $row );
829 $this->assertRevisionRecordMatchesRevision( $orig, $record );
830 $this->assertSame( $text, $record->getContent( 'main' )->serialize() );
834 * @covers \MediaWiki\Storage\RevisionStore::newRevisionFromArchiveRow
836 public function testNewRevisionFromArchiveRow_legacyEncoding() {
837 $this->setMwGlobals( 'wgLegacyEncoding', 'windows-1252' );
838 $this->overrideMwServices();
839 $store = MediaWikiServices
::getInstance()->getRevisionStore();
840 $title = Title
::newFromText( __METHOD__
);
841 $text = __METHOD__
. '-bä';
842 $page = WikiPage
::factory( $title );
843 /** @var Revision $orig */
844 $orig = $page->doEditContent( new WikitextContent( $text ), __METHOD__
)
846 $page->doDeleteArticle( __METHOD__
);
848 $db = wfGetDB( DB_MASTER
);
849 $arQuery = $store->getArchiveQueryInfo();
851 $arQuery['tables'], $arQuery['fields'], [ 'ar_rev_id' => $orig->getId() ],
852 __METHOD__
, [], $arQuery['joins']
854 $this->assertTrue( is_object( $res ), 'query failed' );
856 $row = $res->fetchObject();
858 $record = $store->newRevisionFromArchiveRow( $row );
860 $this->assertRevisionRecordMatchesRevision( $orig, $record );
861 $this->assertSame( $text, $record->getContent( 'main' )->serialize() );
865 * @covers \MediaWiki\Storage\RevisionStore::loadRevisionFromId
867 public function testLoadRevisionFromId() {
868 $title = Title
::newFromText( __METHOD__
);
869 $page = WikiPage
::factory( $title );
870 /** @var Revision $rev */
871 $rev = $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
)
874 $store = MediaWikiServices
::getInstance()->getRevisionStore();
875 $result = $store->loadRevisionFromId( wfGetDB( DB_MASTER
), $rev->getId() );
876 $this->assertRevisionRecordMatchesRevision( $rev, $result );
880 * @covers \MediaWiki\Storage\RevisionStore::loadRevisionFromPageId
882 public function testLoadRevisionFromPageId() {
883 $title = Title
::newFromText( __METHOD__
);
884 $page = WikiPage
::factory( $title );
885 /** @var Revision $rev */
886 $rev = $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
)
889 $store = MediaWikiServices
::getInstance()->getRevisionStore();
890 $result = $store->loadRevisionFromPageId( wfGetDB( DB_MASTER
), $page->getId() );
891 $this->assertRevisionRecordMatchesRevision( $rev, $result );
895 * @covers \MediaWiki\Storage\RevisionStore::loadRevisionFromTitle
897 public function testLoadRevisionFromTitle() {
898 $title = Title
::newFromText( __METHOD__
);
899 $page = WikiPage
::factory( $title );
900 /** @var Revision $rev */
901 $rev = $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
)
904 $store = MediaWikiServices
::getInstance()->getRevisionStore();
905 $result = $store->loadRevisionFromTitle( wfGetDB( DB_MASTER
), $title );
906 $this->assertRevisionRecordMatchesRevision( $rev, $result );
910 * @covers \MediaWiki\Storage\RevisionStore::loadRevisionFromTimestamp
912 public function testLoadRevisionFromTimestamp() {
913 $title = Title
::newFromText( __METHOD__
);
914 $page = WikiPage
::factory( $title );
915 /** @var Revision $revOne */
916 $revOne = $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
)
918 // Sleep to ensure different timestamps... )(evil)
920 /** @var Revision $revTwo */
921 $revTwo = $page->doEditContent( new WikitextContent( __METHOD__
. 'a' ), '' )
924 $store = MediaWikiServices
::getInstance()->getRevisionStore();
926 $store->loadRevisionFromTimestamp( wfGetDB( DB_MASTER
), $title, '20150101010101' )
930 $store->loadRevisionFromTimestamp(
931 wfGetDB( DB_MASTER
),
933 $revOne->getTimestamp()
938 $store->loadRevisionFromTimestamp(
939 wfGetDB( DB_MASTER
),
941 $revTwo->getTimestamp()
947 * @covers \MediaWiki\Storage\RevisionStore::listRevisionSizes
949 public function testGetParentLengths() {
950 $page = WikiPage
::factory( Title
::newFromText( __METHOD__
) );
951 /** @var Revision $revOne */
952 $revOne = $page->doEditContent(
953 new WikitextContent( __METHOD__
), __METHOD__
954 )->value
['revision'];
955 /** @var Revision $revTwo */
956 $revTwo = $page->doEditContent(
957 new WikitextContent( __METHOD__
. '2' ), __METHOD__
958 )->value
['revision'];
960 $store = MediaWikiServices
::getInstance()->getRevisionStore();
963 $revOne->getId() => strlen( __METHOD__
),
965 $store->listRevisionSizes(
966 wfGetDB( DB_MASTER
),
972 $revOne->getId() => strlen( __METHOD__
),
973 $revTwo->getId() => strlen( __METHOD__
) +
1,
975 $store->listRevisionSizes(
976 wfGetDB( DB_MASTER
),
977 [ $revOne->getId(), $revTwo->getId() ]
983 * @covers \MediaWiki\Storage\RevisionStore::getPreviousRevision
985 public function testGetPreviousRevision() {
986 $page = WikiPage
::factory( Title
::newFromText( __METHOD__
) );
987 /** @var Revision $revOne */
988 $revOne = $page->doEditContent(
989 new WikitextContent( __METHOD__
), __METHOD__
990 )->value
['revision'];
991 /** @var Revision $revTwo */
992 $revTwo = $page->doEditContent(
993 new WikitextContent( __METHOD__
. '2' ), __METHOD__
994 )->value
['revision'];
996 $store = MediaWikiServices
::getInstance()->getRevisionStore();
998 $store->getPreviousRevision( $store->getRevisionById( $revOne->getId() ) )
1002 $store->getPreviousRevision( $store->getRevisionById( $revTwo->getId() ) )->getId()
1007 * @covers \MediaWiki\Storage\RevisionStore::getNextRevision
1009 public function testGetNextRevision() {
1010 $page = WikiPage
::factory( Title
::newFromText( __METHOD__
) );
1011 /** @var Revision $revOne */
1012 $revOne = $page->doEditContent(
1013 new WikitextContent( __METHOD__
), __METHOD__
1014 )->value
['revision'];
1015 /** @var Revision $revTwo */
1016 $revTwo = $page->doEditContent(
1017 new WikitextContent( __METHOD__
. '2' ), __METHOD__
1018 )->value
['revision'];
1020 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1023 $store->getNextRevision( $store->getRevisionById( $revOne->getId() ) )->getId()
1026 $store->getNextRevision( $store->getRevisionById( $revTwo->getId() ) )
1031 * @covers \MediaWiki\Storage\RevisionStore::getTimestampFromId
1033 public function testGetTimestampFromId_found() {
1034 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
1035 /** @var Revision $rev */
1036 $rev = $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
)
1037 ->value
['revision'];
1039 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1040 $result = $store->getTimestampFromId(
1045 $this->assertSame( $rev->getTimestamp(), $result );
1049 * @covers \MediaWiki\Storage\RevisionStore::getTimestampFromId
1051 public function testGetTimestampFromId_notFound() {
1052 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
1053 /** @var Revision $rev */
1054 $rev = $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
)
1055 ->value
['revision'];
1057 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1058 $result = $store->getTimestampFromId(
1063 $this->assertFalse( $result );
1067 * @covers \MediaWiki\Storage\RevisionStore::countRevisionsByPageId
1069 public function testCountRevisionsByPageId() {
1070 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1071 $page = WikiPage
::factory( Title
::newFromText( __METHOD__
) );
1075 $store->countRevisionsByPageId( wfGetDB( DB_MASTER
), $page->getId() )
1077 $page->doEditContent( new WikitextContent( 'a' ), 'a' );
1080 $store->countRevisionsByPageId( wfGetDB( DB_MASTER
), $page->getId() )
1082 $page->doEditContent( new WikitextContent( 'b' ), 'b' );
1085 $store->countRevisionsByPageId( wfGetDB( DB_MASTER
), $page->getId() )
1090 * @covers \MediaWiki\Storage\RevisionStore::countRevisionsByTitle
1092 public function testCountRevisionsByTitle() {
1093 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1094 $page = WikiPage
::factory( Title
::newFromText( __METHOD__
) );
1098 $store->countRevisionsByTitle( wfGetDB( DB_MASTER
), $page->getTitle() )
1100 $page->doEditContent( new WikitextContent( 'a' ), 'a' );
1103 $store->countRevisionsByTitle( wfGetDB( DB_MASTER
), $page->getTitle() )
1105 $page->doEditContent( new WikitextContent( 'b' ), 'b' );
1108 $store->countRevisionsByTitle( wfGetDB( DB_MASTER
), $page->getTitle() )
1113 * @covers \MediaWiki\Storage\RevisionStore::userWasLastToEdit
1115 public function testUserWasLastToEdit_false() {
1116 $sysop = $this->getTestSysop()->getUser();
1117 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
1118 $page->doEditContent( new WikitextContent( __METHOD__
), __METHOD__
);
1120 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1121 $result = $store->userWasLastToEdit(
1122 wfGetDB( DB_MASTER
),
1127 $this->assertFalse( $result );
1131 * @covers \MediaWiki\Storage\RevisionStore::userWasLastToEdit
1133 public function testUserWasLastToEdit_true() {
1134 $startTime = wfTimestampNow();
1135 $sysop = $this->getTestSysop()->getUser();
1136 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
1137 $page->doEditContent(
1138 new WikitextContent( __METHOD__
),
1145 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1146 $result = $store->userWasLastToEdit(
1147 wfGetDB( DB_MASTER
),
1152 $this->assertTrue( $result );
1156 * @covers \MediaWiki\Storage\RevisionStore::getKnownCurrentRevision
1158 public function testGetKnownCurrentRevision() {
1159 $page = WikiPage
::factory( Title
::newFromText( 'UTPage' ) );
1160 /** @var Revision $rev */
1161 $rev = $page->doEditContent(
1162 new WikitextContent( __METHOD__
. 'b' ),
1166 $this->getTestUser()->getUser()
1167 )->value
['revision'];
1169 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1170 $record = $store->getKnownCurrentRevision(
1175 $this->assertRevisionRecordMatchesRevision( $rev, $record );
1178 public function provideNewMutableRevisionFromArray() {
1179 yield
'Basic array, with page & id' => [
1184 'timestamp' => '20171017114835',
1185 'user_text' => '111.0.1.2',
1187 'minor_edit' => false,
1191 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1192 'comment' => 'Goat Comment!',
1193 'content_format' => 'text/x-wiki',
1194 'content_model' => 'wikitext',
1197 yield
'Basic array, content object' => [
1201 'timestamp' => '20171017114835',
1202 'user_text' => '111.0.1.2',
1204 'minor_edit' => false,
1208 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1209 'comment' => 'Goat Comment!',
1210 'content' => new WikitextContent( 'Some Content' ),
1213 yield
'Basic array, serialized text' => [
1217 'timestamp' => '20171017114835',
1218 'user_text' => '111.0.1.2',
1220 'minor_edit' => false,
1224 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1225 'comment' => 'Goat Comment!',
1226 'text' => ( new WikitextContent( 'Söme Content' ) )->serialize(),
1229 yield
'Basic array, serialized text, utf-8 flags' => [
1233 'timestamp' => '20171017114835',
1234 'user_text' => '111.0.1.2',
1236 'minor_edit' => false,
1240 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1241 'comment' => 'Goat Comment!',
1242 'text' => ( new WikitextContent( 'Söme Content' ) )->serialize(),
1246 yield
'Basic array, with title' => [
1248 'title' => Title
::newFromText( 'SomeText' ),
1250 'timestamp' => '20171017114835',
1251 'user_text' => '111.0.1.2',
1253 'minor_edit' => false,
1257 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1258 'comment' => 'Goat Comment!',
1259 'content_format' => 'text/x-wiki',
1260 'content_model' => 'wikitext',
1263 yield
'Basic array, no user field' => [
1268 'timestamp' => '20171017114835',
1269 'user_text' => '111.0.1.3',
1270 'minor_edit' => false,
1274 'sha1' => 'rdqbbzs3pkhihgbs8qf2q9jsvheag5z',
1275 'comment' => 'Goat Comment!',
1276 'content_format' => 'text/x-wiki',
1277 'content_model' => 'wikitext',
1283 * @dataProvider provideNewMutableRevisionFromArray
1284 * @covers \MediaWiki\Storage\RevisionStore::newMutableRevisionFromArray
1286 public function testNewMutableRevisionFromArray( array $array ) {
1287 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1289 $result = $store->newMutableRevisionFromArray( $array );
1291 if ( isset( $array['id'] ) ) {
1292 $this->assertSame( $array['id'], $result->getId() );
1294 if ( isset( $array['page'] ) ) {
1295 $this->assertSame( $array['page'], $result->getPageId() );
1297 $this->assertSame( $array['timestamp'], $result->getTimestamp() );
1298 $this->assertSame( $array['user_text'], $result->getUser()->getName() );
1299 if ( isset( $array['user'] ) ) {
1300 $this->assertSame( $array['user'], $result->getUser()->getId() );
1302 $this->assertSame( (bool)$array['minor_edit'], $result->isMinor() );
1303 $this->assertSame( $array['deleted'], $result->getVisibility() );
1304 $this->assertSame( $array['len'], $result->getSize() );
1305 $this->assertSame( $array['parent_id'], $result->getParentId() );
1306 $this->assertSame( $array['sha1'], $result->getSha1() );
1307 $this->assertSame( $array['comment'], $result->getComment()->text
);
1308 if ( isset( $array['content'] ) ) {
1310 $result->getSlot( 'main' )->getContent()->equals( $array['content'] )
1312 } elseif ( isset( $array['text'] ) ) {
1313 $this->assertSame( $array['text'], $result->getSlot( 'main' )->getContent()->serialize() );
1316 $array['content_format'],
1317 $result->getSlot( 'main' )->getContent()->getDefaultFormat()
1319 $this->assertSame( $array['content_model'], $result->getSlot( 'main' )->getModel() );
1324 * @dataProvider provideNewMutableRevisionFromArray
1325 * @covers \MediaWiki\Storage\RevisionStore::newMutableRevisionFromArray
1327 public function testNewMutableRevisionFromArray_legacyEncoding( array $array ) {
1328 $cache = new WANObjectCache( [ 'cache' => new HashBagOStuff() ] );
1329 $lb = MediaWikiServices
::getInstance()->getDBLoadBalancer();
1330 $blobStore = new SqlBlobStore( $lb, $cache );
1331 $blobStore->setLegacyEncoding( 'windows-1252', Language
::factory( 'en' ) );
1333 $factory = $this->getMockBuilder( BlobStoreFactory
::class )
1334 ->setMethods( [ 'newBlobStore', 'newSqlBlobStore' ] )
1335 ->disableOriginalConstructor()
1337 $factory->expects( $this->any() )
1338 ->method( 'newBlobStore' )
1339 ->willReturn( $blobStore );
1340 $factory->expects( $this->any() )
1341 ->method( 'newSqlBlobStore' )
1342 ->willReturn( $blobStore );
1344 $this->setService( 'BlobStoreFactory', $factory );
1346 $this->testNewMutableRevisionFromArray( $array );
1349 protected function getDefaultQueryFields( $returnTextIdField = true ) {
1360 if ( $returnTextIdField ) {
1361 $fields[] = 'rev_text_id';
1366 protected function getCommentQueryFields() {
1368 'rev_comment_text' => 'rev_comment',
1369 'rev_comment_data' => 'NULL',
1370 'rev_comment_cid' => 'NULL',
1374 protected function getActorQueryFields() {
1376 'rev_user' => 'rev_user',
1377 'rev_user_text' => 'rev_user_text',
1378 'rev_actor' => 'NULL',
1382 protected function getContentHandlerQueryFields() {
1384 'rev_content_format',
1385 'rev_content_model',
1389 abstract public function provideGetQueryInfo();
1392 * @dataProvider provideGetQueryInfo
1393 * @covers \MediaWiki\Storage\RevisionStore::getQueryInfo
1395 public function testGetQueryInfo( $options, $expected ) {
1396 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1398 $queryInfo = $store->getQueryInfo( $options );
1400 $this->assertArrayEqualsIgnoringIntKeyOrder(
1401 $expected['tables'],
1402 $queryInfo['tables']
1404 $this->assertArrayEqualsIgnoringIntKeyOrder(
1405 $expected['fields'],
1406 $queryInfo['fields']
1408 $this->assertArrayEqualsIgnoringIntKeyOrder(
1414 protected function getDefaultArchiveFields( $returnTextFields = true ) {
1428 if ( $returnTextFields ) {
1429 $fields[] = 'ar_text_id';
1434 abstract public function provideGetArchiveQueryInfo();
1437 * @dataProvider provideGetArchiveQueryInfo
1438 * @covers \MediaWiki\Storage\RevisionStore::getArchiveQueryInfo
1440 public function testGetArchiveQueryInfo( $expected ) {
1441 $store = MediaWikiServices
::getInstance()->getRevisionStore();
1443 $archiveQueryInfo = $store->getArchiveQueryInfo();
1445 $this->assertArrayEqualsIgnoringIntKeyOrder(
1446 $expected['tables'],
1447 $archiveQueryInfo['tables']
1450 $this->assertArrayEqualsIgnoringIntKeyOrder(
1451 $expected['fields'],
1452 $archiveQueryInfo['fields']
1455 $this->assertArrayEqualsIgnoringIntKeyOrder(
1457 $archiveQueryInfo['joins']
1462 * Assert that the two arrays passed are equal, ignoring the order of the values that integer
1465 * Note: Failures of this assertion can be slightly confusing as the arrays are actually
1466 * split into a string key array and an int key array before assertions occur.
1468 * @param array $expected
1469 * @param array $actual
1471 private function assertArrayEqualsIgnoringIntKeyOrder( array $expected, array $actual ) {
1472 $this->objectAssociativeSort( $expected );
1473 $this->objectAssociativeSort( $actual );
1475 // Separate the int key values from the string key values so that assertion failures are
1476 // easier to understand.
1477 $expectedIntKeyValues = [];
1478 $actualIntKeyValues = [];
1480 // Remove all int keys and re add them at the end after sorting by value
1481 // This will result in all int keys being in the same order with same ints at the end of
1483 foreach ( $expected as $key => $value ) {
1484 if ( is_int( $key ) ) {
1485 unset( $expected[$key] );
1486 $expectedIntKeyValues[] = $value;
1489 foreach ( $actual as $key => $value ) {
1490 if ( is_int( $key ) ) {
1491 unset( $actual[$key] );
1492 $actualIntKeyValues[] = $value;
1496 $this->assertArrayEquals( $expected, $actual, false, true );
1497 $this->assertArrayEquals( $expectedIntKeyValues, $actualIntKeyValues, false, true );