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