tests/phpunit/includes/Revision/RevisionStoreFactoryTest.php

   1 <?php
   2
   3 namespace MediaWiki\Tests\Revision;
   4
   5 use ActorMigration;
   6 use CommentStore;
   7 use MediaWiki\Logger\Spi as LoggerSpi;
   8 use MediaWiki\Revision\RevisionStore;
   9 use MediaWiki\Revision\RevisionStoreFactory;
  10 use MediaWiki\Revision\SlotRoleRegistry;
  11 use MediaWiki\Storage\BlobStore;
  12 use MediaWiki\Storage\BlobStoreFactory;
  13 use MediaWiki\Storage\NameTableStore;
  14 use MediaWiki\Storage\NameTableStoreFactory;
  15 use MediaWiki\Storage\SqlBlobStore;
  16 use Psr\Log\LoggerInterface;
  17 use Psr\Log\NullLogger;
  18 use WANObjectCache;
  19 use Wikimedia\Rdbms\ILBFactory;
  20 use Wikimedia\Rdbms\ILoadBalancer;
  21 use Wikimedia\TestingAccessWrapper;
  22
  23 class RevisionStoreFactoryTest extends \MediaWikiIntegrationTestCase {
  24
  25         /**
  26          * @covers \MediaWiki\Revision\RevisionStoreFactory::__construct
  27          */
  28         public function testValidConstruction_doesntCauseErrors() {
  29                 new RevisionStoreFactory(
  30                         $this->getMockLoadBalancerFactory(),
  31                         $this->getMockBlobStoreFactory(),
  32                         $this->getNameTableStoreFactory(),
  33                         $this->getMockSlotRoleRegistry(),
  34                         $this->getHashWANObjectCache(),
  35                         $this->getMockCommentStore(),
  36                         ActorMigration::newMigration(),
  37                         MIGRATION_OLD,
  38                         $this->getMockLoggerSpi(),
  39                         true
  40                 );
  41                 $this->assertTrue( true );
  42         }
  43
  44         public function provideWikiIds() {
  45                 yield [ true ];
  46                 yield [ false ];
  47                 yield [ 'somewiki' ];
  48                 yield [ 'somewiki', MIGRATION_OLD , false ];
  49                 yield [ 'somewiki', MIGRATION_NEW , true ];
  50         }
  51
  52         /**
  53          * @dataProvider provideWikiIds
  54          * @covers \MediaWiki\Revision\RevisionStoreFactory::getRevisionStore
  55          */
  56         public function testGetRevisionStore(
  57                 $dbDomain,
  58                 $mcrMigrationStage = MIGRATION_OLD,
  59                 $contentHandlerUseDb = true
  60         ) {
  61                 $lbFactory = $this->getMockLoadBalancerFactory();
  62                 $blobStoreFactory = $this->getMockBlobStoreFactory();
  63                 $nameTableStoreFactory = $this->getNameTableStoreFactory();
  64                 $slotRoleRegistry = $this->getMockSlotRoleRegistry();
  65                 $cache = $this->getHashWANObjectCache();
  66                 $commentStore = $this->getMockCommentStore();
  67                 $actorMigration = ActorMigration::newMigration();
  68                 $loggerProvider = $this->getMockLoggerSpi();
  69
  70                 $factory = new RevisionStoreFactory(
  71                         $lbFactory,
  72                         $blobStoreFactory,
  73                         $nameTableStoreFactory,
  74                         $slotRoleRegistry,
  75                         $cache,
  76                         $commentStore,
  77                         $actorMigration,
  78                         $mcrMigrationStage,
  79                         $loggerProvider,
  80                         $contentHandlerUseDb
  81                 );
  82
  83                 $store = $factory->getRevisionStore( $dbDomain );
  84                 $wrapper = TestingAccessWrapper::newFromObject( $store );
  85
  86                 // ensure the correct object type is returned
  87                 $this->assertInstanceOf( RevisionStore::class, $store );
  88
  89                 // ensure the RevisionStore is for the given wikiId
  90                 $this->assertSame( $dbDomain, $wrapper->dbDomain );
  91
  92                 // ensure all other required services are correctly set
  93                 $this->assertSame( $cache, $wrapper->cache );
  94                 $this->assertSame( $commentStore, $wrapper->commentStore );
  95                 $this->assertSame( $mcrMigrationStage, $wrapper->mcrMigrationStage );
  96                 $this->assertSame( $actorMigration, $wrapper->actorMigration );
  97                 $this->assertSame( $contentHandlerUseDb, $store->getContentHandlerUseDB() );
  98
  99                 $this->assertInstanceOf( ILoadBalancer::class, $wrapper->loadBalancer );
 100                 $this->assertInstanceOf( BlobStore::class, $wrapper->blobStore );
 101                 $this->assertInstanceOf( NameTableStore::class, $wrapper->contentModelStore );
 102                 $this->assertInstanceOf( NameTableStore::class, $wrapper->slotRoleStore );
 103                 $this->assertInstanceOf( LoggerInterface::class, $wrapper->logger );
 104         }
 105
 106         /**
 107          * @return \PHPUnit_Framework_MockObject_MockObject|ILoadBalancer
 108          */
 109         private function getMockLoadBalancer() {
 110                 return $this->getMockBuilder( ILoadBalancer::class )
 111                         ->disableOriginalConstructor()->getMock();
 112         }
 113
 114         /**
 115          * @return \PHPUnit_Framework_MockObject_MockObject|ILBFactory
 116          */
 117         private function getMockLoadBalancerFactory() {
 118                 $mock = $this->getMockBuilder( ILBFactory::class )
 119                         ->disableOriginalConstructor()->getMock();
 120
 121                 $mock->method( 'getMainLB' )
 122                         ->willReturnCallback( function () {
 123                                 return $this->getMockLoadBalancer();
 124                         } );
 125
 126                 return $mock;
 127         }
 128
 129         /**
 130          * @return \PHPUnit_Framework_MockObject_MockObject|SqlBlobStore
 131          */
 132         private function getMockSqlBlobStore() {
 133                 return $this->getMockBuilder( SqlBlobStore::class )
 134                         ->disableOriginalConstructor()->getMock();
 135         }
 136
 137         /**
 138          * @return \PHPUnit_Framework_MockObject_MockObject|BlobStoreFactory
 139          */
 140         private function getMockBlobStoreFactory() {
 141                 $mock = $this->getMockBuilder( BlobStoreFactory::class )
 142                         ->disableOriginalConstructor()->getMock();
 143
 144                 $mock->method( 'newSqlBlobStore' )
 145                         ->willReturnCallback( function () {
 146                                 return $this->getMockSqlBlobStore();
 147                         } );
 148
 149                 return $mock;
 150         }
 151
 152         /**
 153          * @return SlotRoleRegistry
 154          */
 155         private function getMockSlotRoleRegistry() {
 156                 return $this->createMock( SlotRoleRegistry::class );
 157         }
 158
 159         /**
 160          * @return NameTableStoreFactory
 161          */
 162         private function getNameTableStoreFactory() {
 163                 return new NameTableStoreFactory(
 164                         $this->getMockLoadBalancerFactory(),
 165                         $this->getHashWANObjectCache(),
 166                         new NullLogger() );
 167         }
 168
 169         /**
 170          * @return \PHPUnit_Framework_MockObject_MockObject|CommentStore
 171          */
 172         private function getMockCommentStore() {
 173                 return $this->getMockBuilder( CommentStore::class )
 174                         ->disableOriginalConstructor()->getMock();
 175         }
 176
 177         private function getHashWANObjectCache() {
 178                 return new WANObjectCache( [ 'cache' => new \HashBagOStuff() ] );
 179         }
 180
 181         /**
 182          * @return \PHPUnit_Framework_MockObject_MockObject|LoggerSpi
 183          */
 184         private function getMockLoggerSpi() {
 185                 $mock = $this->getMock( LoggerSpi::class );
 186
 187                 $mock->method( 'getLogger' )
 188                         ->willReturn( new NullLogger() );
 189
 190                 return $mock;
 191         }
 192
 193 }