WordPress.org

Make WordPress Core

Ticket #28759: 28759-cache-unit-tests.diff

File 28759-cache-unit-tests.diff, 37.1 KB (added by jipmoors, 6 years ago)

Split unit tests for Public API and WP_Cache_Object

  • tests/phpunit/tests/cache/WPObjectCache.php

     
     1<?php
     2
     3/**
     4 * @group cache
     5 */
     6class Tests_Cache_WPObjectCache extends WP_UnitTestCase {
     7        var $cache = NULL;
     8
     9        function setUp() {
     10                parent::setUp();
     11                // create two cache objects with a shared cache dir
     12                // this simulates a typical cache situation, two separate requests interacting
     13                $this->cache =& $this->init_cache();
     14        }
     15
     16        function tearDown() {
     17                $this->flush_cache();
     18                parent::tearDown();
     19        }
     20
     21        function &init_cache() {
     22                $cache = new WP_Object_Cache();
     23                $cache->add_global_groups( array( 'global-cache-test', 'users', 'userlogins', 'usermeta', 'user_meta', 'site-transient', 'site-options', 'site-lookup', 'blog-lookup', 'blog-details', 'rss', 'global-posts', 'blog-id-cache' ) );
     24                return $cache;
     25        }
     26
     27        function test_miss() {
     28                $this->assertFalse($this->cache->get(rand_str()));
     29        }
     30
     31        function test_add_get() {
     32                $key = rand_str();
     33                $val = rand_str();
     34
     35                $this->cache->add($key, $val);
     36                $this->assertEquals($val, $this->cache->get($key));
     37        }
     38
     39        function test_add_get_0() {
     40                $key = rand_str();
     41                $val = 0;
     42
     43                // you can store zero in the cache
     44                $this->cache->add($key, $val);
     45                $this->assertEquals($val, $this->cache->get($key));
     46        }
     47
     48        function test_add_get_null() {
     49                $key = rand_str();
     50                $val = null;
     51
     52                $this->assertTrue( $this->cache->add($key, $val) );
     53                // null is converted to empty string
     54                $this->assertNull( $this->cache->get($key) );
     55        }
     56
     57        function test_add() {
     58                $key = rand_str();
     59                $val1 = rand_str();
     60                $val2 = rand_str();
     61
     62                // add $key to the cache
     63                $this->assertTrue($this->cache->add($key, $val1));
     64                $this->assertEquals($val1, $this->cache->get($key));
     65                // $key is in the cache, so reject new calls to add()
     66                $this->assertFalse($this->cache->add($key, $val2));
     67                $this->assertEquals($val1, $this->cache->get($key));
     68        }
     69
     70        function test_replace() {
     71                $key = rand_str();
     72                $val = rand_str();
     73                $val2 = rand_str();
     74
     75                // memcached rejects replace() if the key does not exist
     76                $this->assertFalse($this->cache->replace($key, $val));
     77                $this->assertFalse($this->cache->get($key));
     78                $this->assertTrue($this->cache->add($key, $val));
     79                $this->assertEquals($val, $this->cache->get($key));
     80                $this->assertTrue($this->cache->replace($key, $val2));
     81                $this->assertEquals($val2, $this->cache->get($key));
     82        }
     83
     84        function test_set() {
     85                $key = rand_str();
     86                $val1 = rand_str();
     87                $val2 = rand_str();
     88
     89                // memcached accepts set() if the key does not exist
     90                $this->assertTrue($this->cache->set($key, $val1));
     91                $this->assertEquals($val1, $this->cache->get($key));
     92                // Second set() with same key should be allowed
     93                $this->assertTrue($this->cache->set($key, $val2));
     94                $this->assertEquals($val2, $this->cache->get($key));
     95        }
     96
     97        function test_flush() {
     98                global $_wp_using_ext_object_cache;
     99
     100                if ( $_wp_using_ext_object_cache )
     101                        return;
     102
     103                $key = rand_str();
     104                $val = rand_str();
     105
     106                $this->cache->add($key, $val);
     107                // item is visible to both cache objects
     108                $this->assertEquals($val, $this->cache->get($key));
     109                $this->cache->flush();
     110                // If there is no value get returns false.
     111                $this->assertFalse($this->cache->get($key));
     112        }
     113
     114        // Make sure objects are cloned going to and from the cache
     115        function test_object_refs() {
     116                $key = rand_str();
     117                $object_a = new stdClass;
     118                $object_a->foo = 'alpha';
     119                $this->cache->set( $key, $object_a );
     120                $object_a->foo = 'bravo';
     121                $object_b = $this->cache->get( $key );
     122                $this->assertEquals( 'alpha', $object_b->foo );
     123                $object_b->foo = 'charlie';
     124                $this->assertEquals( 'bravo', $object_a->foo );
     125
     126                $key = rand_str();
     127                $object_a = new stdClass;
     128                $object_a->foo = 'alpha';
     129                $this->cache->add( $key, $object_a );
     130                $object_a->foo = 'bravo';
     131                $object_b = $this->cache->get( $key );
     132                $this->assertEquals( 'alpha', $object_b->foo );
     133                $object_b->foo = 'charlie';
     134                $this->assertEquals( 'bravo', $object_a->foo );
     135        }
     136
     137        function test_incr() {
     138                $key = rand_str();
     139
     140                $this->assertFalse( $this->cache->incr( $key ) );
     141
     142                $this->cache->set( $key, 0 );
     143                $this->cache->incr( $key );
     144                $this->assertEquals( 1, $this->cache->get( $key ) );
     145
     146                $this->cache->incr( $key, 2 );
     147                $this->assertEquals( 3, $this->cache->get( $key ) );
     148        }
     149
     150        function test_decr() {
     151                $key = rand_str();
     152
     153                $this->assertFalse( $this->cache->decr( $key ) );
     154
     155                $this->cache->set( $key, 0 );
     156                $this->cache->decr( $key );
     157                $this->assertEquals( 0, $this->cache->get( $key ) );
     158
     159                $this->cache->set( $key, 3 );
     160                $this->cache->decr( $key );
     161                $this->assertEquals( 2, $this->cache->get( $key ) );
     162
     163                $this->cache->decr( $key, 2 );
     164                $this->assertEquals( 0, $this->cache->get( $key ) );
     165        }
     166
     167        function test_delete() {
     168                $key = rand_str();
     169                $val = rand_str();
     170
     171                // Verify set
     172                $this->assertTrue( $this->cache->set( $key, $val ) );
     173                $this->assertEquals( $val, $this->cache->get( $key ) );
     174
     175                // Verify successful delete
     176                $this->assertTrue( $this->cache->delete( $key ) );
     177                $this->assertFalse( $this->cache->get( $key ) );
     178
     179                $this->assertFalse( $this->cache->delete( $key, 'default') );
     180        }
     181
     182        function test_switch_to_blog() {
     183                if ( ! method_exists( $this->cache, 'switch_to_blog' ) )
     184                        return;
     185
     186                $key = rand_str();
     187                $val = rand_str();
     188                $val2 = rand_str();
     189
     190                if ( ! is_multisite() ) {
     191                        // Single site ingnores switch_to_blog().
     192                        $this->assertTrue( $this->cache->set( $key, $val ) );
     193                        $this->assertEquals( $val, $this->cache->get( $key ) );
     194                        $this->cache->switch_to_blog( 999 );
     195                        $this->assertEquals( $val, $this->cache->get( $key ) );
     196                        $this->assertTrue( $this->cache->set( $key, $val2 ) );
     197                        $this->assertEquals( $val2, $this->cache->get( $key ) );
     198                        $this->cache->switch_to_blog( get_current_blog_id() );
     199                        $this->assertEquals( $val2, $this->cache->get( $key ) );
     200                } else {
     201                        // Multisite should have separate per-blog caches
     202                        $this->assertTrue( $this->cache->set( $key, $val ) );
     203                        $this->assertEquals( $val, $this->cache->get( $key ) );
     204                        $this->cache->switch_to_blog( 999 );
     205                        $this->assertFalse( $this->cache->get( $key ) );
     206                        $this->assertTrue( $this->cache->set( $key, $val2 ) );
     207                        $this->assertEquals( $val2, $this->cache->get( $key ) );
     208                        $this->cache->switch_to_blog( get_current_blog_id() );
     209                        $this->assertEquals( $val, $this->cache->get( $key ) );
     210                        $this->cache->switch_to_blog( 999 );
     211                        $this->assertEquals( $val2, $this->cache->get( $key ) );
     212                        $this->cache->switch_to_blog( get_current_blog_id() );
     213                        $this->assertEquals( $val, $this->cache->get( $key ) );
     214                }
     215
     216                // Global group
     217                $this->assertTrue( $this->cache->set( $key, $val, 'global-cache-test' ) );
     218                $this->assertEquals( $val, $this->cache->get( $key, 'global-cache-test' ) );
     219                $this->cache->switch_to_blog( 999 );
     220                $this->assertEquals( $val, $this->cache->get( $key, 'global-cache-test' ) );
     221                $this->assertTrue( $this->cache->set( $key, $val2, 'global-cache-test' ) );
     222                $this->assertEquals( $val2, $this->cache->get( $key, 'global-cache-test' ) );
     223                $this->cache->switch_to_blog( get_current_blog_id() );
     224                $this->assertEquals( $val2, $this->cache->get( $key, 'global-cache-test' ) );
     225        }
     226
     227        function test_wp_cache_init() {
     228                global $_wp_using_ext_object_cache;
     229
     230                if ( $_wp_using_ext_object_cache )
     231                        return;
     232
     233                $new_blank_cache_object = new WP_Object_Cache();
     234                wp_cache_init();
     235
     236                global $wp_object_cache;
     237                $this->assertEquals( $wp_object_cache, $new_blank_cache_object );
     238        }
     239}
  • tests/phpunit/tests/cache/api.php

     
     1<?php
     2
     3/**
     4 * @group cache
     5 */
     6class Tests_Cache_API extends WP_UnitTestCase {
     7        var $cache = null;
     8
     9        function setUp() {
     10                parent::setUp();
     11        }
     12
     13        function tearDown() {
     14                wp_cache_flush();
     15                parent::tearDown();
     16        }
     17
     18        function test_set() {
     19                $key   = rand_str();
     20                $value = rand_str();
     21
     22                $this->assertTrue( wp_cache_set( $key, $value ) );
     23                $this->assertTrue( wp_cache_set( $key, $value, 'group' ) );
     24                $this->assertTrue( wp_cache_set( $key, 0 ) );
     25                $this->assertTrue( wp_cache_set( $key, false ) );
     26        }
     27
     28        function test_get() {
     29                $key    = rand_str();
     30                $value  = rand_str();
     31                $value2 = rand_str();
     32
     33                $this->assertFalse( wp_cache_get( 'non-existing-key' ) );
     34                wp_cache_get( 'non-existing-key', 'default', false, $found );
     35                $this->assertFalse( $found );
     36
     37
     38                unset($found);
     39
     40                wp_cache_set( $key, $value );
     41                $result = wp_cache_get( $key, 'default', false, $found );
     42
     43                $this->assertTrue( $found );
     44                $this->assertEquals( $value, $result );
     45
     46                unset($found);
     47
     48                // test zero
     49                wp_cache_set( $key, 0 );
     50                $result = wp_cache_get( $key, 'default', false, $found );
     51
     52                $this->assertTrue( $found );
     53                $this->assertEquals( 0, $result );
     54
     55                unset($found);
     56
     57                // test false
     58                wp_cache_set( $key, false );
     59                $result = wp_cache_get( $key, 'default', false, $found );
     60
     61                $this->assertTrue( $found );
     62                $this->assertFalse( $result );
     63
     64                unset($found);
     65
     66                // test null
     67                wp_cache_set( $key, null );
     68                $result = wp_cache_get( $key, 'default', false, $found );
     69
     70                $this->assertTrue( $found );
     71                $this->assertNull( $result );
     72
     73                unset($found);
     74
     75                // test array
     76                $array = ['array content'];
     77
     78                wp_cache_set( $key, $array );
     79                $result = wp_cache_get( $key, 'default', false, $found );
     80
     81                $this->assertTrue( $found );
     82                $this->assertEquals( $array, $result );
     83
     84                unset($found);
     85
     86                // test object
     87                $object = new stdClass();
     88                $object->parameter = 'data';
     89
     90                wp_cache_set( $key, $object );
     91                $result = wp_cache_get( $key, 'default', false, $found );
     92
     93                $this->assertTrue( $found );
     94                $this->assertEquals( $object, $result );
     95
     96                unset($found);
     97
     98                // same key in different group with different value
     99                wp_cache_set( $key, $value );
     100                $this->assertEquals( $value, wp_cache_get( $key ) );
     101
     102                wp_cache_set( $key, $value2, 'my_group' );
     103                $this->assertEquals( $value2, wp_cache_get( $key, 'my_group' ) );
     104
     105                $this->assertEquals( $value, wp_cache_get( $key ) );
     106        }
     107
     108        function test_add() {
     109                $key    = rand_str();
     110                $value1 = 'dummy';
     111                $value2 = 'new';
     112
     113                // key should not exist
     114                $this->assertFalse( wp_cache_get( $key ) );
     115
     116                // adding new key
     117                $this->assertTrue( wp_cache_add( $key, $value1 ) );
     118                // adding an existing key
     119                $this->assertFalse( wp_cache_add( $key, $value2 ) );
     120
     121                // adding new key to a group
     122                $this->assertTrue( wp_cache_add( $key, $value1, 'my_group' ) );
     123                // adding an existing key to a group
     124                $this->assertFalse( wp_cache_add( $key, $value2, 'my_group' ) );
     125        }
     126
     127        function test_delete() {
     128                // delete non-exsisting key
     129                $this->assertFalse( wp_cache_delete( 'remove_me' ) );
     130
     131                wp_cache_set( 'remove_me', 'now' );
     132                $this->assertTrue( wp_cache_delete( 'remove_me' ) );
     133
     134                // delete an already deleted key
     135                $this->assertFalse( wp_cache_get( 'remove_me' ) );
     136        }
     137
     138        function test_replace() {
     139                $key    = rand_str();
     140                $value1 = rand_str();
     141                $value2 = rand_str();
     142
     143                // no group:
     144                wp_cache_set( $key, $value1 );
     145
     146                $this->assertTrue( wp_cache_replace( $key, $value2 ) );
     147                // test value
     148                $this->assertEquals( $value2, wp_cache_get( $key ) );
     149
     150                // group:
     151                wp_cache_set( $key, $value1, 'my_group' );
     152
     153                $this->assertTrue( wp_cache_replace( $key, $value2, 'my_group' ) );
     154                $this->assertEquals( $value2, wp_cache_get( $key, 'my_group' ) );
     155        }
     156
     157        function test_increase() {
     158                $key = rand_str();
     159
     160                // non existent key check
     161                $this->assertFalse( wp_cache_incr( 'incr_non_existent' ) );
     162
     163                // adding default (1)
     164                wp_cache_set( $key, 9 );
     165                $this->assertEquals( 10, wp_cache_incr( $key ) );
     166
     167                // adding 0
     168                wp_cache_set( $key, 3 );
     169                $this->assertEquals( 3, wp_cache_incr( $key, 0 ) );
     170
     171                // adding 1
     172                wp_cache_set( $key, 7 );
     173                $this->assertEquals( 8, wp_cache_incr( $key, 1 ) );
     174
     175                // adding 3
     176                wp_cache_set( $key, 5 );
     177                $this->assertEquals( 8, wp_cache_incr( $key, 3 ) );
     178
     179                // result in negative number -> 0
     180                wp_cache_set( $key, - 5 );
     181                $this->assertEquals( 0, wp_cache_incr( $key ) );
     182
     183                /**
     184                 * Should negative increment be possible / allowed?
     185                 * Memcache allows for negative increment (not negative decrement)
     186                 */
     187                // negative increment
     188                wp_cache_set( $key, 4 );
     189                $this->assertEquals( 2, wp_cache_incr( $key, - 2 ) );
     190
     191                // negative increment below zero
     192                wp_cache_set( $key, 4 );
     193                $this->assertEquals( 0, wp_cache_incr( $key, - 6 ) );
     194
     195                // adding string
     196                wp_cache_set( $key, 3 );
     197                $this->assertEquals( 53, wp_cache_incr( $key, '50' ) );
     198
     199                // adding non-numeric string
     200                wp_cache_set( $key, 4 );
     201                $this->assertEquals( 4, wp_cache_incr( $key, 'aaa' ) );
     202
     203                // adding array with entry
     204                wp_cache_set( $key, 2 );
     205                $this->assertEquals( 2, wp_cache_incr( $key, array('') ) );
     206
     207
     208                // group:
     209                wp_cache_set( $key, 8, 'incr_group' );
     210                $this->assertEquals( 9, wp_cache_incr( $key, 1, 'incr_group' ) );
     211        }
     212
     213        function test_decrease() {
     214                $key = rand_str();
     215
     216                // non existent key check
     217                $this->assertFalse( wp_cache_decr( 'decr_non_existent' ) );
     218
     219                // default (1)
     220                wp_cache_set( $key, 10 );
     221                $this->assertEquals( 9, wp_cache_decr( $key ) );
     222
     223                // zero
     224                wp_cache_set( $key, 6 );
     225                $this->assertEquals( 6, wp_cache_decr( $key, 0 ) );
     226
     227                // one
     228                wp_cache_set( $key, 7 );
     229                $result = wp_cache_decr( $key, 1 );
     230                $this->assertEquals( $result, 6 );
     231
     232                // three
     233                wp_cache_set( $key, 15 );
     234                $this->assertEquals( 12, wp_cache_decr( $key, 3 ) );
     235
     236                // negative number
     237                wp_cache_set( $key, - 5 );
     238                $this->assertEquals( 0, wp_cache_decr( $key ) );
     239
     240                // negative decrement = increment?
     241                wp_cache_set( $key, 20 );
     242                $this->assertEquals( 22, wp_cache_decr( $key, - 2 ) );
     243
     244                // a string
     245                wp_cache_set( $key, 11 );
     246                $this->assertEquals( 6, wp_cache_decr( $key, '5' ) );
     247
     248                // adding non-numeric string
     249                wp_cache_set( $key, 4 );
     250                $this->assertEquals( 4, wp_cache_decr( $key, 'aaa' ) );
     251
     252                // adding array with entry
     253                wp_cache_set( $key, 2 );
     254                $this->assertEquals( 2, wp_cache_decr( $key, array('') ) );
     255
     256                // grouped
     257                wp_cache_set( $key, 5, 'my_group' );
     258                $this->assertEquals( 4, wp_cache_decr( $key, 1, 'my_group' ) );
     259        }
     260
     261        function test_flush() {
     262                $key1 = rand_str();
     263                $key2 = rand_str();
     264
     265                wp_cache_set( $key1, 'data1' );
     266                wp_cache_set( $key2, 'data2' );
     267
     268                $this->assertEquals( 'data1', wp_cache_get($key1) );
     269                $this->assertEquals( 'data2', wp_cache_get($key2) );
     270
     271                // add
     272                // add
     273                wp_cache_flush();
     274
     275                $this->assertFalse( wp_cache_get( $key1 ) );
     276                $this->assertFalse( wp_cache_get( $key2 ) );
     277        }
     278
     279        // test switching blogs
     280        function test_switch_blog() {
     281                $key  = rand_str();
     282                $val  = rand_str();
     283                $val2 = rand_str();
     284
     285                if ( ! is_multisite() ) {
     286                        // Single site ignores switch_to_blog()
     287                        $this->assertTrue( wp_cache_set( $key, $val ) );
     288                        $this->assertEquals( $val, wp_cache_get( $key ) );
     289
     290                        wp_cache_switch_to_blog( 999 );
     291                        $this->assertEquals( $val, wp_cache_get( $key ) );
     292                        $this->assertTrue( wp_cache_set( $key, $val2 ) );
     293                        $this->assertEquals( $val2, wp_cache_get( $key ) );
     294
     295                        wp_cache_switch_to_blog( get_current_blog_id() );
     296                        $this->assertEquals( $val2, wp_cache_get( $key ) );
     297                } else {
     298                        // Multisite should have separate per-blog caches
     299                        $this->assertTrue( wp_cache_set( $key, $val ) );
     300                        $this->assertEquals( $val, wp_cache_get( $key ) );
     301
     302                        wp_cache_switch_to_blog( 999 );
     303                        $this->assertFalse( wp_cache_get( $key ) );
     304                        $this->assertTrue( wp_cache_set( $key, $val2 ) );
     305                        $this->assertEquals( $val2, wp_cache_get( $key ) );
     306
     307                        wp_cache_switch_to_blog( get_current_blog_id() );
     308                        $this->assertEquals( $val, wp_cache_get( $key ) );
     309
     310                        wp_cache_switch_to_blog( 999 );
     311                        $this->assertEquals( $val2, wp_cache_get( $key ) );
     312
     313                        wp_cache_switch_to_blog( get_current_blog_id() );
     314                        $this->assertEquals( $val, wp_cache_get( $key ) );
     315                }
     316        }
     317
     318        // Make sure objects are cloned going to and from the cache
     319        function test_object_references() {
     320
     321                // run it twice with different keys and similar objects
     322                $keys = array(rand_str(), rand_str());
     323
     324                foreach ($keys as $key) {
     325                        $object_a      = new stdClass;
     326                        $object_a->foo = 'alpha';
     327                        wp_cache_set( $key, $object_a );
     328
     329                        // change property of original object
     330                        $object_a->foo = 'bravo';
     331
     332                        // check cached object for old value
     333                        $object_b = wp_cache_get( $key );
     334                        $this->assertEquals( 'alpha', $object_b->foo );
     335
     336                        // change retrieved object property
     337                        $object_b->foo = 'charlie';
     338
     339                        // make sure original property is expected value
     340                        $this->assertEquals( 'bravo', $object_a->foo );
     341                }
     342        }
     343
     344    // Keys in global groups should be preserved when switching blogs
     345        function test_global_group() {
     346                $key  = rand_str();
     347                $val  = rand_str();
     348                $val2 = rand_str();
     349
     350                // in multisite only
     351                if ( is_multisite() ) {
     352                        wp_cache_add_global_groups( 'global-cache-test' );
     353
     354                        // Global group
     355                        wp_cache_set( $key, $val, 'global-cache-test' );
     356                        $this->assertEquals( $val, wp_cache_get( $key, 'global-cache-test' ) );
     357
     358                        wp_cache_set( $key, $val, 'not-global' );
     359                        $this->assertEquals( $val, wp_cache_get( $key, 'not-global' ) );
     360
     361                        wp_cache_switch_to_blog( 999 );
     362                        $this->assertEquals( $val, wp_cache_get( $key, 'global-cache-test' ) );
     363                        wp_cache_set( $key, $val2, 'global-cache-test' );
     364                        $this->assertEquals( $val2, wp_cache_get( $key, 'global-cache-test' ) );
     365
     366                        // value should not be retrieved, because the group is not global
     367                        $this->assertFalse( wp_cache_get( $key, 'not-global' ) );
     368
     369                        wp_cache_switch_to_blog( get_current_blog_id() );
     370                        $this->assertEquals( $val2, wp_cache_get( $key, 'global-cache-test' ) );
     371
     372                        // the value should be back again
     373                        $this->assertEquals( $val, wp_cache_get( $key, 'not-global' ) );
     374                }
     375        }
     376}
     377<?php
     378
     379/**
     380 * @group cache
     381 */
     382class Tests_Cache_API extends WP_UnitTestCase {
     383        var $cache = null;
     384
     385        function setUp() {
     386                parent::setUp();
     387        }
     388
     389        function tearDown() {
     390                wp_cache_flush();
     391                parent::tearDown();
     392        }
     393
     394        function test_set() {
     395                $key   = rand_str();
     396                $value = rand_str();
     397
     398                $this->assertTrue( wp_cache_set( $key, $value ) );
     399                $this->assertTrue( wp_cache_set( $key, $value, 'group' ) );
     400                $this->assertTrue( wp_cache_set( $key, 0 ) );
     401                $this->assertTrue( wp_cache_set( $key, false ) );
     402        }
     403
     404        function test_get() {
     405                $key    = rand_str();
     406                $value  = rand_str();
     407                $value2 = rand_str();
     408
     409                $this->assertFalse( wp_cache_get( 'non-existing-key' ) );
     410                wp_cache_get( 'non-existing-key', 'default', false, $found );
     411                $this->assertFalse( $found );
     412
     413
     414                unset($found);
     415
     416                wp_cache_set( $key, $value );
     417                $result = wp_cache_get( $key, 'default', false, $found );
     418
     419                $this->assertTrue( $found );
     420                $this->assertEquals( $value, $result );
     421
     422                unset($found);
     423
     424                // test zero
     425                wp_cache_set( $key, 0 );
     426                $result = wp_cache_get( $key, 'default', false, $found );
     427
     428                $this->assertTrue( $found );
     429                $this->assertEquals( 0, $result );
     430
     431                unset($found);
     432
     433                // test false
     434                wp_cache_set( $key, false );
     435                $result = wp_cache_get( $key, 'default', false, $found );
     436
     437                $this->assertTrue( $found );
     438                $this->assertFalse( $result );
     439
     440                unset($found);
     441
     442                // test null
     443                wp_cache_set( $key, null );
     444                $result = wp_cache_get( $key, 'default', false, $found );
     445
     446                $this->assertTrue( $found );
     447                $this->assertNull( $result );
     448
     449                unset($found);
     450
     451                // test array
     452                $array = ['array content'];
     453
     454                wp_cache_set( $key, $array );
     455                $result = wp_cache_get( $key, 'default', false, $found );
     456
     457                $this->assertTrue( $found );
     458                $this->assertEquals( $array, $result );
     459
     460                unset($found);
     461
     462                // test object
     463                $object = new stdClass();
     464                $object->parameter = 'data';
     465
     466                wp_cache_set( $key, $object );
     467                $result = wp_cache_get( $key, 'default', false, $found );
     468
     469                $this->assertTrue( $found );
     470                $this->assertEquals( $object, $result );
     471
     472                unset($found);
     473
     474                // same key in different group with different value
     475                wp_cache_set( $key, $value );
     476                $this->assertEquals( $value, wp_cache_get( $key ) );
     477
     478                wp_cache_set( $key, $value2, 'my_group' );
     479                $this->assertEquals( $value2, wp_cache_get( $key, 'my_group' ) );
     480
     481                $this->assertEquals( $value, wp_cache_get( $key ) );
     482        }
     483
     484        function test_add() {
     485                $key    = rand_str();
     486                $value1 = 'dummy';
     487                $value2 = 'new';
     488
     489                // key should not exist
     490                $this->assertFalse( wp_cache_get( $key ) );
     491
     492                // adding new key
     493                $this->assertTrue( wp_cache_add( $key, $value1 ) );
     494                // adding an existing key
     495                $this->assertFalse( wp_cache_add( $key, $value2 ) );
     496
     497                // adding new key to a group
     498                $this->assertTrue( wp_cache_add( $key, $value1, 'my_group' ) );
     499                // adding an existing key to a group
     500                $this->assertFalse( wp_cache_add( $key, $value2, 'my_group' ) );
     501        }
     502
     503        function test_delete() {
     504                // delete non-exsisting key
     505                $this->assertFalse( wp_cache_delete( 'remove_me' ) );
     506
     507                wp_cache_set( 'remove_me', 'now' );
     508                $this->assertTrue( wp_cache_delete( 'remove_me' ) );
     509
     510                // delete an already deleted key
     511                $this->assertFalse( wp_cache_get( 'remove_me' ) );
     512        }
     513
     514        function test_replace() {
     515                $key    = rand_str();
     516                $value1 = rand_str();
     517                $value2 = rand_str();
     518
     519                // no group:
     520                wp_cache_set( $key, $value1 );
     521
     522                $this->assertTrue( wp_cache_replace( $key, $value2 ) );
     523                // test value
     524                $this->assertEquals( $value2, wp_cache_get( $key ) );
     525
     526                // group:
     527                wp_cache_set( $key, $value1, 'my_group' );
     528
     529                $this->assertTrue( wp_cache_replace( $key, $value2, 'my_group' ) );
     530                $this->assertEquals( $value2, wp_cache_get( $key, 'my_group' ) );
     531        }
     532
     533        function test_increase() {
     534                $key = rand_str();
     535
     536                // non existent key check
     537                $this->assertFalse( wp_cache_incr( 'incr_non_existent' ) );
     538
     539                // adding default (1)
     540                wp_cache_set( $key, 9 );
     541                $this->assertEquals( 10, wp_cache_incr( $key ) );
     542
     543                // adding 0
     544                wp_cache_set( $key, 3 );
     545                $this->assertEquals( 3, wp_cache_incr( $key, 0 ) );
     546
     547                // adding 1
     548                wp_cache_set( $key, 7 );
     549                $this->assertEquals( 8, wp_cache_incr( $key, 1 ) );
     550
     551                // adding 3
     552                wp_cache_set( $key, 5 );
     553                $this->assertEquals( 8, wp_cache_incr( $key, 3 ) );
     554
     555                // result in negative number -> 0
     556                wp_cache_set( $key, - 5 );
     557                $this->assertEquals( 0, wp_cache_incr( $key ) );
     558
     559                /**
     560                 * Should negative increment be possible / allowed?
     561                 * Memcache allows for negative increment (not negative decrement)
     562                 */
     563                // negative increment
     564                wp_cache_set( $key, 4 );
     565                $this->assertEquals( 2, wp_cache_incr( $key, - 2 ) );
     566
     567                // negative increment below zero
     568                wp_cache_set( $key, 4 );
     569                $this->assertEquals( 0, wp_cache_incr( $key, - 6 ) );
     570
     571                // adding string
     572                wp_cache_set( $key, 3 );
     573                $this->assertEquals( 53, wp_cache_incr( $key, '50' ) );
     574
     575                // adding non-numeric string
     576                wp_cache_set( $key, 4 );
     577                $this->assertEquals( 4, wp_cache_incr( $key, 'aaa' ) );
     578
     579                // adding array with entry
     580                wp_cache_set( $key, 2 );
     581                $this->assertEquals( 2, wp_cache_incr( $key, array('') ) );
     582
     583
     584                // group:
     585                wp_cache_set( $key, 8, 'incr_group' );
     586                $this->assertEquals( 9, wp_cache_incr( $key, 1, 'incr_group' ) );
     587        }
     588
     589        function test_decrease() {
     590                $key = rand_str();
     591
     592                // non existent key check
     593                $this->assertFalse( wp_cache_decr( 'decr_non_existent' ) );
     594
     595                // default (1)
     596                wp_cache_set( $key, 10 );
     597                $this->assertEquals( 9, wp_cache_decr( $key ) );
     598
     599                // zero
     600                wp_cache_set( $key, 6 );
     601                $this->assertEquals( 6, wp_cache_decr( $key, 0 ) );
     602
     603                // one
     604                wp_cache_set( $key, 7 );
     605                $result = wp_cache_decr( $key, 1 );
     606                $this->assertEquals( $result, 6 );
     607
     608                // three
     609                wp_cache_set( $key, 15 );
     610                $this->assertEquals( 12, wp_cache_decr( $key, 3 ) );
     611
     612                // negative number
     613                wp_cache_set( $key, - 5 );
     614                $this->assertEquals( 0, wp_cache_decr( $key ) );
     615
     616                // negative decrement = increment?
     617                wp_cache_set( $key, 20 );
     618                $this->assertEquals( 22, wp_cache_decr( $key, - 2 ) );
     619
     620                // a string
     621                wp_cache_set( $key, 11 );
     622                $this->assertEquals( 6, wp_cache_decr( $key, '5' ) );
     623
     624                // adding non-numeric string
     625                wp_cache_set( $key, 4 );
     626                $this->assertEquals( 4, wp_cache_decr( $key, 'aaa' ) );
     627
     628                // adding array with entry
     629                wp_cache_set( $key, 2 );
     630                $this->assertEquals( 2, wp_cache_decr( $key, array('') ) );
     631
     632                // grouped
     633                wp_cache_set( $key, 5, 'my_group' );
     634                $this->assertEquals( 4, wp_cache_decr( $key, 1, 'my_group' ) );
     635        }
     636
     637        function test_flush() {
     638                $key1 = rand_str();
     639                $key2 = rand_str();
     640
     641                wp_cache_set( $key1, 'data1' );
     642                wp_cache_set( $key2, 'data2' );
     643
     644                $this->assertEquals( 'data1', wp_cache_get($key1) );
     645                $this->assertEquals( 'data2', wp_cache_get($key2) );
     646
     647                // add
     648                // add
     649                wp_cache_flush();
     650
     651                $this->assertFalse( wp_cache_get( $key1 ) );
     652                $this->assertFalse( wp_cache_get( $key2 ) );
     653        }
     654
     655        // test switching blogs
     656        function test_switch_blog() {
     657                $key  = rand_str();
     658                $val  = rand_str();
     659                $val2 = rand_str();
     660
     661                if ( ! is_multisite() ) {
     662                        // Single site ignores switch_to_blog()
     663                        $this->assertTrue( wp_cache_set( $key, $val ) );
     664                        $this->assertEquals( $val, wp_cache_get( $key ) );
     665
     666                        wp_cache_switch_to_blog( 999 );
     667                        $this->assertEquals( $val, wp_cache_get( $key ) );
     668                        $this->assertTrue( wp_cache_set( $key, $val2 ) );
     669                        $this->assertEquals( $val2, wp_cache_get( $key ) );
     670
     671                        wp_cache_switch_to_blog( get_current_blog_id() );
     672                        $this->assertEquals( $val2, wp_cache_get( $key ) );
     673                } else {
     674                        // Multisite should have separate per-blog caches
     675                        $this->assertTrue( wp_cache_set( $key, $val ) );
     676                        $this->assertEquals( $val, wp_cache_get( $key ) );
     677
     678                        wp_cache_switch_to_blog( 999 );
     679                        $this->assertFalse( wp_cache_get( $key ) );
     680                        $this->assertTrue( wp_cache_set( $key, $val2 ) );
     681                        $this->assertEquals( $val2, wp_cache_get( $key ) );
     682
     683                        wp_cache_switch_to_blog( get_current_blog_id() );
     684                        $this->assertEquals( $val, wp_cache_get( $key ) );
     685
     686                        wp_cache_switch_to_blog( 999 );
     687                        $this->assertEquals( $val2, wp_cache_get( $key ) );
     688
     689                        wp_cache_switch_to_blog( get_current_blog_id() );
     690                        $this->assertEquals( $val, wp_cache_get( $key ) );
     691                }
     692        }
     693
     694        // Make sure objects are cloned going to and from the cache
     695        function test_object_references() {
     696
     697                // run it twice with different keys and similar objects
     698                $keys = array(rand_str(), rand_str());
     699
     700                foreach ($keys as $key) {
     701                        $object_a      = new stdClass;
     702                        $object_a->foo = 'alpha';
     703                        wp_cache_set( $key, $object_a );
     704
     705                        // change property of original object
     706                        $object_a->foo = 'bravo';
     707
     708                        // check cached object for old value
     709                        $object_b = wp_cache_get( $key );
     710                        $this->assertEquals( 'alpha', $object_b->foo );
     711
     712                        // change retrieved object property
     713                        $object_b->foo = 'charlie';
     714
     715                        // make sure original property is expected value
     716                        $this->assertEquals( 'bravo', $object_a->foo );
     717                }
     718        }
     719
     720    // Keys in global groups should be preserved when switching blogs
     721        function test_global_group() {
     722                $key  = rand_str();
     723                $val  = rand_str();
     724                $val2 = rand_str();
     725
     726                // in multisite only
     727                if ( is_multisite() ) {
     728                        wp_cache_add_global_groups( 'global-cache-test' );
     729
     730                        // Global group
     731                        wp_cache_set( $key, $val, 'global-cache-test' );
     732                        $this->assertEquals( $val, wp_cache_get( $key, 'global-cache-test' ) );
     733
     734                        wp_cache_set( $key, $val, 'not-global' );
     735                        $this->assertEquals( $val, wp_cache_get( $key, 'not-global' ) );
     736
     737                        wp_cache_switch_to_blog( 999 );
     738                        $this->assertEquals( $val, wp_cache_get( $key, 'global-cache-test' ) );
     739                        wp_cache_set( $key, $val2, 'global-cache-test' );
     740                        $this->assertEquals( $val2, wp_cache_get( $key, 'global-cache-test' ) );
     741
     742                        // value should not be retrieved, because the group is not global
     743                        $this->assertFalse( wp_cache_get( $key, 'not-global' ) );
     744
     745                        wp_cache_switch_to_blog( get_current_blog_id() );
     746                        $this->assertEquals( $val2, wp_cache_get( $key, 'global-cache-test' ) );
     747
     748                        // the value should be back again
     749                        $this->assertEquals( $val, wp_cache_get( $key, 'not-global' ) );
     750                }
     751        }
     752}
  • tests/phpunit/tests/cache.php

     
    1 <?php
    2 
    3 /**
    4  * @group cache
    5  */
    6 class Tests_Cache extends WP_UnitTestCase {
    7         var $cache = NULL;
    8 
    9         function setUp() {
    10                 parent::setUp();
    11                 // create two cache objects with a shared cache dir
    12                 // this simulates a typical cache situation, two separate requests interacting
    13                 $this->cache =& $this->init_cache();
    14         }
    15 
    16         function tearDown() {
    17                 $this->flush_cache();
    18                 parent::tearDown();
    19         }
    20 
    21         function &init_cache() {
    22                 $cache = new WP_Object_Cache();
    23                 $cache->add_global_groups( array( 'global-cache-test', 'users', 'userlogins', 'usermeta', 'user_meta', 'site-transient', 'site-options', 'site-lookup', 'blog-lookup', 'blog-details', 'rss', 'global-posts', 'blog-id-cache' ) );
    24                 return $cache;
    25         }
    26 
    27         function test_miss() {
    28                 $this->assertEquals(NULL, $this->cache->get(rand_str()));
    29         }
    30 
    31         function test_add_get() {
    32                 $key = rand_str();
    33                 $val = rand_str();
    34 
    35                 $this->cache->add($key, $val);
    36                 $this->assertEquals($val, $this->cache->get($key));
    37         }
    38 
    39         function test_add_get_0() {
    40                 $key = rand_str();
    41                 $val = 0;
    42 
    43                 // you can store zero in the cache
    44                 $this->cache->add($key, $val);
    45                 $this->assertEquals($val, $this->cache->get($key));
    46         }
    47 
    48         function test_add_get_null() {
    49                 $key = rand_str();
    50                 $val = null;
    51 
    52                 $this->assertTrue( $this->cache->add($key, $val) );
    53                 // null is converted to empty string
    54                 $this->assertEquals( '', $this->cache->get($key) );
    55         }
    56 
    57         function test_add() {
    58                 $key = rand_str();
    59                 $val1 = rand_str();
    60                 $val2 = rand_str();
    61 
    62                 // add $key to the cache
    63                 $this->assertTrue($this->cache->add($key, $val1));
    64                 $this->assertEquals($val1, $this->cache->get($key));
    65                 // $key is in the cache, so reject new calls to add()
    66                 $this->assertFalse($this->cache->add($key, $val2));
    67                 $this->assertEquals($val1, $this->cache->get($key));
    68         }
    69 
    70         function test_replace() {
    71                 $key = rand_str();
    72                 $val = rand_str();
    73                 $val2 = rand_str();
    74 
    75                 // memcached rejects replace() if the key does not exist
    76                 $this->assertFalse($this->cache->replace($key, $val));
    77                 $this->assertFalse($this->cache->get($key));
    78                 $this->assertTrue($this->cache->add($key, $val));
    79                 $this->assertEquals($val, $this->cache->get($key));
    80                 $this->assertTrue($this->cache->replace($key, $val2));
    81                 $this->assertEquals($val2, $this->cache->get($key));
    82         }
    83 
    84         function test_set() {
    85                 $key = rand_str();
    86                 $val1 = rand_str();
    87                 $val2 = rand_str();
    88 
    89                 // memcached accepts set() if the key does not exist
    90                 $this->assertTrue($this->cache->set($key, $val1));
    91                 $this->assertEquals($val1, $this->cache->get($key));
    92                 // Second set() with same key should be allowed
    93                 $this->assertTrue($this->cache->set($key, $val2));
    94                 $this->assertEquals($val2, $this->cache->get($key));
    95         }
    96 
    97         function test_flush() {
    98                 global $_wp_using_ext_object_cache;
    99 
    100                 if ( $_wp_using_ext_object_cache )
    101                         return;
    102 
    103                 $key = rand_str();
    104                 $val = rand_str();
    105 
    106                 $this->cache->add($key, $val);
    107                 // item is visible to both cache objects
    108                 $this->assertEquals($val, $this->cache->get($key));
    109                 $this->cache->flush();
    110                 // If there is no value get returns false.
    111                 $this->assertFalse($this->cache->get($key));
    112         }
    113 
    114         // Make sure objects are cloned going to and from the cache
    115         function test_object_refs() {
    116                 $key = rand_str();
    117                 $object_a = new stdClass;
    118                 $object_a->foo = 'alpha';
    119                 $this->cache->set( $key, $object_a );
    120                 $object_a->foo = 'bravo';
    121                 $object_b = $this->cache->get( $key );
    122                 $this->assertEquals( 'alpha', $object_b->foo );
    123                 $object_b->foo = 'charlie';
    124                 $this->assertEquals( 'bravo', $object_a->foo );
    125 
    126                 $key = rand_str();
    127                 $object_a = new stdClass;
    128                 $object_a->foo = 'alpha';
    129                 $this->cache->add( $key, $object_a );
    130                 $object_a->foo = 'bravo';
    131                 $object_b = $this->cache->get( $key );
    132                 $this->assertEquals( 'alpha', $object_b->foo );
    133                 $object_b->foo = 'charlie';
    134                 $this->assertEquals( 'bravo', $object_a->foo );
    135         }
    136 
    137         function test_incr() {
    138                 $key = rand_str();
    139 
    140                 $this->assertFalse( $this->cache->incr( $key ) );
    141 
    142                 $this->cache->set( $key, 0 );
    143                 $this->cache->incr( $key );
    144                 $this->assertEquals( 1, $this->cache->get( $key ) );
    145 
    146                 $this->cache->incr( $key, 2 );
    147                 $this->assertEquals( 3, $this->cache->get( $key ) );
    148         }
    149 
    150         function test_wp_cache_incr() {
    151                 $key = rand_str();
    152 
    153                 $this->assertFalse( wp_cache_incr( $key ) );
    154 
    155                 wp_cache_set( $key, 0 );
    156                 wp_cache_incr( $key );
    157                 $this->assertEquals( 1, wp_cache_get( $key ) );
    158 
    159                 wp_cache_incr( $key, 2 );
    160                 $this->assertEquals( 3, wp_cache_get( $key ) );
    161         }
    162 
    163         function test_decr() {
    164                 $key = rand_str();
    165 
    166                 $this->assertFalse( $this->cache->decr( $key ) );
    167 
    168                 $this->cache->set( $key, 0 );
    169                 $this->cache->decr( $key );
    170                 $this->assertEquals( 0, $this->cache->get( $key ) );
    171 
    172                 $this->cache->set( $key, 3 );
    173                 $this->cache->decr( $key );
    174                 $this->assertEquals( 2, $this->cache->get( $key ) );
    175 
    176                 $this->cache->decr( $key, 2 );
    177                 $this->assertEquals( 0, $this->cache->get( $key ) );
    178         }
    179 
    180         /**
    181          * @group 21327
    182          */
    183         function test_wp_cache_decr() {
    184                 $key = rand_str();
    185 
    186                 $this->assertFalse( wp_cache_decr( $key ) );
    187 
    188                 wp_cache_set( $key, 0 );
    189                 wp_cache_decr( $key );
    190                 $this->assertEquals( 0, wp_cache_get( $key ) );
    191 
    192                 wp_cache_set( $key, 3 );
    193                 wp_cache_decr( $key );
    194                 $this->assertEquals( 2, wp_cache_get( $key ) );
    195 
    196                 wp_cache_decr( $key, 2 );
    197                 $this->assertEquals( 0, wp_cache_get( $key ) );
    198         }
    199 
    200         function test_delete() {
    201                 $key = rand_str();
    202                 $val = rand_str();
    203 
    204                 // Verify set
    205                 $this->assertTrue( $this->cache->set( $key, $val ) );
    206                 $this->assertEquals( $val, $this->cache->get( $key ) );
    207 
    208                 // Verify successful delete
    209                 $this->assertTrue( $this->cache->delete( $key ) );
    210                 $this->assertFalse( $this->cache->get( $key ) );
    211 
    212                 $this->assertFalse( $this->cache->delete( $key, 'default') );
    213         }
    214 
    215         function test_wp_cache_delete() {
    216                 $key = rand_str();
    217                 $val = rand_str();
    218 
    219                 // Verify set
    220                 $this->assertTrue( wp_cache_set( $key, $val ) );
    221                 $this->assertEquals( $val, wp_cache_get( $key ) );
    222 
    223                 // Verify successful delete
    224                 $this->assertTrue( wp_cache_delete( $key ) );
    225                 $this->assertFalse( wp_cache_get( $key ) );
    226 
    227                 // wp_cache_delete() does not have a $force method.
    228                 // Delete returns (bool) true when key is not set and $force is true
    229                 // $this->assertTrue( wp_cache_delete( $key, 'default', true ) );
    230 
    231                 $this->assertFalse( wp_cache_delete( $key, 'default') );
    232         }
    233 
    234         function test_switch_to_blog() {
    235                 if ( ! method_exists( $this->cache, 'switch_to_blog' ) )
    236                         return;
    237 
    238                 $key = rand_str();
    239                 $val = rand_str();
    240                 $val2 = rand_str();
    241 
    242                 if ( ! is_multisite() ) {
    243                         // Single site ingnores switch_to_blog().
    244                         $this->assertTrue( $this->cache->set( $key, $val ) );
    245                         $this->assertEquals( $val, $this->cache->get( $key ) );
    246                         $this->cache->switch_to_blog( 999 );
    247                         $this->assertEquals( $val, $this->cache->get( $key ) );
    248                         $this->assertTrue( $this->cache->set( $key, $val2 ) );
    249                         $this->assertEquals( $val2, $this->cache->get( $key ) );
    250                         $this->cache->switch_to_blog( get_current_blog_id() );
    251                         $this->assertEquals( $val2, $this->cache->get( $key ) );
    252                 } else {
    253                         // Multisite should have separate per-blog caches
    254                         $this->assertTrue( $this->cache->set( $key, $val ) );
    255                         $this->assertEquals( $val, $this->cache->get( $key ) );
    256                         $this->cache->switch_to_blog( 999 );
    257                         $this->assertFalse( $this->cache->get( $key ) );
    258                         $this->assertTrue( $this->cache->set( $key, $val2 ) );
    259                         $this->assertEquals( $val2, $this->cache->get( $key ) );
    260                         $this->cache->switch_to_blog( get_current_blog_id() );
    261                         $this->assertEquals( $val, $this->cache->get( $key ) );
    262                         $this->cache->switch_to_blog( 999 );
    263                         $this->assertEquals( $val2, $this->cache->get( $key ) );
    264                         $this->cache->switch_to_blog( get_current_blog_id() );
    265                         $this->assertEquals( $val, $this->cache->get( $key ) );
    266                 }
    267 
    268                 // Global group
    269                 $this->assertTrue( $this->cache->set( $key, $val, 'global-cache-test' ) );
    270                 $this->assertEquals( $val, $this->cache->get( $key, 'global-cache-test' ) );
    271                 $this->cache->switch_to_blog( 999 );
    272                 $this->assertEquals( $val, $this->cache->get( $key, 'global-cache-test' ) );
    273                 $this->assertTrue( $this->cache->set( $key, $val2, 'global-cache-test' ) );
    274                 $this->assertEquals( $val2, $this->cache->get( $key, 'global-cache-test' ) );
    275                 $this->cache->switch_to_blog( get_current_blog_id() );
    276                 $this->assertEquals( $val2, $this->cache->get( $key, 'global-cache-test' ) );
    277         }
    278 
    279         function test_wp_cache_init() {
    280                 $new_blank_cache_object = new WP_Object_Cache();
    281                 wp_cache_init();
    282 
    283                 global $wp_object_cache;
    284                 $this->assertEquals( $wp_object_cache, $new_blank_cache_object );
    285         }
    286 
    287         function test_wp_cache_replace() {
    288                 $key  = 'my-key';
    289                 $val1 = 'first-val';
    290                 $val2 = 'second-val';
    291 
    292                 $fake_key = 'my-fake-key';
    293 
    294                 // Save the first value to cache and verify
    295                 wp_cache_set( $key, $val1 );
    296                 $this->assertEquals( $val1, wp_cache_get( $key ) );
    297 
    298                 // Replace the value and verify
    299                 wp_cache_replace( $key, $val2 );
    300                 $this->assertEquals( $val2, wp_cache_get( $key ) );
    301 
    302                 // Non-existant key should fail
    303                 $this->assertFalse( wp_cache_replace( $fake_key, $val1 ) );
    304 
    305                 // Make sure $fake_key is not stored
    306                 $this->assertFalse( wp_cache_get( $fake_key ) );
    307         }
    308 }