Changeset 63958 for trunk/tests/phpunit/tests/meta.php

Timestamp:

09/28/2026 01:56:38 AM (18 hours ago)

Author:

peterwilsoncc

Message:

Options, Meta APIs: Ensure meta cache is an array before use.

In get_metadata_raw() and metadata_exists() ensure that cached data is of a valid form (ie, an array) before use. This prevents PHP errors of a third party has set the cache directly using a non array value.

Each of these functions now treat invalid cache forms as a cache miss. Invalid cache entries are deleted in update_meta_cache() if they are not an array.

Props josephscott, jonsurrell, westonruter.
Fixes #66091.

File:

• trunk/tests/phpunit/tests/meta.php (modified) (1 diff)

trunk/tests/phpunit/tests/meta.php

@@ -130 +130 @@
                 $this->assertFalse( metadata_exists( 'user', 1234567890, 'meta_key' ) );
                 remove_filter( 'get_user_metadata', '__return_zero' );
+        }
+
+        /**
+         * Non-array values that can not be used as a meta cache entry.
+         *
+         * @return array<string, array{mixed}>
+         */
+        public static function data_non_array_cache_values(): array {
+                return array(
+                        'object'  => array( new stdClass() ),
+                        'string'  => array( 'meta_value' ),
+                        'integer' => array( 1 ),
+                        'float'   => array( 1.5 ),
+                        'true'    => array( true ),
+                );
+        }
+
+        /**
+         * @ticket 66091
+         *
+         * @dataProvider data_non_array_cache_values
+         *
+         * @param mixed $invalid_cached_value Unusable value to place in the meta cache.
+         */
+        public function test_metadata_exists_treats_non_array_cache_value_as_miss( $invalid_cached_value ): void {
+                $this->assertTrue( wp_cache_set( self::$author->ID, $invalid_cached_value, 'user_meta' ), 'The unusable value should be placed in the cache, check test setup.' );
+
+                $this->assertTrue( metadata_exists( 'user', self::$author->ID, 'meta_key' ), 'An existing meta key should be reported as existing.' );
+                $this->assertFalse( metadata_exists( 'user', self::$author->ID, 'foobarbaz' ), 'A missing meta key should be reported as not existing.' );
+                $this->assertIsArray( wp_cache_get( self::$author->ID, 'user_meta' ), 'The unusable cache value should have been replaced.' );
+        }
+
+        /**
+         * @ticket 66091
+         *
+         * @dataProvider data_non_array_cache_values
+         *
+         * @param mixed $invalid_cached_value Unusable value to place in the meta cache.
+         */
+        public function test_get_metadata_treats_non_array_cache_value_as_miss( $invalid_cached_value ): void {
+                $this->assertTrue( wp_cache_set( self::$author->ID, $invalid_cached_value, 'user_meta' ), 'The unusable value should be placed in the cache, check test setup.' );
+
+                $this->assertSame( 'meta_value', get_metadata( 'user', self::$author->ID, 'meta_key', true ), 'The single meta value should be returned.' );
+                $this->assertSame( array( 'meta_value' ), get_metadata( 'user', self::$author->ID, 'meta_key' ), 'The array of meta values should be returned.' );
+                $this->assertIsArray( wp_cache_get( self::$author->ID, 'user_meta' ), 'The unusable cache value should have been replaced.' );
+        }
+
+        /**
+         * @ticket 66091
+         *
+         * @dataProvider data_non_array_cache_values
+         *
+         * @param mixed $invalid_cached_value Unusable value to place in the meta cache.
+         */
+        public function test_get_metadata_with_empty_key_treats_non_array_cache_value_as_miss( $invalid_cached_value ): void {
+                $this->assertTrue( wp_cache_set( self::$author->ID, $invalid_cached_value, 'user_meta' ), 'The unusable value should be placed in the cache, check test setup.' );
+
+                $meta = get_metadata( 'user', self::$author->ID );
+
+                $this->assertIsArray( $meta, 'All meta for the object should be returned as an array.' );
+                $this->assertSame( array( 'meta_value' ), $meta['meta_key'], 'The existing meta key should be included in the returned meta.' );
+        }
+
+        /**
+         * @ticket 66091
+         *
+         * @dataProvider data_non_array_cache_values
+         *
+         * @param mixed $invalid_cached_value Unusable value to place in the meta cache.
+         */
+        public function test_update_meta_cache_replaces_non_array_cache_value( $invalid_cached_value ): void {
+                $this->assertTrue( wp_cache_set( self::$author->ID, $invalid_cached_value, 'user_meta' ), 'The unusable value should be placed in the cache, check test setup.' );
+
+                $meta_cache = update_meta_cache( 'user', array( self::$author->ID ) );
+
+                $this->assertIsArray( $meta_cache );
+                $this->assertArrayHasKey( self::$author->ID, $meta_cache );
+                $this->assertIsArray( $meta_cache[ self::$author->ID ], 'The returned meta cache for the object should be an array.' );
+                $this->assertSame( array( 'meta_value' ), $meta_cache[ self::$author->ID ]['meta_key'], 'The returned meta cache should include the existing meta key.' );
+
+                $cached = wp_cache_get( self::$author->ID, 'user_meta' );
+                $this->assertIsArray( $cached, 'The unusable cache value should have been replaced.' );
+                $this->assertSame( array( 'meta_value' ), $cached['meta_key'], 'The replaced cache value should include the existing meta key.' );
+        }
+
+        /**
+         * @ticket 66091
+         */
+        public function test_update_meta_cache_replaces_non_array_cache_value_for_object_without_meta(): void {
+                $term_id = self::factory()->term->create();
+
+                $this->assertTrue( wp_cache_set( $term_id, new stdClass(), 'term_meta' ), 'The unusable value should be placed in the cache, check test setup.' );
+
+                $meta_cache = update_meta_cache( 'term', array( $term_id ) );
+                $this->assertIsArray( $meta_cache );
+                $this->assertArrayHasKey( $term_id, $meta_cache );
+
+                $this->assertSame( array(), $meta_cache[ $term_id ], 'The returned meta cache for an object without meta should be an empty array.' );
+                $this->assertSame( array(), wp_cache_get( $term_id, 'term_meta' ), 'The unusable cache value should have been replaced with an empty array.' );
+        }
+
+        /**
+         * @ticket 66091
+         */
+        public function test_update_meta_cache_removes_non_array_cache_value_while_cache_addition_is_suspended(): void {
+                $this->assertTrue( wp_cache_set( self::$author->ID, new stdClass(), 'user_meta' ), 'The unusable value should be placed in the cache, check test setup.' );
+
+                wp_suspend_cache_addition( true );
+                $meta_cache = update_meta_cache( 'user', array( self::$author->ID ) );
+                wp_suspend_cache_addition( false );
+                $this->assertIsArray( $meta_cache );
+                $this->assertIsArray( $meta_cache[ self::$author->ID ] );
+
+                $this->assertSame( array( 'meta_value' ), $meta_cache[ self::$author->ID ]['meta_key'], 'The meta should still be returned while cache addition is suspended.' );
+                $this->assertFalse( wp_cache_get( self::$author->ID, 'user_meta' ), 'The unusable cache value should be removed but not replaced while cache addition is suspended.' );
         }