objectcache: make getMultiWith(Union)SetCallback() usage easier

[lhc/web/wiklou.git] / tests / phpunit / includes / libs / objectcache / WANObjectCacheTest.php

diff --git a/tests/phpunit/includes/libs/objectcache/WANObjectCacheTest.php b/tests/phpunit/includes/libs/objectcache/WANObjectCacheTest.php
index 87c1d1e..6d32201 100644 (file)
--- a/tests/phpunit/includes/libs/objectcache/WANObjectCacheTest.php
+++ b/tests/phpunit/includes/libs/objectcache/WANObjectCacheTest.php
@@ -11,7 +11,7 @@ use Wikimedia\TestingAccessWrapper;
  * @covers WANObjectCache::getWarmupKeyMisses
  * @covers WANObjectCache::prefixCacheKeys
  * @covers WANObjectCache::getProcessCache
- * @covers WANObjectCache::getNonProcessCachedKeys
+ * @covers WANObjectCache::getNonProcessCachedMultiKeys
  * @covers WANObjectCache::getRawKeysForWarmup
  * @covers WANObjectCache::getInterimValue
  * @covers WANObjectCache::setInterimValue
@@ -47,18 +47,26 @@ class WANObjectCacheTest extends PHPUnit\Framework\TestCase {
         * @param int $ttl
         */
        public function testSetAndGet( $value, $ttl ) {
+               $cache = $this->cache;
+
                $curTTL = null;
                $asOf = null;
-               $key = $this->cache->makeKey( 'x', wfRandomString() );
+               $key = $cache->makeKey( 'x', wfRandomString() );
 
-               $this->cache->get( $key, $curTTL, [], $asOf );
+               $cache->get( $key, $curTTL, [], $asOf );
                $this->assertNull( $curTTL, "Current TTL is null" );
                $this->assertNull( $asOf, "Current as-of-time is infinite" );
 
                $t = microtime( true );
-               $this->cache->set( $key, $value, $ttl );
 
-               $this->assertEquals( $value, $this->cache->get( $key, $curTTL, [], $asOf ) );
+               $cache->set( $key, $value, $cache::TTL_UNCACHEABLE );
+               $cache->get( $key, $curTTL, [], $asOf );
+               $this->assertNull( $curTTL, "Current TTL is null (TTL_UNCACHEABLE)" );
+               $this->assertNull( $asOf, "Current as-of-time is infinite (TTL_UNCACHEABLE)" );
+
+               $cache->set( $key, $value, $ttl );
+
+               $this->assertEquals( $value, $cache->get( $key, $curTTL, [], $asOf ) );
                if ( is_infinite( $ttl ) || $ttl == 0 ) {
                        $this->assertTrue( is_infinite( $curTTL ), "Current TTL is infinite" );
                } else {
@@ -157,7 +165,7 @@ class WANObjectCacheTest extends PHPUnit\Framework\TestCase {
                $this->assertEquals( 6, $hit, "New values cached" );
 
                foreach ( $keys as $i => $key ) {
-                       // Should evict from process cache
+                       // Should not evict from process cache
                        $this->cache->delete( $key );
                        $mockWallClock += 0.001; // cached values will be newer than tombstone
                        // Get into cache (specific process cache group)
@@ -192,7 +200,7 @@ class WANObjectCacheTest extends PHPUnit\Framework\TestCase {
        /**
         * @dataProvider getWithSetCallback_provider
         * @covers WANObjectCache::getWithSetCallback()
-        * @covers WANObjectCache::doGetWithSetCallback()
+        * @covers WANObjectCache::fetchOrRegenerate()
         * @param array $extOpts
         * @param bool $versioned
         */
@@ -268,11 +276,7 @@ class WANObjectCacheTest extends PHPUnit\Framework\TestCase {
 
                $curTTL = null;
                $v = $cache->get( $key, $curTTL, [ $cKey1, $cKey2 ] );
-               if ( $versioned ) {
-                       $this->assertEquals( $value, $v[$cache::VFLD_DATA], "Value returned" );
-               } else {
-                       $this->assertEquals( $value, $v, "Value returned" );
-               }
+               $this->assertEquals( $value, $v, "Value returned" );
                $this->assertLessThanOrEqual( 0, $curTTL, "Value has current TTL < 0 due to check keys" );
 
                $wasSet = 0;
@@ -378,7 +382,7 @@ class WANObjectCacheTest extends PHPUnit\Framework\TestCase {
        /**
         * @dataProvider getWithSetCallback_provider
         * @covers WANObjectCache::getWithSetCallback()
-        * @covers WANObjectCache::doGetWithSetCallback()
+        * @covers WANObjectCache::fetchOrRegenerate()
         * @param array $extOpts
         * @param bool $versioned
         */
@@ -544,15 +548,6 @@ class WANObjectCacheTest extends PHPUnit\Framework\TestCase {
                $this->assertEquals( 2, $wasSet, "Value re-calculated" );
        }
 
-       /**
-        * @covers WANObjectCache::getWithSetCallback()
-        * @covers WANObjectCache::doGetWithSetCallback()
-        */
-       public function testGetWithSetCallback_invalidCallback() {
-               $this->setExpectedException( InvalidArgumentException::class );
-               $this->cache->getWithSetCallback( 'key', 30, 'invalid callback' );
-       }
-
        /**
         * @dataProvider getMultiWithSetCallback_provider
         * @covers WANObjectCache::getMultiWithSetCallback
@@ -606,15 +601,16 @@ class WANObjectCacheTest extends PHPUnit\Framework\TestCase {
                $value = "@efef$";
                $keyedIds = new ArrayIterator( [ $keyB => 'efef' ] );
                $v = $cache->getMultiWithSetCallback(
-                       $keyedIds, 30, $genFunc, [ 'lowTTL' => 0, 'lockTSE' => 5, ] + $extOpts );
+                       $keyedIds, 30, $genFunc, [ 'lowTTL' => 0, 'lockTSE' => 5 ] + $extOpts );
                $this->assertEquals( $value, $v[$keyB], "Value returned" );
                $this->assertEquals( 1, $wasSet, "Value regenerated" );
-               $this->assertEquals( 0, $cache->getWarmupKeyMisses(), "Keys warmed yet in process cache" );
+               $this->assertEquals( 0, $cache->getWarmupKeyMisses(), "Keys warmed in warmup cache" );
+
                $v = $cache->getMultiWithSetCallback(
-                       $keyedIds, 30, $genFunc, [ 'lowTTL' => 0, 'lockTSE' => 5, ] + $extOpts );
+                       $keyedIds, 30, $genFunc, [ 'lowTTL' => 0, 'lockTSE' => 5 ] + $extOpts );
                $this->assertEquals( $value, $v[$keyB], "Value returned" );
                $this->assertEquals( 1, $wasSet, "Value not regenerated" );
-               $this->assertEquals( 0, $cache->getWarmupKeyMisses(), "Keys warmed in process cache" );
+               $this->assertEquals( 0, $cache->getWarmupKeyMisses(), "Keys warmed in warmup cache" );
 
                $mockWallClock += 1;
 
@@ -649,11 +645,7 @@ class WANObjectCacheTest extends PHPUnit\Framework\TestCase {
 
                $curTTL = null;
                $v = $cache->get( $keyC, $curTTL, [ $cKey1, $cKey2 ] );
-               if ( $versioned ) {
-                       $this->assertEquals( $value, $v[$cache::VFLD_DATA], "Value returned" );
-               } else {
-                       $this->assertEquals( $value, $v, "Value returned" );
-               }
+               $this->assertEquals( $value, $v, "Value returned" );
                $this->assertLessThanOrEqual( 0, $curTTL, "Value has current TTL < 0 due to check keys" );
 
                $wasSet = 0;
@@ -780,12 +772,13 @@ class WANObjectCacheTest extends PHPUnit\Framework\TestCase {
                        $keyedIds, 30, $genFunc, [ 'lowTTL' => 0 ] + $extOpts );
                $this->assertEquals( $value, $v[$keyB], "Value returned" );
                $this->assertEquals( 1, $wasSet, "Value regenerated" );
-               $this->assertEquals( 0, $cache->getWarmupKeyMisses(), "Keys warmed yet in process cache" );
+               $this->assertEquals( 0, $cache->getWarmupKeyMisses(), "Keys warmed in warmup cache" );
+
                $v = $cache->getMultiWithUnionSetCallback(
                        $keyedIds, 30, $genFunc, [ 'lowTTL' => 0 ] + $extOpts );
                $this->assertEquals( $value, $v[$keyB], "Value returned" );
                $this->assertEquals( 1, $wasSet, "Value not regenerated" );
-               $this->assertEquals( 0, $cache->getWarmupKeyMisses(), "Keys warmed in process cache" );
+               $this->assertEquals( 0, $cache->getWarmupKeyMisses(), "Keys warmed in warmup cache" );
 
                $mockWallClock += 1;
 
@@ -818,11 +811,7 @@ class WANObjectCacheTest extends PHPUnit\Framework\TestCase {
 
                $curTTL = null;
                $v = $cache->get( $keyC, $curTTL, [ $cKey1, $cKey2 ] );
-               if ( $versioned ) {
-                       $this->assertEquals( $value, $v[$cache::VFLD_DATA], "Value returned" );
-               } else {
-                       $this->assertEquals( $value, $v, "Value returned" );
-               }
+               $this->assertEquals( $value, $v, "Value returned" );
                $this->assertLessThanOrEqual( 0, $curTTL, "Value has current TTL < 0 due to check keys" );
 
                $wasSet = 0;
@@ -880,7 +869,7 @@ class WANObjectCacheTest extends PHPUnit\Framework\TestCase {
 
        /**
         * @covers WANObjectCache::getWithSetCallback()
-        * @covers WANObjectCache::doGetWithSetCallback()
+        * @covers WANObjectCache::fetchOrRegenerate()
         */
        public function testLockTSE() {
                $cache = $this->cache;
@@ -924,7 +913,7 @@ class WANObjectCacheTest extends PHPUnit\Framework\TestCase {
 
        /**
         * @covers WANObjectCache::getWithSetCallback()
-        * @covers WANObjectCache::doGetWithSetCallback()
+        * @covers WANObjectCache::fetchOrRegenerate()
         * @covers WANObjectCache::set()
         */
        public function testLockTSESlow() {
@@ -1005,7 +994,7 @@ class WANObjectCacheTest extends PHPUnit\Framework\TestCase {
 
        /**
         * @covers WANObjectCache::getWithSetCallback()
-        * @covers WANObjectCache::doGetWithSetCallback()
+        * @covers WANObjectCache::fetchOrRegenerate()
         */
        public function testBusyValue() {
                $cache = $this->cache;
@@ -1083,7 +1072,7 @@ class WANObjectCacheTest extends PHPUnit\Framework\TestCase {
                $cache->set( $key2, $value2, 10 );
 
                $curTTLs = [];
-               $this->assertEquals(
+               $this->assertSame(
                        [ $key1 => $value1, $key2 => $value2 ],
                        $cache->getMulti( [ $key1, $key2, $key3 ], $curTTLs ),
                        'Result array populated'
@@ -1099,7 +1088,7 @@ class WANObjectCacheTest extends PHPUnit\Framework\TestCase {
                $mockWallClock += 1;
 
                $curTTLs = [];
-               $this->assertEquals(
+               $this->assertSame(
                        [ $key1 => $value1, $key2 => $value2 ],
                        $cache->getMulti( [ $key1, $key2, $key3 ], $curTTLs, [ $cKey1, $cKey2 ] ),
                        "Result array populated even with new check keys"
@@ -1160,7 +1149,7 @@ class WANObjectCacheTest extends PHPUnit\Framework\TestCase {
                        'key2' => $check2,
                        'key3' => $check3,
                ] );
-               $this->assertEquals(
+               $this->assertSame(
                        [ 'key1' => $value1, 'key2' => $value2 ],
                        $result,
                        'Initial values'
@@ -1180,7 +1169,7 @@ class WANObjectCacheTest extends PHPUnit\Framework\TestCase {
                        'key2' => $check2,
                        'key3' => $check3,
                ] );
-               $this->assertEquals(
+               $this->assertSame(
                        [ 'key1' => $value1, 'key2' => $value2 ],
                        $result,
                        'key1 expired by check1, but value still provided'
@@ -1283,7 +1272,7 @@ class WANObjectCacheTest extends PHPUnit\Framework\TestCase {
        /**
         * @dataProvider getWithSetCallback_versions_provider
         * @covers WANObjectCache::getWithSetCallback()
-        * @covers WANObjectCache::doGetWithSetCallback()
+        * @covers WANObjectCache::fetchOrRegenerate()
         * @param array $extOpts
         * @param bool $versioned
         */
@@ -1523,7 +1512,7 @@ class WANObjectCacheTest extends PHPUnit\Framework\TestCase {
                $this->internalCache->set(
                        WANObjectCache::VALUE_KEY_PREFIX . $vKey1,
                        [
-                               WANObjectCache::FLD_VERSION => WANObjectCache::VERSION,
+                               WANObjectCache::FLD_FORMAT_VERSION => WANObjectCache::VERSION,
                                WANObjectCache::FLD_VALUE => $value,
                                WANObjectCache::FLD_TTL => 3600,
                                WANObjectCache::FLD_TIME => $goodTime
@@ -1532,7 +1521,7 @@ class WANObjectCacheTest extends PHPUnit\Framework\TestCase {
                $this->internalCache->set(
                        WANObjectCache::VALUE_KEY_PREFIX . $vKey2,
                        [
-                               WANObjectCache::FLD_VERSION => WANObjectCache::VERSION,
+                               WANObjectCache::FLD_FORMAT_VERSION => WANObjectCache::VERSION,
                                WANObjectCache::FLD_VALUE => $value,
                                WANObjectCache::FLD_TTL => 3600,
                                WANObjectCache::FLD_TIME => $badTime
@@ -1569,7 +1558,7 @@ class WANObjectCacheTest extends PHPUnit\Framework\TestCase {
                        ->setMethods( [ 'get', 'changeTTL' ] )->getMock();
                $backend->expects( $this->once() )->method( 'get' )
                        ->willReturn( [
-                               WANObjectCache::FLD_VERSION => WANObjectCache::VERSION,
+                               WANObjectCache::FLD_FORMAT_VERSION => WANObjectCache::VERSION,
                                WANObjectCache::FLD_VALUE => 'value',
                                WANObjectCache::FLD_TTL => 3600,
                                WANObjectCache::FLD_TIME => 300,
@@ -1841,14 +1830,145 @@ class WANObjectCacheTest extends PHPUnit\Framework\TestCase {
 
        /**
         * @dataProvider statsKeyProvider
-        * @covers WANObjectCache::determineKeyClass
+        * @covers WANObjectCache::determineKeyClassForStats
         */
        public function testStatsKeyClass( $key, $class ) {
                $wanCache = TestingAccessWrapper::newFromObject( new WANObjectCache( [
                        'cache' => new HashBagOStuff
                ] ) );
 
-               $this->assertEquals( $class, $wanCache->determineKeyClass( $key ) );
+               $this->assertEquals( $class, $wanCache->determineKeyClassForStats( $key ) );
+       }
+
+       /**
+        * @covers WANObjectCache::makeMultiKeys
+        */
+       public function testMakeMultiKeys() {
+               $cache = $this->cache;
+
+               $ids = [ 1, 2, 3, 4, 4, 5, 6, 6, 7, 7 ];
+               $keyCallback = function ( $id, WANObjectCache $cache ) {
+                       return $cache->makeKey( 'key', $id );
+               };
+               $keyedIds = $cache->makeMultiKeys( $ids, $keyCallback );
+
+               $expected = [
+                       "local:key:1" => 1,
+                       "local:key:2" => 2,
+                       "local:key:3" => 3,
+                       "local:key:4" => 4,
+                       "local:key:5" => 5,
+                       "local:key:6" => 6,
+                       "local:key:7" => 7
+               ];
+               $this->assertSame( $expected, iterator_to_array( $keyedIds ) );
+
+               $ids = [ '1', '2', '3', '4', '4', '5', '6', '6', '7', '7' ];
+               $keyCallback = function ( $id, WANObjectCache $cache ) {
+                       return $cache->makeGlobalKey( 'key', $id, 'a', $id, 'b' );
+               };
+               $keyedIds = $cache->makeMultiKeys( $ids, $keyCallback );
+
+               $expected = [
+                       "global:key:1:a:1:b" => '1',
+                       "global:key:2:a:2:b" => '2',
+                       "global:key:3:a:3:b" => '3',
+                       "global:key:4:a:4:b" => '4',
+                       "global:key:5:a:5:b" => '5',
+                       "global:key:6:a:6:b" => '6',
+                       "global:key:7:a:7:b" => '7'
+               ];
+               $this->assertSame( $expected, iterator_to_array( $keyedIds ) );
+       }
+
+       /**
+        * @covers WANObjectCache::makeMultiKeys
+        */
+       public function testMakeMultiKeysIntString() {
+               $cache = $this->cache;
+               $ids = [ 1, 2, 3, 4, '4', 5, 6, 6, 7, '7' ];
+               $keyCallback = function ( $id, WANObjectCache $cache ) {
+                       return $cache->makeGlobalKey( 'key', $id, 'a', $id, 'b' );
+               };
+
+               $keyedIds = $cache->makeMultiKeys( $ids, $keyCallback );
+
+               $expected = [
+                       "global:key:1:a:1:b" => 1,
+                       "global:key:2:a:2:b" => 2,
+                       "global:key:3:a:3:b" => 3,
+                       "global:key:4:a:4:b" => 4,
+                       "global:key:5:a:5:b" => 5,
+                       "global:key:6:a:6:b" => 6,
+                       "global:key:7:a:7:b" => 7
+               ];
+               $this->assertSame( $expected, iterator_to_array( $keyedIds ) );
+       }
+
+       /**
+        * @covers WANObjectCache::makeMultiKeys
+        * @expectedException UnexpectedValueException
+        */
+       public function testMakeMultiKeysCollision() {
+               $ids = [ 1, 2, 3, 4, '4', 5, 6, 6, 7 ];
+
+               $this->cache->makeMultiKeys(
+                       $ids,
+                       function ( $id ) {
+                               return "keymod:" . $id % 3;
+                       }
+               );
+       }
+
+       /**
+        * @covers WANObjectCache::multiRemap
+        */
+       public function testMultiRemap() {
+               $a = [ 'a', 'b', 'c' ];
+               $res = [ 'keyA' => 1, 'keyB' => 2, 'keyC' => 3 ];
+
+               $this->assertEquals(
+                       [ 'a' => 1, 'b' => 2, 'c' => 3 ],
+                       $this->cache->multiRemap( $a, $res )
+               );
+
+               $a = [ 'a', 'b', 'c', 'c', 'd' ];
+               $res = [ 'keyA' => 1, 'keyB' => 2, 'keyC' => 3, 'keyD' => 4 ];
+
+               $this->assertEquals(
+                       [ 'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4 ],
+                       $this->cache->multiRemap( $a, $res )
+               );
+       }
+
+       /**
+        * @covers WANObjectCache::hash256
+        */
+       public function testHash256() {
+               $bag = new HashBagOStuff();
+               $cache = new WANObjectCache( [ 'cache' => $bag, 'epoch' => 5 ] );
+               $this->assertEquals(
+                       'f402bce76bfa1136adc705d8d5719911ce1fe61f0ad82ddf79a15f3c4de6ec4c',
+                       $cache->hash256( 'x' )
+               );
+
+               $cache = new WANObjectCache( [ 'cache' => $bag, 'epoch' => 50 ] );
+               $this->assertEquals(
+                       'f79a126722f0a682c4c500509f1b61e836e56c4803f92edc89fc281da5caa54e',
+                       $cache->hash256( 'x' )
+               );
+
+               $cache = new WANObjectCache( [ 'cache' => $bag, 'secret' => 'garden' ] );
+               $this->assertEquals(
+                       '48cd57016ffe29981a1114c45e5daef327d30fc6206cb73edc3cb94b4d8fe093',
+                       $cache->hash256( 'x' )
+               );
+
+               $cache = new WANObjectCache( [ 'cache' => $bag, 'secret' => 'garden', 'epoch' => 3 ] );
+               $this->assertEquals(
+                       '48cd57016ffe29981a1114c45e5daef327d30fc6206cb73edc3cb94b4d8fe093',
+                       $cache->hash256( 'x' )
+               );
        }
 }