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 MediaWikiTestCase;
  17 use Psr\Log\LoggerInterface;
  18 use Psr\Log\NullLogger;
  19 use WANObjectCache;
  20 use Wikimedia\Rdbms\ILBFactory;
  21 use Wikimedia\Rdbms\ILoadBalancer;
  22 use Wikimedia\TestingAccessWrapper;
  23
  24 class RevisionStoreFactoryTest extends MediaWikiTestCase {
  25
  26         public function testValidConstruction_doesntCauseErrors() {
  27                 new RevisionStoreFactory(
  28                         $this->getMockLoadBalancerFactory(),
  29                         $this->getMockBlobStoreFactory(),
  30                         $this->getNameTableStoreFactory(),
  31                         $this->getMockSlotRoleRegistry(),
  32                         $this->getHashWANObjectCache(),
  33                         $this->getMockCommentStore(),
  34                         ActorMigration::newMigration(),
  35                         MIGRATION_OLD,
  36                         $this->getMockLoggerSpi(),
  37                         true
  38                 );
  39                 $this->assertTrue( true );
  40         }
  41
  42         public function provideWikiIds() {
  43                 yield [ true ];
  44                 yield [ false ];
  45                 yield [ 'somewiki' ];
  46                 yield [ 'somewiki', MIGRATION_OLD , false ];
  47                 yield [ 'somewiki', MIGRATION_NEW , true ];
  48         }
  49
  50         /**
  51          * @dataProvider provideWikiIds
  52          */
  53         public function testGetRevisionStore(
  54                 $wikiId,
  55                 $mcrMigrationStage = MIGRATION_OLD,
  56                 $contentHandlerUseDb = true
  57         ) {
  58                 $lbFactory = $this->getMockLoadBalancerFactory();
  59                 $blobStoreFactory = $this->getMockBlobStoreFactory();
  60                 $nameTableStoreFactory = $this->getNameTableStoreFactory();
  61                 $slotRoleRegistry = $this->getMockSlotRoleRegistry();
  62                 $cache = $this->getHashWANObjectCache();
  63                 $commentStore = $this->getMockCommentStore();
  64                 $actorMigration = ActorMigration::newMigration();
  65                 $loggerProvider = $this->getMockLoggerSpi();
  66
  67                 $factory = new RevisionStoreFactory(
  68                         $lbFactory,
  69                         $blobStoreFactory,
  70                         $nameTableStoreFactory,
  71                         $slotRoleRegistry,
  72                         $cache,
  73                         $commentStore,
  74                         $actorMigration,
  75                         $mcrMigrationStage,
  76                         $loggerProvider,
  77                         $contentHandlerUseDb
  78                 );
  79
  80                 $store = $factory->getRevisionStore( $wikiId );
  81                 $wrapper = TestingAccessWrapper::newFromObject( $store );
  82
  83                 // ensure the correct object type is returned
  84                 $this->assertInstanceOf( RevisionStore::class, $store );
  85
  86                 // ensure the RevisionStore is for the given wikiId
  87                 $this->assertSame( $wikiId, $wrapper->wikiId );
  88
  89                 // ensure all other required services are correctly set
  90                 $this->assertSame( $cache, $wrapper->cache );
  91                 $this->assertSame( $commentStore, $wrapper->commentStore );
  92                 $this->assertSame( $mcrMigrationStage, $wrapper->mcrMigrationStage );
  93                 $this->assertSame( $actorMigration, $wrapper->actorMigration );
  94                 $this->assertSame( $contentHandlerUseDb, $store->getContentHandlerUseDB() );
  95
  96                 $this->assertInstanceOf( ILoadBalancer::class, $wrapper->loadBalancer );
  97                 $this->assertInstanceOf( BlobStore::class, $wrapper->blobStore );
  98                 $this->assertInstanceOf( NameTableStore::class, $wrapper->contentModelStore );
  99                 $this->assertInstanceOf( NameTableStore::class, $wrapper->slotRoleStore );
 100                 $this->assertInstanceOf( LoggerInterface::class, $wrapper->logger );
 101         }
 102
 103         /**
 104          * @return \PHPUnit_Framework_MockObject_MockObject|ILoadBalancer
 105          */
 106         private function getMockLoadBalancer() {
 107                 return $this->getMockBuilder( ILoadBalancer::class )
 108                         ->disableOriginalConstructor()->getMock();
 109         }
 110
 111         /**
 112          * @return \PHPUnit_Framework_MockObject_MockObject|ILBFactory
 113          */
 114         private function getMockLoadBalancerFactory() {
 115                 $mock = $this->getMockBuilder( ILBFactory::class )
 116                         ->disableOriginalConstructor()->getMock();
 117
 118                 $mock->method( 'getMainLB' )
 119                         ->willReturnCallback( function () {
 120                                 return $this->getMockLoadBalancer();
 121                         } );
 122
 123                 return $mock;
 124         }
 125
 126         /**
 127          * @return \PHPUnit_Framework_MockObject_MockObject|SqlBlobStore
 128          */
 129         private function getMockSqlBlobStore() {
 130                 return $this->getMockBuilder( SqlBlobStore::class )
 131                         ->disableOriginalConstructor()->getMock();
 132         }
 133
 134         /**
 135          * @return \PHPUnit_Framework_MockObject_MockObject|BlobStoreFactory
 136          */
 137         private function getMockBlobStoreFactory() {
 138                 $mock = $this->getMockBuilder( BlobStoreFactory::class )
 139                         ->disableOriginalConstructor()->getMock();
 140
 141                 $mock->method( 'newSqlBlobStore' )
 142                         ->willReturnCallback( function () {
 143                                 return $this->getMockSqlBlobStore();
 144                         } );
 145
 146                 return $mock;
 147         }
 148
 149         /**
 150          * @return \PHPUnit_Framework_MockObject_MockObject|SlotRoleRegistry
 151          */
 152         private function getMockSlotRoleRegistry() {
 153                 $mock = $this->getMockBuilder( SlotRoleRegistry::class )
 154                         ->disableOriginalConstructor()->getMock();
 155
 156                 return $mock;
 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 }