tests/phpunit/includes/libs/ProcessCacheLRUTest.php

   1 <?php
   2
   3 /**
   4  * Test for ProcessCacheLRU class.
   5  *
   6  * Note that it uses the ProcessCacheLRUTestable class which extends some
   7  * properties and methods visibility. That class is defined at the end of the
   8  * file containing this class.
   9  *
  10  * @group Cache
  11  */
  12 class ProcessCacheLRUTest extends MediaWikiTestCase {
  13
  14         /**
  15          * Helper to verify emptiness of a cache object.
  16          * Compare against an array so we get the cache content difference.
  17          */
  18         function assertCacheEmpty( $cache, $msg = 'Cache should be empty' ) {
  19                 $this->assertAttributeEquals( array(), 'cache', $cache, $msg );
  20         }
  21
  22         /**
  23          * Helper to fill a cache object passed by reference
  24          */
  25         function fillCache( &$cache, $numEntries ) {
  26                 // Fill cache with three values
  27                 for ( $i = 1; $i <= $numEntries; $i++ ) {
  28                         $cache->set( "cache-key-$i", "prop-$i", "value-$i" );
  29                 }
  30         }
  31
  32         /**
  33          * Generates an array of what would be expected in cache for a given cache
  34          * size and a number of entries filled in sequentially
  35          */
  36         function getExpectedCache( $cacheMaxEntries, $entryToFill ) {
  37                 $expected = array();
  38
  39                 if ( $entryToFill === 0 ) {
  40                         # The cache is empty!
  41                         return array();
  42                 } elseif ( $entryToFill <= $cacheMaxEntries ) {
  43                         # Cache is not fully filled
  44                         $firstKey = 1;
  45                 } else {
  46                         # Cache overflowed
  47                         $firstKey = 1 + $entryToFill - $cacheMaxEntries;
  48                 }
  49
  50                 $lastKey = $entryToFill;
  51
  52                 for ( $i = $firstKey; $i <= $lastKey; $i++ ) {
  53                         $expected["cache-key-$i"] = array( "prop-$i" => "value-$i" );
  54                 }
  55
  56                 return $expected;
  57         }
  58
  59         /**
  60          * Highlight diff between assertEquals and assertNotSame
  61          */
  62         public function testPhpUnitArrayEquality() {
  63                 $one = array( 'A' => 1, 'B' => 2 );
  64                 $two = array( 'B' => 2, 'A' => 1 );
  65                 $this->assertEquals( $one, $two ); // ==
  66                 $this->assertNotSame( $one, $two ); // ===
  67         }
  68
  69         /**
  70          * @dataProvider provideInvalidConstructorArg
  71          * @expectedException UnexpectedValueException
  72          */
  73         public function testConstructorGivenInvalidValue( $maxSize ) {
  74                 new ProcessCacheLRUTestable( $maxSize );
  75         }
  76
  77         /**
  78          * Value which are forbidden by the constructor
  79          */
  80         public static function provideInvalidConstructorArg() {
  81                 return array(
  82                         array( null ),
  83                         array( array() ),
  84                         array( new stdClass() ),
  85                         array( 0 ),
  86                         array( '5' ),
  87                         array( -1 ),
  88                 );
  89         }
  90
  91         public function testAddAndGetAKey() {
  92                 $oneCache = new ProcessCacheLRUTestable( 1 );
  93                 $this->assertCacheEmpty( $oneCache );
  94
  95                 // First set just one value
  96                 $oneCache->set( 'cache-key', 'prop1', 'value1' );
  97                 $this->assertEquals( 1, $oneCache->getEntriesCount() );
  98                 $this->assertTrue( $oneCache->has( 'cache-key', 'prop1' ) );
  99                 $this->assertEquals( 'value1', $oneCache->get( 'cache-key', 'prop1' ) );
 100         }
 101
 102         public function testDeleteOldKey() {
 103                 $oneCache = new ProcessCacheLRUTestable( 1 );
 104                 $this->assertCacheEmpty( $oneCache );
 105
 106                 $oneCache->set( 'cache-key', 'prop1', 'value1' );
 107                 $oneCache->set( 'cache-key', 'prop1', 'value2' );
 108                 $this->assertEquals( 'value2', $oneCache->get( 'cache-key', 'prop1' ) );
 109         }
 110
 111         /**
 112          * This test that we properly overflow when filling a cache with
 113          * a sequence of always different cache-keys. Meant to verify we correclty
 114          * delete the older key.
 115          *
 116          * @dataProvider provideCacheFilling
 117          * @param int $cacheMaxEntries Maximum entry the created cache will hold
 118          * @param int $entryToFill Number of entries to insert in the created cache.
 119          */
 120         public function testFillingCache( $cacheMaxEntries, $entryToFill, $msg = '' ) {
 121                 $cache = new ProcessCacheLRUTestable( $cacheMaxEntries );
 122                 $this->fillCache( $cache, $entryToFill );
 123
 124                 $this->assertSame(
 125                         $this->getExpectedCache( $cacheMaxEntries, $entryToFill ),
 126                         $cache->getCache(),
 127                         "Filling a $cacheMaxEntries entries cache with $entryToFill entries"
 128                 );
 129         }
 130
 131         /**
 132          * Provider for testFillingCache
 133          */
 134         public static function provideCacheFilling() {
 135                 // ($cacheMaxEntries, $entryToFill, $msg='')
 136                 return array(
 137                         array( 1, 0 ),
 138                         array( 1, 1 ),
 139                         array( 1, 2 ), # overflow
 140                         array( 5, 33 ), # overflow
 141                 );
 142         }
 143
 144         /**
 145          * Create a cache with only one remaining entry then update
 146          * the first inserted entry. Should bump it to the top.
 147          */
 148         public function testReplaceExistingKeyShouldBumpEntryToTop() {
 149                 $maxEntries = 3;
 150
 151                 $cache = new ProcessCacheLRUTestable( $maxEntries );
 152                 // Fill cache leaving just one remaining slot
 153                 $this->fillCache( $cache, $maxEntries - 1 );
 154
 155                 // Set an existing cache key
 156                 $cache->set( "cache-key-1", "prop-1", "new-value-for-1" );
 157
 158                 $this->assertSame(
 159                         array(
 160                                 'cache-key-2' => array( 'prop-2' => 'value-2' ),
 161                                 'cache-key-1' => array( 'prop-1' => 'new-value-for-1' ),
 162                         ),
 163                         $cache->getCache()
 164                 );
 165         }
 166
 167         public function testRecentlyAccessedKeyStickIn() {
 168                 $cache = new ProcessCacheLRUTestable( 2 );
 169                 $cache->set( 'first', 'prop1', 'value1' );
 170                 $cache->set( 'second', 'prop2', 'value2' );
 171
 172                 // Get first
 173                 $cache->get( 'first', 'prop1' );
 174                 // Cache a third value, should invalidate the least used one
 175                 $cache->set( 'third', 'prop3', 'value3' );
 176
 177                 $this->assertFalse( $cache->has( 'second', 'prop2' ) );
 178         }
 179
 180         /**
 181          * This first create a full cache then update the value for the 2nd
 182          * filled entry.
 183          * Given a cache having 1,2,3 as key, updating 2 should bump 2 to
 184          * the top of the queue with the new value: 1,3,2* (* = updated).
 185          */
 186         public function testReplaceExistingKeyInAFullCacheShouldBumpToTop() {
 187                 $maxEntries = 3;
 188
 189                 $cache = new ProcessCacheLRUTestable( $maxEntries );
 190                 $this->fillCache( $cache, $maxEntries );
 191
 192                 // Set an existing cache key
 193                 $cache->set( "cache-key-2", "prop-2", "new-value-for-2" );
 194                 $this->assertSame(
 195                         array(
 196                                 'cache-key-1' => array( 'prop-1' => 'value-1' ),
 197                                 'cache-key-3' => array( 'prop-3' => 'value-3' ),
 198                                 'cache-key-2' => array( 'prop-2' => 'new-value-for-2' ),
 199                         ),
 200                         $cache->getCache()
 201                 );
 202                 $this->assertEquals( 'new-value-for-2',
 203                         $cache->get( 'cache-key-2', 'prop-2' )
 204                 );
 205         }
 206
 207         public function testBumpExistingKeyToTop() {
 208                 $cache = new ProcessCacheLRUTestable( 3 );
 209                 $this->fillCache( $cache, 3 );
 210
 211                 // Set the very first cache key to a new value
 212                 $cache->set( "cache-key-1", "prop-1", "new value for 1" );
 213                 $this->assertEquals(
 214                         array(
 215                                 'cache-key-2' => array( 'prop-2' => 'value-2' ),
 216                                 'cache-key-3' => array( 'prop-3' => 'value-3' ),
 217                                 'cache-key-1' => array( 'prop-1' => 'new value for 1' ),
 218                         ),
 219                         $cache->getCache()
 220                 );
 221         }
 222 }
 223
 224 /**
 225  * Overrides some ProcessCacheLRU methods and properties accessibility.
 226  */
 227 class ProcessCacheLRUTestable extends ProcessCacheLRU {
 228         public $cache = array();
 229
 230         public function getCache() {
 231                 return $this->cache;
 232         }
 233
 234         public function getEntriesCount() {
 235                 return count( $this->cache );
 236         }
 237 }