tests/phpunit/includes/Storage/NameTableStoreTest.php

   1 <?php
   2
   3 namespace MediaWiki\Tests\Storage;
   4
   5 use BagOStuff;
   6 use EmptyBagOStuff;
   7 use HashBagOStuff;
   8 use MediaWiki\Storage\NameTableAccessException;
   9 use MediaWiki\Storage\NameTableStore;
  10 use MediaWikiTestCase;
  11 use Psr\Log\NullLogger;
  12 use WANObjectCache;
  13 use Wikimedia\Rdbms\Database;
  14 use Wikimedia\Rdbms\LoadBalancer;
  15 use Wikimedia\TestingAccessWrapper;
  16
  17 /**
  18  * @author Addshore
  19  * @group Database
  20  * @covers \MediaWiki\Storage\NameTableStore
  21  */
  22 class NameTableStoreTest extends MediaWikiTestCase {
  23
  24         public function setUp() {
  25                 $this->tablesUsed[] = 'slot_roles';
  26                 parent::setUp();
  27         }
  28
  29         protected function addCoreDBData() {
  30                 // The default implementation causes the slot_roles to already have content. Skip that.
  31         }
  32
  33         private function populateTable( $values ) {
  34                 $insertValues = [];
  35                 foreach ( $values as $name ) {
  36                         $insertValues[] = [ 'role_name' => $name ];
  37                 }
  38                 $this->db->insert( 'slot_roles', $insertValues );
  39         }
  40
  41         private function getHashWANObjectCache( $cacheBag ) {
  42                 return new WANObjectCache( [ 'cache' => $cacheBag ] );
  43         }
  44
  45         /**
  46          * @param $db
  47          * @return \PHPUnit_Framework_MockObject_MockObject|LoadBalancer
  48          */
  49         private function getMockLoadBalancer( $db ) {
  50                 $mock = $this->getMockBuilder( LoadBalancer::class )
  51                         ->disableOriginalConstructor()
  52                         ->getMock();
  53                 $mock->expects( $this->any() )
  54                         ->method( 'getConnection' )
  55                         ->willReturn( $db );
  56                 return $mock;
  57         }
  58
  59         private function getCallCheckingDb( $insertCalls, $selectCalls ) {
  60                 $mock = $this->getMockBuilder( Database::class )
  61                         ->disableOriginalConstructor()
  62                         ->getMock();
  63                 $mock->expects( $this->exactly( $insertCalls ) )
  64                         ->method( 'insert' )
  65                         ->willReturnCallback( function () {
  66                                 return call_user_func_array( [ $this->db, 'insert' ], func_get_args() );
  67                         } );
  68                 $mock->expects( $this->exactly( $selectCalls ) )
  69                         ->method( 'select' )
  70                         ->willReturnCallback( function () {
  71                                 return call_user_func_array( [ $this->db, 'select' ], func_get_args() );
  72                         } );
  73                 $mock->expects( $this->exactly( $insertCalls ) )
  74                         ->method( 'affectedRows' )
  75                         ->willReturnCallback( function () {
  76                                 return call_user_func_array( [ $this->db, 'affectedRows' ], func_get_args() );
  77                         } );
  78                 $mock->expects( $this->any() )
  79                         ->method( 'insertId' )
  80                         ->willReturnCallback( function () {
  81                                 return call_user_func_array( [ $this->db, 'insertId' ], func_get_args() );
  82                         } );
  83                 return $mock;
  84         }
  85
  86         private function getNameTableSqlStore(
  87                 BagOStuff $cacheBag,
  88                 $insertCalls,
  89                 $selectCalls,
  90                 $normalizationCallback = null,
  91                 $insertCallback = null
  92         ) {
  93                 return new NameTableStore(
  94                         $this->getMockLoadBalancer( $this->getCallCheckingDb( $insertCalls, $selectCalls ) ),
  95                         $this->getHashWANObjectCache( $cacheBag ),
  96                         new NullLogger(),
  97                         'slot_roles', 'role_id', 'role_name',
  98                         $normalizationCallback,
  99                         false,
 100                         $insertCallback
 101                 );
 102         }
 103
 104         public function provideGetAndAcquireId() {
 105                 return [
 106                         'no wancache, empty table' =>
 107                                 [ new EmptyBagOStuff(), true, 1, [], 'foo', 1 ],
 108                         'no wancache, one matching value' =>
 109                                 [ new EmptyBagOStuff(), false, 1, [ 'foo' ], 'foo', 1 ],
 110                         'no wancache, one not matching value' =>
 111                                 [ new EmptyBagOStuff(), true, 1, [ 'bar' ], 'foo', 2 ],
 112                         'no wancache, multiple, one matching value' =>
 113                                 [ new EmptyBagOStuff(), false, 1, [ 'foo', 'bar' ], 'bar', 2 ],
 114                         'no wancache, multiple, no matching value' =>
 115                                 [ new EmptyBagOStuff(), true, 1, [ 'foo', 'bar' ], 'baz', 3 ],
 116                         'wancache, empty table' =>
 117                                 [ new HashBagOStuff(), true, 1, [], 'foo', 1 ],
 118                         'wancache, one matching value' =>
 119                                 [ new HashBagOStuff(), false, 1, [ 'foo' ], 'foo', 1 ],
 120                         'wancache, one not matching value' =>
 121                                 [ new HashBagOStuff(), true, 1, [ 'bar' ], 'foo', 2 ],
 122                         'wancache, multiple, one matching value' =>
 123                                 [ new HashBagOStuff(), false, 1, [ 'foo', 'bar' ], 'bar', 2 ],
 124                         'wancache, multiple, no matching value' =>
 125                                 [ new HashBagOStuff(), true, 1, [ 'foo', 'bar' ], 'baz', 3 ],
 126                 ];
 127         }
 128
 129         /**
 130          * @dataProvider provideGetAndAcquireId
 131          * @param BagOStuff $cacheBag to use in the WANObjectCache service
 132          * @param bool $needsInsert Does the value we are testing need to be inserted?
 133          * @param int $selectCalls Number of times the select DB method will be called
 134          * @param string[] $existingValues to be added to the db table
 135          * @param string $name name to acquire
 136          * @param int $expectedId the id we expect the name to have
 137          */
 138         public function testGetAndAcquireId(
 139                 $cacheBag,
 140                 $needsInsert,
 141                 $selectCalls,
 142                 $existingValues,
 143                 $name,
 144                 $expectedId
 145         ) {
 146                 // Make sure the table is empty!
 147                 $this->truncateTable( 'slot_roles' );
 148
 149                 $this->populateTable( $existingValues );
 150                 $store = $this->getNameTableSqlStore( $cacheBag, (int)$needsInsert, $selectCalls );
 151
 152                 // Some names will not initially exist
 153                 try {
 154                         $result = $store->getId( $name );
 155                         $this->assertSame( $expectedId, $result );
 156                 } catch ( NameTableAccessException $e ) {
 157                         if ( $needsInsert ) {
 158                                 $this->assertTrue( true ); // Expected exception
 159                         } else {
 160                                 $this->fail( 'Did not expect an exception, but got one: ' . $e->getMessage() );
 161                         }
 162                 }
 163
 164                 // All names should return their id here
 165                 $this->assertSame( $expectedId, $store->acquireId( $name ) );
 166
 167                 // acquireId inserted these names, so now everything should exist with getId
 168                 $this->assertSame( $expectedId, $store->getId( $name ) );
 169
 170                 // calling getId again will also still work, and not result in more selects
 171                 $this->assertSame( $expectedId, $store->getId( $name ) );
 172         }
 173
 174         public function provideTestGetAndAcquireIdNameNormalization() {
 175                 yield [ 'A', 'a', 'strtolower' ];
 176                 yield [ 'b', 'B', 'strtoupper' ];
 177                 yield [
 178                         'X',
 179                         'X',
 180                         function ( $name ) {
 181                                 return $name;
 182                         }
 183                 ];
 184                 yield [ 'ZZ', 'ZZ-a', __CLASS__ . '::appendDashAToString' ];
 185         }
 186
 187         public static function appendDashAToString( $string ) {
 188                 return $string . '-a';
 189         }
 190
 191         /**
 192          * @dataProvider provideTestGetAndAcquireIdNameNormalization
 193          */
 194         public function testGetAndAcquireIdNameNormalization(
 195                 $nameIn,
 196                 $nameOut,
 197                 $normalizationCallback
 198         ) {
 199                 $store = $this->getNameTableSqlStore(
 200                         new EmptyBagOStuff(),
 201                         1,
 202                         1,
 203                         $normalizationCallback
 204                 );
 205                 $acquiredId = $store->acquireId( $nameIn );
 206                 $this->assertSame( $nameOut, $store->getName( $acquiredId ) );
 207         }
 208
 209         public function provideGetName() {
 210                 return [
 211                         [ new HashBagOStuff(), 3, 3 ],
 212                         [ new EmptyBagOStuff(), 3, 3 ],
 213                 ];
 214         }
 215
 216         /**
 217          * @dataProvider provideGetName
 218          */
 219         public function testGetName( $cacheBag, $insertCalls, $selectCalls ) {
 220                 $store = $this->getNameTableSqlStore( $cacheBag, $insertCalls, $selectCalls );
 221
 222                 // Get 1 ID and make sure getName returns correctly
 223                 $fooId = $store->acquireId( 'foo' );
 224                 $this->assertSame( 'foo', $store->getName( $fooId ) );
 225
 226                 // Get another ID and make sure getName returns correctly
 227                 $barId = $store->acquireId( 'bar' );
 228                 $this->assertSame( 'bar', $store->getName( $barId ) );
 229
 230                 // Blitz the cache and make sure it still returns
 231                 TestingAccessWrapper::newFromObject( $store )->tableCache = null;
 232                 $this->assertSame( 'foo', $store->getName( $fooId ) );
 233                 $this->assertSame( 'bar', $store->getName( $barId ) );
 234
 235                 // Blitz the cache again and get another ID and make sure getName returns correctly
 236                 TestingAccessWrapper::newFromObject( $store )->tableCache = null;
 237                 $bazId = $store->acquireId( 'baz' );
 238                 $this->assertSame( 'baz', $store->getName( $bazId ) );
 239                 $this->assertSame( 'baz', $store->getName( $bazId ) );
 240         }
 241
 242         public function testGetName_masterFallback() {
 243                 $store = $this->getNameTableSqlStore( new EmptyBagOStuff(), 1, 2 );
 244
 245                 // Insert a new name
 246                 $fooId = $store->acquireId( 'foo' );
 247
 248                 // Empty the process cache, getCachedTable() will now return this empty array
 249                 TestingAccessWrapper::newFromObject( $store )->tableCache = [];
 250
 251                 // getName should fallback to master, which is why we assert 2 selectCalls above
 252                 $this->assertSame( 'foo', $store->getName( $fooId ) );
 253         }
 254
 255         public function testGetMap_empty() {
 256                 $this->populateTable( [] );
 257                 $store = $this->getNameTableSqlStore( new HashBagOStuff(), 0, 1 );
 258                 $table = $store->getMap();
 259                 $this->assertSame( [], $table );
 260         }
 261
 262         public function testGetMap_twoValues() {
 263                 $this->populateTable( [ 'foo', 'bar' ] );
 264                 $store = $this->getNameTableSqlStore( new HashBagOStuff(), 0, 1 );
 265
 266                 // We are using a cache, so 2 calls should only result in 1 select on the db
 267                 $store->getMap();
 268                 $table = $store->getMap();
 269
 270                 $expected = [ 1 => 'foo', 2 => 'bar' ];
 271                 $this->assertSame( $expected, $table );
 272                 // Make sure the table returned is the same as the cached table
 273                 $this->assertSame( $expected, TestingAccessWrapper::newFromObject( $store )->tableCache );
 274         }
 275
 276         public function testReloadMap() {
 277                 $this->populateTable( [ 'foo' ] );
 278                 $store = $this->getNameTableSqlStore( new HashBagOStuff(), 0, 2 );
 279
 280                 // force load
 281                 $this->assertCount( 1, $store->getMap() );
 282
 283                 // add more stuff to the table, so the cache gets out of sync
 284                 $this->populateTable( [ 'bar' ] );
 285
 286                 $expected = [ 1 => 'foo', 2 => 'bar' ];
 287                 $this->assertSame( $expected, $store->reloadMap() );
 288                 $this->assertSame( $expected, $store->getMap() );
 289         }
 290
 291         public function testCacheRaceCondition() {
 292                 $wanHashBag = new HashBagOStuff();
 293                 $store1 = $this->getNameTableSqlStore( $wanHashBag, 1, 1 );
 294                 $store2 = $this->getNameTableSqlStore( $wanHashBag, 1, 0 );
 295                 $store3 = $this->getNameTableSqlStore( $wanHashBag, 1, 1 );
 296
 297                 // Cache the current table in the instances we will use
 298                 // This simulates multiple requests running simultaneously
 299                 $store1->getMap();
 300                 $store2->getMap();
 301                 $store3->getMap();
 302
 303                 // Store 2 separate names using different instances
 304                 $fooId = $store1->acquireId( 'foo' );
 305                 $barId = $store2->acquireId( 'bar' );
 306
 307                 // Each of these instances should be aware of what they have inserted
 308                 $this->assertSame( $fooId, $store1->acquireId( 'foo' ) );
 309                 $this->assertSame( $barId, $store2->acquireId( 'bar' ) );
 310
 311                 // A new store should be able to get both of these new Ids
 312                 // Note: before there was a race condition here where acquireId( 'bar' ) would update the
 313                 //       cache with data missing the 'foo' key that it was not aware of
 314                 $store4 = $this->getNameTableSqlStore( $wanHashBag, 0, 1 );
 315                 $this->assertSame( $fooId, $store4->getId( 'foo' ) );
 316                 $this->assertSame( $barId, $store4->getId( 'bar' ) );
 317
 318                 // If a store with old cached data tries to acquire these we will get the same ids.
 319                 $this->assertSame( $fooId, $store3->acquireId( 'foo' ) );
 320                 $this->assertSame( $barId, $store3->acquireId( 'bar' ) );
 321         }
 322
 323         public function testGetAndAcquireIdInsertCallback() {
 324                 // FIXME: fails under postgres
 325                 $this->markTestSkippedIfDbType( 'postgres' );
 326
 327                 $store = $this->getNameTableSqlStore(
 328                         new EmptyBagOStuff(),
 329                         1,
 330                         1,
 331                         null,
 332                         function ( $insertFields ) {
 333                                 $insertFields['role_id'] = 7251;
 334                                 return $insertFields;
 335                         }
 336                 );
 337                 $this->assertSame( 7251, $store->acquireId( 'A' ) );
 338         }
 339
 340 }