ProcessCacheLRUTest.php

Go to the documentation of this file.

<?php
 
class ProcessCacheLRUTest extends PHPUnit\Framework\TestCase {
 
    use MediaWikiCoversValidator;
 
    protected function assertCacheEmpty( $cache, $msg = 'Cache should be empty' ) {
        $this->assertAttributeEquals( [], 'cache', $cache, $msg );
    }
 
    protected function fillCache( &$cache, $numEntries ) {
        // Fill cache with three values
        for ( $i = 1; $i <= $numEntries; $i++ ) {
            $cache->set( "cache-key-$i", "prop-$i", "value-$i" );
        }
    }
 
    protected function getExpectedCache( $cacheMaxEntries, $entryToFill ) {
        $expected = [];
 
        if ( $entryToFill === 0 ) {
            // The cache is empty!
            return [];
        } elseif ( $entryToFill <= $cacheMaxEntries ) {
            // Cache is not fully filled
            $firstKey = 1;
        } else {
            // Cache overflowed
            $firstKey = 1 + $entryToFill - $cacheMaxEntries;
        }
 
        $lastKey = $entryToFill;
 
        for ( $i = $firstKey; $i <= $lastKey; $i++ ) {
            $expected["cache-key-$i"] = [ "prop-$i" => "value-$i" ];
        }
 
        return $expected;
    }
 
    public function testPhpUnitArrayEquality() {
        $one = [ 'A' => 1, 'B' => 2 ];
        $two = [ 'B' => 2, 'A' => 1 ];
        // ==
        $this->assertEquals( $one, $two );
        // ===
        $this->assertNotSame( $one, $two );
    }
 
    public function testConstructorGivenInvalidValue( $maxSize ) {
        new ProcessCacheLRUTestable( $maxSize );
    }
 
    public static function provideInvalidConstructorArg() {
        return [
            [ null ],
            [ [] ],
            [ new stdClass() ],
            [ 0 ],
            [ '5' ],
            [ -1 ],
        ];
    }
 
    public function testAddAndGetAKey() {
        $oneCache = new ProcessCacheLRUTestable( 1 );
        $this->assertCacheEmpty( $oneCache );
 
        // First set just one value
        $oneCache->set( 'cache-key', 'prop1', 'value1' );
        $this->assertEquals( 1, $oneCache->getEntriesCount() );
        $this->assertTrue( $oneCache->has( 'cache-key', 'prop1' ) );
        $this->assertEquals( 'value1', $oneCache->get( 'cache-key', 'prop1' ) );
    }
 
    public function testDeleteOldKey() {
        $oneCache = new ProcessCacheLRUTestable( 1 );
        $this->assertCacheEmpty( $oneCache );
 
        $oneCache->set( 'cache-key', 'prop1', 'value1' );
        $oneCache->set( 'cache-key', 'prop1', 'value2' );
        $this->assertEquals( 'value2', $oneCache->get( 'cache-key', 'prop1' ) );
    }
 
    public function testFillingCache( $cacheMaxEntries, $entryToFill, $msg = '' ) {
        $cache = new ProcessCacheLRUTestable( $cacheMaxEntries );
        $this->fillCache( $cache, $entryToFill );
 
        $this->assertSame(
            $this->getExpectedCache( $cacheMaxEntries, $entryToFill ),
            $cache->getCache(),
            "Filling a $cacheMaxEntries entries cache with $entryToFill entries"
        );
    }
 
    public static function provideCacheFilling() {
        // ($cacheMaxEntries, $entryToFill, $msg='')
        return [
            [ 1, 0 ],
            [ 1, 1 ],
            // overflow
            [ 1, 2 ],
            // overflow
            [ 5, 33 ],
        ];
    }
 
    public function testReplaceExistingKeyShouldBumpEntryToTop() {
        $maxEntries = 3;
 
        $cache = new ProcessCacheLRUTestable( $maxEntries );
        // Fill cache leaving just one remaining slot
        $this->fillCache( $cache, $maxEntries - 1 );
 
        // Set an existing cache key
        $cache->set( "cache-key-1", "prop-1", "new-value-for-1" );
 
        $this->assertSame(
            [
                'cache-key-2' => [ 'prop-2' => 'value-2' ],
                'cache-key-1' => [ 'prop-1' => 'new-value-for-1' ],
            ],
            $cache->getCache()
        );
    }
 
    public function testRecentlyAccessedKeyStickIn() {
        $cache = new ProcessCacheLRUTestable( 2 );
        $cache->set( 'first', 'prop1', 'value1' );
        $cache->set( 'second', 'prop2', 'value2' );
 
        // Get first
        $cache->get( 'first', 'prop1' );
        // Cache a third value, should invalidate the least used one
        $cache->set( 'third', 'prop3', 'value3' );
 
        $this->assertFalse( $cache->has( 'second', 'prop2' ) );
    }
 
    public function testReplaceExistingKeyInAFullCacheShouldBumpToTop() {
        $maxEntries = 3;
 
        $cache = new ProcessCacheLRUTestable( $maxEntries );
        $this->fillCache( $cache, $maxEntries );
 
        // Set an existing cache key
        $cache->set( "cache-key-2", "prop-2", "new-value-for-2" );
        $this->assertSame(
            [
                'cache-key-1' => [ 'prop-1' => 'value-1' ],
                'cache-key-3' => [ 'prop-3' => 'value-3' ],
                'cache-key-2' => [ 'prop-2' => 'new-value-for-2' ],
            ],
            $cache->getCache()
        );
        $this->assertEquals( 'new-value-for-2',
            $cache->get( 'cache-key-2', 'prop-2' )
        );
    }
 
    public function testBumpExistingKeyToTop() {
        $cache = new ProcessCacheLRUTestable( 3 );
        $this->fillCache( $cache, 3 );
 
        // Set the very first cache key to a new value
        $cache->set( "cache-key-1", "prop-1", "new value for 1" );
        $this->assertEquals(
            [
                'cache-key-2' => [ 'prop-2' => 'value-2' ],
                'cache-key-3' => [ 'prop-3' => 'value-3' ],
                'cache-key-1' => [ 'prop-1' => 'new value for 1' ],
            ],
            $cache->getCache()
        );
    }
}
 
class ProcessCacheLRUTestable extends ProcessCacheLRU {
    public $cache = [];
 
    public function getCache() {
        return $this->cache;
    }
 
    public function getEntriesCount() {
        return count( $this->cache );
    }
}