tests/phpunit/includes/libs/objectcache/BagOStuffTest.php

   1 <?php
   2
   3 use Wikimedia\ScopedCallback;
   4
   5 /**
   6  * @author Matthias Mullie <mmullie@wikimedia.org>
   7  * @group BagOStuff
   8  */
   9 class BagOStuffTest extends MediaWikiTestCase {
  10         /** @var BagOStuff */
  11         private $cache;
  12
  13         const TEST_KEY = 'test';
  14
  15         protected function setUp() {
  16                 parent::setUp();
  17
  18                 // type defined through parameter
  19                 if ( $this->getCliArg( 'use-bagostuff' ) !== null ) {
  20                         $name = $this->getCliArg( 'use-bagostuff' );
  21
  22                         $this->cache = ObjectCache::newFromId( $name );
  23                 } else {
  24                         // no type defined - use simple hash
  25                         $this->cache = new HashBagOStuff;
  26                 }
  27
  28                 $this->cache->delete( $this->cache->makeKey( self::TEST_KEY ) );
  29                 $this->cache->delete( $this->cache->makeKey( self::TEST_KEY ) . ':lock' );
  30         }
  31
  32         /**
  33          * @covers BagOStuff::makeGlobalKey
  34          * @covers BagOStuff::makeKeyInternal
  35          */
  36         public function testMakeKey() {
  37                 $cache = ObjectCache::newFromId( 'hash' );
  38
  39                 $localKey = $cache->makeKey( 'first', 'second', 'third' );
  40                 $globalKey = $cache->makeGlobalKey( 'first', 'second', 'third' );
  41
  42                 $this->assertStringMatchesFormat(
  43                         '%Sfirst%Ssecond%Sthird%S',
  44                         $localKey,
  45                         'Local key interpolates parameters'
  46                 );
  47
  48                 $this->assertStringMatchesFormat(
  49                         'global%Sfirst%Ssecond%Sthird%S',
  50                         $globalKey,
  51                         'Global key interpolates parameters and contains global prefix'
  52                 );
  53
  54                 $this->assertNotEquals(
  55                         $localKey,
  56                         $globalKey,
  57                         'Local key and global key with same parameters should not be equal'
  58                 );
  59
  60                 $this->assertNotEquals(
  61                         $cache->makeKeyInternal( 'prefix', [ 'a', 'bc:', 'de' ] ),
  62                         $cache->makeKeyInternal( 'prefix', [ 'a', 'bc', ':de' ] )
  63                 );
  64         }
  65
  66         /**
  67          * @covers BagOStuff::merge
  68          * @covers BagOStuff::mergeViaCas
  69          */
  70         public function testMerge() {
  71                 $key = $this->cache->makeKey( self::TEST_KEY );
  72
  73                 $calls = 0;
  74                 $casRace = false; // emulate a race
  75                 $callback = function ( BagOStuff $cache, $key, $oldVal ) use ( &$calls, &$casRace ) {
  76                         ++$calls;
  77                         if ( $casRace ) {
  78                                 // Uses CAS instead?
  79                                 $cache->set( $key, 'conflict', 5 );
  80                         }
  81
  82                         return ( $oldVal === false ) ? 'merged' : $oldVal . 'merged';
  83                 };
  84
  85                 // merge on non-existing value
  86                 $merged = $this->cache->merge( $key, $callback, 5 );
  87                 $this->assertTrue( $merged );
  88                 $this->assertEquals( 'merged', $this->cache->get( $key ) );
  89
  90                 // merge on existing value
  91                 $merged = $this->cache->merge( $key, $callback, 5 );
  92                 $this->assertTrue( $merged );
  93                 $this->assertEquals( 'mergedmerged', $this->cache->get( $key ) );
  94
  95                 $calls = 0;
  96                 $casRace = true;
  97                 $this->assertFalse(
  98                         $this->cache->merge( $key, $callback, 5, 1 ),
  99                         'Non-blocking merge (CAS)'
 100                 );
 101                 if ( $this->cache instanceof MultiWriteBagOStuff ) {
 102                         $wrapper = \Wikimedia\TestingAccessWrapper::newFromObject( $this->cache );
 103                         $n = count( $wrapper->caches );
 104                 } else {
 105                         $n = 1;
 106                 }
 107                 $this->assertEquals( $n, $calls );
 108         }
 109
 110         /**
 111          * @covers BagOStuff::changeTTL
 112          */
 113         public function testChangeTTL() {
 114                 $key = $this->cache->makeKey( self::TEST_KEY );
 115                 $value = 'meow';
 116
 117                 $this->cache->add( $key, $value, 5 );
 118                 $this->assertTrue( $this->cache->changeTTL( $key, 5 ) );
 119                 $this->assertEquals( $this->cache->get( $key ), $value );
 120                 $this->cache->delete( $key );
 121                 $this->assertFalse( $this->cache->changeTTL( $key, 5 ) );
 122         }
 123
 124         /**
 125          * @covers BagOStuff::add
 126          */
 127         public function testAdd() {
 128                 $key = $this->cache->makeKey( self::TEST_KEY );
 129                 $this->assertTrue( $this->cache->add( $key, 'test', 5 ) );
 130         }
 131
 132         /**
 133          * @covers BagOStuff::get
 134          */
 135         public function testGet() {
 136                 $value = [ 'this' => 'is', 'a' => 'test' ];
 137
 138                 $key = $this->cache->makeKey( self::TEST_KEY );
 139                 $this->cache->add( $key, $value, 5 );
 140                 $this->assertEquals( $this->cache->get( $key ), $value );
 141         }
 142
 143         /**
 144          * @covers BagOStuff::get
 145          * @covers BagOStuff::set
 146          * @covers BagOStuff::getWithSetCallback
 147          */
 148         public function testGetWithSetCallback() {
 149                 $key = $this->cache->makeKey( self::TEST_KEY );
 150                 $value = $this->cache->getWithSetCallback(
 151                         $key,
 152                         30,
 153                         function () {
 154                                 return 'hello kitty';
 155                         }
 156                 );
 157
 158                 $this->assertEquals( 'hello kitty', $value );
 159                 $this->assertEquals( $value, $this->cache->get( $key ) );
 160         }
 161
 162         /**
 163          * @covers BagOStuff::incr
 164          */
 165         public function testIncr() {
 166                 $key = $this->cache->makeKey( self::TEST_KEY );
 167                 $this->cache->add( $key, 0, 5 );
 168                 $this->cache->incr( $key );
 169                 $expectedValue = 1;
 170                 $actualValue = $this->cache->get( $key );
 171                 $this->assertEquals( $expectedValue, $actualValue, 'Value should be 1 after incrementing' );
 172         }
 173
 174         /**
 175          * @covers BagOStuff::incrWithInit
 176          */
 177         public function testIncrWithInit() {
 178                 $key = $this->cache->makeKey( self::TEST_KEY );
 179                 $val = $this->cache->incrWithInit( $key, 0, 1, 3 );
 180                 $this->assertEquals( 3, $val, "Correct init value" );
 181
 182                 $val = $this->cache->incrWithInit( $key, 0, 1, 3 );
 183                 $this->assertEquals( 4, $val, "Correct init value" );
 184         }
 185
 186         /**
 187          * @covers BagOStuff::getMulti
 188          */
 189         public function testGetMulti() {
 190                 $value1 = [ 'this' => 'is', 'a' => 'test' ];
 191                 $value2 = [ 'this' => 'is', 'another' => 'test' ];
 192                 $value3 = [ 'testing a key that may be encoded when sent to cache backend' ];
 193                 $value4 = [ 'another test where chars in key will be encoded' ];
 194
 195                 $key1 = $this->cache->makeKey( 'test-1' );
 196                 $key2 = $this->cache->makeKey( 'test-2' );
 197                 // internally, MemcachedBagOStuffs will encode to will-%25-encode
 198                 $key3 = $this->cache->makeKey( 'will-%-encode' );
 199                 $key4 = $this->cache->makeKey(
 200                         'flowdb:flow_ref:wiki:by-source:v3:Parser\'s_"broken"_+_(page)_&_grill:testwiki:1:4.7'
 201                 );
 202
 203                 // cleanup
 204                 $this->cache->delete( $key1 );
 205                 $this->cache->delete( $key2 );
 206                 $this->cache->delete( $key3 );
 207                 $this->cache->delete( $key4 );
 208
 209                 $this->cache->add( $key1, $value1, 5 );
 210                 $this->cache->add( $key2, $value2, 5 );
 211                 $this->cache->add( $key3, $value3, 5 );
 212                 $this->cache->add( $key4, $value4, 5 );
 213
 214                 $this->assertEquals(
 215                         [ $key1 => $value1, $key2 => $value2, $key3 => $value3, $key4 => $value4 ],
 216                         $this->cache->getMulti( [ $key1, $key2, $key3, $key4 ] )
 217                 );
 218
 219                 // cleanup
 220                 $this->cache->delete( $key1 );
 221                 $this->cache->delete( $key2 );
 222                 $this->cache->delete( $key3 );
 223                 $this->cache->delete( $key4 );
 224         }
 225
 226         /**
 227          * @covers BagOStuff::setMulti
 228          * @covers BagOStuff::deleteMulti
 229          */
 230         public function testSetDeleteMulti() {
 231                 $map = [
 232                         $this->cache->makeKey( 'test-1' ) => 'Siberian',
 233                         $this->cache->makeKey( 'test-2' ) => [ 'Huskies' ],
 234                         $this->cache->makeKey( 'test-3' ) => [ 'are' => 'the' ],
 235                         $this->cache->makeKey( 'test-4' ) => (object)[ 'greatest' => 'animal' ],
 236                         $this->cache->makeKey( 'test-5' ) => 4,
 237                         $this->cache->makeKey( 'test-6' ) => 'ever'
 238                 ];
 239
 240                 $this->cache->setMulti( $map, 5 );
 241                 $this->assertEquals(
 242                         $map,
 243                         $this->cache->getMulti( array_keys( $map ) )
 244                 );
 245
 246                 $this->assertTrue( $this->cache->deleteMulti( array_keys( $map ), 5 ) );
 247
 248                 $this->assertEquals(
 249                         [],
 250                         $this->cache->getMulti( array_keys( $map ) )
 251                 );
 252         }
 253
 254         /**
 255          * @covers BagOStuff::getScopedLock
 256          */
 257         public function testGetScopedLock() {
 258                 $key = $this->cache->makeKey( self::TEST_KEY );
 259                 $value1 = $this->cache->getScopedLock( $key, 0 );
 260                 $value2 = $this->cache->getScopedLock( $key, 0 );
 261
 262                 $this->assertType( ScopedCallback::class, $value1, 'First call returned lock' );
 263                 $this->assertNull( $value2, 'Duplicate call returned no lock' );
 264
 265                 unset( $value1 );
 266
 267                 $value3 = $this->cache->getScopedLock( $key, 0 );
 268                 $this->assertType( ScopedCallback::class, $value3, 'Lock returned callback after release' );
 269                 unset( $value3 );
 270
 271                 $value1 = $this->cache->getScopedLock( $key, 0, 5, 'reentry' );
 272                 $value2 = $this->cache->getScopedLock( $key, 0, 5, 'reentry' );
 273
 274                 $this->assertType( ScopedCallback::class, $value1, 'First reentrant call returned lock' );
 275                 $this->assertType( ScopedCallback::class, $value1, 'Second reentrant call returned lock' );
 276         }
 277
 278         /**
 279          * @covers BagOStuff::__construct
 280          * @covers BagOStuff::trackDuplicateKeys
 281          */
 282         public function testReportDupes() {
 283                 $logger = $this->createMock( Psr\Log\NullLogger::class );
 284                 $logger->expects( $this->once() )
 285                         ->method( 'warning' )
 286                         ->with( 'Duplicate get(): "{key}" fetched {count} times', [
 287                                 'key' => 'foo',
 288                                 'count' => 2,
 289                         ] );
 290
 291                 $cache = new HashBagOStuff( [
 292                         'reportDupes' => true,
 293                         'asyncHandler' => 'DeferredUpdates::addCallableUpdate',
 294                         'logger' => $logger,
 295                 ] );
 296                 $cache->get( 'foo' );
 297                 $cache->get( 'bar' );
 298                 $cache->get( 'foo' );
 299
 300                 DeferredUpdates::doUpdates();
 301         }
 302
 303         /**
 304          * @covers BagOStuff::lock()
 305          * @covers BagOStuff::unlock()
 306          */
 307         public function testLocking() {
 308                 $key = 'test';
 309                 $this->assertTrue( $this->cache->lock( $key ) );
 310                 $this->assertFalse( $this->cache->lock( $key ) );
 311                 $this->assertTrue( $this->cache->unlock( $key ) );
 312
 313                 $key2 = 'test2';
 314                 $this->assertTrue( $this->cache->lock( $key2, 5, 5, 'rclass' ) );
 315                 $this->assertTrue( $this->cache->lock( $key2, 5, 5, 'rclass' ) );
 316                 $this->assertTrue( $this->cache->unlock( $key2 ) );
 317                 $this->assertTrue( $this->cache->unlock( $key2 ) );
 318         }
 319 }