Ticket #23290: 23290-phpunit.patch

tests/phpunit/tests/multisite/wpCacheSwitchToBlog.php

@@ +1 @@
+<?php
+
+/**
+ * Tests for the wp_cache_switch_to_blog() function.
+ *
+ * @group ms-required
+ * @group ms-site
+ * @group multisite
+ * @group cache
+ *
+ * @covers ::wp_cache_switch_to_blog
+ */
+class Tests_Multisite_WpCacheSwitchToBlogFallback extends WP_UnitTestCase {
+
+        /**
+         * Store the original WP_Object_Cache instance.
+         *
+         * @var WP_Object_Cache
+         */
+        private $original_wp_object_cache;
+
+        /**
+         * Set up before each test.
+         */
+        public function set_up() {
+                global $wp_object_cache;
+
+                parent::set_up();
+
+                // Store the original cache object to restore later.
+                $this->original_wp_object_cache = $wp_object_cache;
+        }
+
+        /**
+         * Tear down after each test.
+         */
+        public function tear_down() {
+                global $wp_object_cache;
+
+                // Restore the original cache object.
+                $wp_object_cache = $this->original_wp_object_cache;
+
+                parent::tear_down();
+        }
+
+        /**
+         * Helper method to add custom global groups for testing.
+         *
+         * @param array $groups Group names to add.
+         */
+        private function add_test_global_groups( $groups ) {
+                wp_cache_add_global_groups( $groups );
+        }
+
+        /**
+         * Test that wp_cache_switch_to_blog() reinitializes the cache.
+         *
+         * @ticket 23290
+         * @covers ::wp_cache_switch_to_blog
+         */
+        public function test_reinitializes_cache() {
+
+                // Set some cache data before switching.
+                wp_cache_set( 'test_key', 'test_value', 'test_group' );
+                $this->assertSame( 'test_value', wp_cache_get( 'test_key', 'test_group' ) );
+
+                // Call the fallback function.
+                wp_cache_switch_to_blog();
+
+                // Verify the cache has been reinitialized (non-global groups should be cleared).
+                $this->assertFalse( wp_cache_get( 'test_key', 'test_group' ) );
+        }
+
+        /**
+         * Test that wp_cache_switch_to_blog() preserves global group configuration.
+         *
+         * The fallback clears all cache data (including global groups) because it calls
+         * wp_cache_init(). However, it restores the global groups configuration afterward.
+         *
+         * @ticket 23290
+         * @covers ::wp_cache_switch_to_blog
+         */
+        public function test_preserves_global_groups_configuration() {
+                global $wp_object_cache;
+
+                // Call the fallback function.
+                wp_cache_switch_to_blog();
+
+                // Verify global groups configuration is preserved after fallback.
+                $this->assertNotEmpty( $wp_object_cache->global_groups );
+                $this->assertArrayHasKey( 'users', $wp_object_cache->global_groups );
+                $this->assertArrayHasKey( 'user_meta', $wp_object_cache->global_groups );
+                $this->assertArrayHasKey( 'site-options', $wp_object_cache->global_groups );
+        }
+
+        /**
+         * Test that wp_cache_switch_to_blog() restores global groups from cache object.
+         *
+         * When the cache object exists with global_groups configuration, the fallback should
+         * preserve that configuration rather than discarding it.
+         *
+         * @ticket 23290
+         * @covers ::wp_cache_switch_to_blog
+         */
+        public function test_restores_global_groups_from_cache_object() {
+                global $wp_object_cache;
+
+                // Verify the global_groups property exists.
+                $this->assertObjectHasProperty( 'global_groups', $wp_object_cache );
+
+                // Store the count of original global groups for comparison.
+                $original_count = count( $wp_object_cache->global_groups );
+
+                // Call the fallback function.
+                wp_cache_switch_to_blog();
+
+                // Verify global groups are restored (same number of groups).
+                $this->assertGreaterThan( 0, count( $wp_object_cache->global_groups ) );
+                $this->assertSame( $original_count, count( $wp_object_cache->global_groups ) );
+
+                // Verify key global groups are still present.
+                $this->assertArrayHasKey( 'users', $wp_object_cache->global_groups );
+                $this->assertArrayHasKey( 'user_meta', $wp_object_cache->global_groups );
+                $this->assertArrayHasKey( 'site-options', $wp_object_cache->global_groups );
+        }
+
+        /**
+         * Test that wp_cache_switch_to_blog() uses default global groups when unavailable.
+         *
+         * When the cache object doesn't have a global_groups property, the fallback
+         * should provide the WordPress default global groups rather than failing.
+         *
+         * @ticket 23290
+         * @covers ::wp_cache_switch_to_blog
+         */
+        public function test_uses_default_global_groups_when_unavailable() {
+                global $wp_object_cache;
+
+                // Create a mock cache object without global_groups.
+                $mock_cache = new stdClass();
+
+                // Temporarily replace the global cache.
+                $wp_object_cache = $mock_cache;
+
+                // Call the fallback function.
+                wp_cache_switch_to_blog();
+
+                // Verify a new cache object was created and global groups are set.
+                $this->assertInstanceOf( 'WP_Object_Cache', $wp_object_cache );
+                $this->assertObjectHasProperty( 'global_groups', $wp_object_cache );
+
+                // Verify default global groups are present.
+                $expected_groups = array(
+                        'blog-details',
+                        'blog-id-cache',
+                        'blog-lookup',
+                        'blog_meta',
+                        'global-posts',
+                        'image_editor',
+                        'networks',
+                        'network-queries',
+                        'sites',
+                        'site-details',
+                        'site-options',
+                        'site-queries',
+                        'site-transient',
+                        'theme_files',
+                        'translation_files',
+                        'rss',
+                        'users',
+                        'user-queries',
+                        'user_meta',
+                        'useremail',
+                        'userlogins',
+                        'userslugs',
+                );
+
+                foreach ( $expected_groups as $group ) {
+                        $this->assertContains( $group, array_keys( $wp_object_cache->global_groups ) );
+                }
+        }
+
+        /**
+         * Test that wp_cache_switch_to_blog() preserves non-persistent groups from cache.
+         *
+         * @ticket 23290
+         * @covers ::wp_cache_switch_to_blog
+         */
+        public function test_preserves_non_persistent_groups_from_cache_object() {
+                global $wp_object_cache;
+
+                // Verify we have access to the cache structure.
+                $this->assertObjectHasProperty( 'cache', $wp_object_cache );
+                $this->assertObjectHasProperty( 'global_groups', $wp_object_cache );
+
+                // Add some data to non-persistent groups.
+                wp_cache_set( 'count_key', 42, 'counts' );
+                wp_cache_set( 'plugin_key', 'plugin_data', 'plugins' );
+
+                // Call the fallback function.
+                wp_cache_switch_to_blog();
+
+                // Verify non-persistent groups are re-added.
+                $this->assertInstanceOf( 'WP_Object_Cache', $wp_object_cache );
+
+                // The actual values won't persist (as they're non-persistent), but the group structure should be maintained.
+                // We can't directly test the internal structure, but we can verify the function completes without error.
+                $this->assertTrue( true );
+        }
+
+        /**
+         * Test that wp_cache_switch_to_blog() uses default non-persistent groups when unavailable.
+         *
+         * @ticket 23290
+         * @covers ::wp_cache_switch_to_blog
+         */
+        public function test_uses_default_non_persistent_groups_when_unavailable() {
+                global $wp_object_cache;
+
+                // Create a minimal mock cache object.
+                $mock_cache = new stdClass();
+
+                // Temporarily replace the global cache.
+                $wp_object_cache = $mock_cache;
+
+                // Call the fallback function.
+                wp_cache_switch_to_blog();
+
+                // Verify a new cache object was created.
+                $this->assertInstanceOf( 'WP_Object_Cache', $wp_object_cache );
+
+                // The default non-persistent groups should be set up.
+                // We test this indirectly by verifying the cache works for these groups.
+                wp_cache_set( 'test_count', 123, 'counts' );
+                $this->assertSame( 123, wp_cache_get( 'test_count', 'counts' ) );
+
+                wp_cache_set( 'test_plugin', 'data', 'plugins' );
+                $this->assertSame( 'data', wp_cache_get( 'test_plugin', 'plugins' ) );
+
+                wp_cache_set( 'test_theme_json', 'theme_data', 'theme_json' );
+                $this->assertSame( 'theme_data', wp_cache_get( 'test_theme_json', 'theme_json' ) );
+        }
+
+        /**
+         * Test fallback integration with switch_to_blog().
+         *
+         * Verifies the fallback path in switch_to_blog() works correctly
+         * when the persistent cache drop-in lacks wp_cache_switch_to_blog().
+         *
+         * @ticket 23290
+         * @covers ::wp_cache_switch_to_blog
+         */
+        public function test_fallback_integration_with_switch_to_blog() {
+
+                self::factory()->blog->create();
+
+                // Set cache data in a non-global group.
+                wp_cache_set( 'test_local', 'local_value', 'posts' );
+
+                // Verify it's set.
+                $this->assertSame( 'local_value', wp_cache_get( 'test_local', 'posts' ) );
+
+                // Call the fallback function.
+                wp_cache_switch_to_blog();
+
+                // Non-global groups should be cleared.
+                $this->assertFalse( wp_cache_get( 'test_local', 'posts' ) );
+
+                // Verify the cache is still functional.
+                wp_cache_set( 'test_new', 'new_value', 'posts' );
+                $this->assertSame( 'new_value', wp_cache_get( 'test_new', 'posts' ) );
+        }
+
+        /**
+         * Test that wp_cache_switch_to_blog() handles empty cache gracefully.
+         *
+         * @ticket 23290
+         * @covers ::wp_cache_switch_to_blog
+         */
+        public function test_handles_empty_cache_gracefully() {
+                global $wp_object_cache;
+
+                // Call wp_cache_init() first to ensure we have a fresh cache.
+                wp_cache_init();
+
+                // Call the fallback function on an empty cache.
+                wp_cache_switch_to_blog();
+
+                // Verify the cache is functional after the call.
+                $this->assertInstanceOf( 'WP_Object_Cache', $wp_object_cache );
+
+                // Test that we can set and get values.
+                wp_cache_set( 'test_after_init', 'test_value', 'default' );
+                $this->assertSame( 'test_value', wp_cache_get( 'test_after_init', 'default' ) );
+        }
+
+        /**
+         * Test that custom global groups configuration is preserved during fallback.
+         *
+         * @ticket 23290
+         */
+        public function test_custom_global_groups_configuration_is_preserved() {
+                global $wp_object_cache;
+
+                // Add a custom global group.
+                wp_cache_add_global_groups( array( 'custom_global_group' ) );
+
+                // Verify it was added.
+                $this->assertArrayHasKey( 'custom_global_group', $wp_object_cache->global_groups );
+
+                // Call the fallback function.
+                wp_cache_switch_to_blog();
+
+                // Verify the custom global group configuration is still present.
+                $this->assertArrayHasKey( 'custom_global_group', $wp_object_cache->global_groups );
+
+                // Verify we can use the custom global group after fallback.
+                wp_cache_set( 'test_key', 'test_value', 'custom_global_group' );
+                $this->assertSame( 'test_value', wp_cache_get( 'test_key', 'custom_global_group' ) );
+        }
+
+        /**
+         * Test that multiple calls to wp_cache_switch_to_blog() work correctly.
+         *
+         * @ticket 23290
+         */
+        public function test_multiple_fallback_calls() {
+                global $wp_object_cache;
+
+                // Set up initial data.
+                wp_cache_set( 'local_key', 'local_value', 'posts' );
+
+                // First fallback call.
+                wp_cache_switch_to_blog();
+                $this->assertFalse( wp_cache_get( 'local_key', 'posts' ) );
+                $this->assertInstanceOf( 'WP_Object_Cache', $wp_object_cache );
+
+                // Set new data.
+                wp_cache_set( 'local_key2', 'local_value2', 'posts' );
+                $this->assertSame( 'local_value2', wp_cache_get( 'local_key2', 'posts' ) );
+
+                // Second fallback call.
+                wp_cache_switch_to_blog();
+                $this->assertFalse( wp_cache_get( 'local_key2', 'posts' ) );
+                $this->assertInstanceOf( 'WP_Object_Cache', $wp_object_cache );
+
+                // Verify global groups are still configured after multiple calls.
+                $this->assertArrayHasKey( 'users', $wp_object_cache->global_groups );
+        }
+
+        /**
+         * Test that wp_cache_switch_to_blog() maintains cache structure integrity.
+         *
+         * @ticket 23290
+         */
+        public function test_maintains_cache_structure_integrity() {
+                global $wp_object_cache;
+
+                // Store the initial properties we expect.
+                $expected_properties = array( 'cache', 'global_groups' );
+
+                // Call the fallback function.
+                wp_cache_switch_to_blog();
+
+                // Verify the cache object has the expected structure.
+                foreach ( $expected_properties as $property ) {
+                        $this->assertObjectHasProperty( $property, $wp_object_cache );
+                }
+
+                // Verify the cache object is still functional.
+                $this->assertInstanceOf( 'WP_Object_Cache', $wp_object_cache );
+        }
+
+        /**
+         * Test wp_cache_switch_to_blog() with default groups present.
+         *
+         * @ticket 23290
+         */
+        public function test_default_global_groups_are_restored() {
+                global $wp_object_cache;
+
+                // Some key global groups that should always be present.
+                $key_global_groups = array(
+                        'users',
+                        'user_meta',
+                        'site-options',
+                        'site-transient',
+                        'blog-lookup',
+                        'blog-details',
+                        'site-details',
+                );
+
+                // Call the fallback function.
+                wp_cache_switch_to_blog();
+
+                // Verify key global groups are present.
+                foreach ( $key_global_groups as $group ) {
+                        $this->assertArrayHasKey( $group, $wp_object_cache->global_groups, "Global group '{$group}' should be present after fallback." );
+                }
+
+                // Verify we have a reasonable number of global groups.
+                $this->assertGreaterThanOrEqual( count( $key_global_groups ), count( $wp_object_cache->global_groups ) );
+        }
+
+        /**
+         * Test that non-global cache data is properly cleared during fallback.
+         *
+         * @ticket 23290
+         */
+        public function test_non_global_cache_data_is_cleared() {
+
+                // Set cache data in various non-global groups.
+                wp_cache_set( 'post_key', 'post_value', 'posts' );
+                wp_cache_set( 'term_key', 'term_value', 'terms' );
+                wp_cache_set( 'option_key', 'option_value', 'options' );
+                wp_cache_set( 'default_key', 'default_value', 'default' );
+
+                // Verify data is set.
+                $this->assertSame( 'post_value', wp_cache_get( 'post_key', 'posts' ) );
+                $this->assertSame( 'term_value', wp_cache_get( 'term_key', 'terms' ) );
+                $this->assertSame( 'option_value', wp_cache_get( 'option_key', 'options' ) );
+                $this->assertSame( 'default_value', wp_cache_get( 'default_key', 'default' ) );
+
+                // Call the fallback function.
+                wp_cache_switch_to_blog();
+
+                // Verify all non-global cache data is cleared.
+                $this->assertFalse( wp_cache_get( 'post_key', 'posts' ) );
+                $this->assertFalse( wp_cache_get( 'term_key', 'terms' ) );
+                $this->assertFalse( wp_cache_get( 'option_key', 'options' ) );
+                $this->assertFalse( wp_cache_get( 'default_key', 'default' ) );
+        }
+
+        /**
+         * Test that fallback preserves many custom global groups.
+         *
+         * This tests the scenario where a plugin adds many custom global groups,
+         * ensuring they're all preserved after the fallback.
+         *
+         * @ticket 23290
+         */
+        public function test_preserves_many_custom_global_groups() {
+                global $wp_object_cache;
+
+                // Add multiple custom global groups.
+                $custom_groups = array(
+                        'my_plugin_cache',
+                        'my_other_plugin',
+                        'custom_group_1',
+                        'custom_group_2',
+                        'custom_group_3',
+                );
+
+                wp_cache_add_global_groups( $custom_groups );
+
+                // Verify they were added.
+                foreach ( $custom_groups as $group ) {
+                        $this->assertArrayHasKey( $group, $wp_object_cache->global_groups );
+                }
+
+                // Call the fallback function.
+                wp_cache_switch_to_blog();
+
+                // Verify all custom global groups are still configured.
+                foreach ( $custom_groups as $group ) {
+                        $this->assertArrayHasKey( $group, $wp_object_cache->global_groups, "Custom group '{$group}' should be preserved." );
+                }
+
+                // Verify they're functional.
+                wp_cache_set( 'test', 'value', 'my_plugin_cache' );
+                $this->assertSame( 'value', wp_cache_get( 'test', 'my_plugin_cache' ) );
+        }
+
+        /**
+         * Test that fallback handles empty global_groups array.
+         *
+         * Edge case where global_groups exists but is empty, which differs from
+         * the property not existing at all.
+         *
+         * @ticket 23290
+         * @covers ::wp_cache_switch_to_blog
+         */
+        public function test_handles_empty_global_groups_array() {
+                global $wp_object_cache;
+
+                // Create a cache object with empty global_groups.
+                $wp_object_cache->global_groups = array();
+
+                // Call the fallback function.
+                wp_cache_switch_to_blog();
+
+                // Should fall back to default global groups.
+                $this->assertNotEmpty( $wp_object_cache->global_groups );
+                $this->assertArrayHasKey( 'users', $wp_object_cache->global_groups );
+        }
+
+        /**
+         * Test preserving both global and non-persistent group configurations.
+         *
+         * This is the core issue from ticket #23290 - ensuring non-persistent groups
+         * aren't lost when using the fallback path in switch_to_blog().
+         *
+         * @ticket 23290
+         * @covers ::wp_cache_switch_to_blog
+         */
+        public function test_preserves_both_global_and_non_persistent_groups() {
+                global $wp_object_cache;
+
+                // Add a custom global group.
+                wp_cache_add_global_groups( array( 'my_global' ) );
+
+                // Add data to various groups including the non-persistent ones.
+                wp_cache_set( 'test1', 'val1', 'counts' );
+                wp_cache_set( 'test2', 'val2', 'plugins' );
+                wp_cache_set( 'test3', 'val3', 'my_global' );
+                wp_cache_set( 'test4', 'val4', 'posts' );
+
+                // Call the fallback function.
+                wp_cache_switch_to_blog();
+
+                // Global group configuration should be preserved.
+                $this->assertArrayHasKey( 'my_global', $wp_object_cache->global_groups );
+
+                // All groups should still be functional after fallback.
+                wp_cache_set( 'after1', 'afterval1', 'counts' );
+                wp_cache_set( 'after2', 'afterval2', 'plugins' );
+                wp_cache_set( 'after3', 'afterval3', 'my_global' );
+                wp_cache_set( 'after4', 'afterval4', 'posts' );
+
+                $this->assertSame( 'afterval1', wp_cache_get( 'after1', 'counts' ) );
+                $this->assertSame( 'afterval2', wp_cache_get( 'after2', 'plugins' ) );
+                $this->assertSame( 'afterval3', wp_cache_get( 'after3', 'my_global' ) );
+                $this->assertSame( 'afterval4', wp_cache_get( 'after4', 'posts' ) );
+        }
+
+        /**
+         * Test fallback in a realistic blog switching scenario.
+         *
+         * @ticket 23290
+         * @covers ::wp_cache_switch_to_blog
+         */
+        public function test_realistic_blog_switching_scenario() {
+                $blog_id_1 = get_current_blog_id();
+                $blog_id_2 = self::factory()->blog->create();
+
+                // Add custom global groups that a plugin might use.
+                wp_cache_add_global_groups( array( 'my_plugin_users', 'my_plugin_settings' ) );
+
+                // Set some cache data on blog 1.
+                wp_cache_set( 'user_1', 'user_data', 'my_plugin_users' );
+                wp_cache_set( 'post_1', 'post_data', 'posts' );
+
+                // Switch to blog 2 (this may trigger the fallback if wp_cache_switch_to_blog doesn't exist).
+                switch_to_blog( $blog_id_2 );
+
+                // The blog context has changed.
+                $this->assertSame( $blog_id_2, get_current_blog_id() );
+
+                // Set some data on blog 2.
+                wp_cache_set( 'post_2', 'post_data_2', 'posts' );
+                $this->assertSame( 'post_data_2', wp_cache_get( 'post_2', 'posts' ) );
+
+                // Switch back to blog 1.
+                restore_current_blog();
+
+                // We're back on blog 1.
+                $this->assertSame( $blog_id_1, get_current_blog_id() );
+
+                // Custom global groups should still be configured after switching.
+                global $wp_object_cache;
+                $this->assertArrayHasKey( 'my_plugin_users', $wp_object_cache->global_groups );
+                $this->assertArrayHasKey( 'my_plugin_settings', $wp_object_cache->global_groups );
+        }
+
+        /**
+         * Test that blog-specific cache keys work correctly after fallback.
+         *
+         * Verifies that non-global cache groups maintain blog-specific prefixing
+         * after the fallback reinitialization.
+         *
+         * @ticket 23290
+         * @covers ::wp_cache_switch_to_blog
+         */
+        public function test_blog_specific_cache_keys_after_fallback() {
+
+                // Set data in a non-global group (which should be blog-specific).
+                wp_cache_set( 'my_key', 'value_blog_1', 'posts' );
+
+                // Call the fallback.
+                wp_cache_switch_to_blog();
+
+                // After fallback, the cache is reinitialized, so data is cleared.
+                $this->assertFalse( wp_cache_get( 'my_key', 'posts' ) );
+
+                // But we can still set blog-specific data.
+                wp_cache_set( 'my_key', 'new_value', 'posts' );
+                $this->assertSame( 'new_value', wp_cache_get( 'my_key', 'posts' ) );
+
+                // And global groups should work as expected.
+                wp_cache_set( 'global_key', 'global_value', 'users' );
+                $this->assertSame( 'global_value', wp_cache_get( 'global_key', 'users' ) );
+        }
+
+        /**
+         * Test fallback correctly identifies non-persistent groups from cache structure.
+         *
+         * The fallback analyzes the existing cache structure to determine which groups
+         * are non-persistent (not in global_groups). This test verifies that analysis works.
+         *
+         * @ticket 23290
+         * @covers ::wp_cache_switch_to_blog
+         */
+        public function test_identifies_non_persistent_groups_from_cache() {
+                global $wp_object_cache;
+
+                // Set data in various groups to populate the cache structure.
+                wp_cache_set( 'k1', 'v1', 'posts' );
+                wp_cache_set( 'k2', 'v2', 'counts' );
+                wp_cache_set( 'k3', 'v3', 'plugins' );
+                wp_cache_set( 'k4', 'v4', 'users' ); // Global group.
+                wp_cache_set( 'k5', 'v5', 'custom_group' );
+
+                // Verify we have multiple groups in the cache.
+                $this->assertGreaterThan( 1, count( $wp_object_cache->cache ) );
+
+                // Call the fallback - it should identify non-global groups from the cache structure.
+                wp_cache_switch_to_blog();
+
+                // Cache is functional after fallback.
+                $this->assertInstanceOf( 'WP_Object_Cache', $wp_object_cache );
+
+                // Test that we can use all the groups that existed before.
+                wp_cache_set( 'new1', 'nv1', 'posts' );
+                wp_cache_set( 'new2', 'nv2', 'counts' );
+                wp_cache_set( 'new3', 'nv3', 'plugins' );
+                wp_cache_set( 'new4', 'nv4', 'users' );
+                wp_cache_set( 'new5', 'nv5', 'custom_group' );
+
+                $this->assertSame( 'nv1', wp_cache_get( 'new1', 'posts' ) );
+                $this->assertSame( 'nv2', wp_cache_get( 'new2', 'counts' ) );
+                $this->assertSame( 'nv3', wp_cache_get( 'new3', 'plugins' ) );
+                $this->assertSame( 'nv4', wp_cache_get( 'new4', 'users' ) );
+                $this->assertSame( 'nv5', wp_cache_get( 'new5', 'custom_group' ) );
+        }
+
+        /**
+         * Test the specific bug from ticket #23290.
+         *
+         * Before the fix, when a persistent object cache drop-in lacked wp_cache_switch_to_blog()
+         * support, custom non-persistent groups added by plugins would be lost because the function
+         * would use hardcoded defaults instead of preserving the existing configuration.
+         *
+         * @ticket 23290
+         * @covers ::wp_cache_switch_to_blog
+         */
+        public function test_ticket_23290_non_persistent_groups_are_maintained() {
+                global $wp_object_cache;
+
+                // Simulate a plugin adding a custom non-persistent group by populating the cache.
+                wp_cache_set( 'plugin_cache_1', 'data1', 'my_plugin_cache' );
+                wp_cache_set( 'plugin_cache_2', 'data2', 'another_plugin' );
+
+                // These groups now exist in the cache structure.
+                $this->assertArrayHasKey( 'my_plugin_cache', $wp_object_cache->cache );
+                $this->assertArrayHasKey( 'another_plugin', $wp_object_cache->cache );
+
+                // Before fix: calling the fallback would lose these groups.
+                // After fix: they should be re-added to the cache configuration.
+                wp_cache_switch_to_blog();
+
+                // After the fallback, we can still use these groups without error.
+                wp_cache_set( 'new_cache_1', 'new_data1', 'my_plugin_cache' );
+                wp_cache_set( 'new_cache_2', 'new_data2', 'another_plugin' );
+
+                // Verify they work.
+                $this->assertSame( 'new_data1', wp_cache_get( 'new_cache_1', 'my_plugin_cache' ) );
+                $this->assertSame( 'new_data2', wp_cache_get( 'new_cache_2', 'another_plugin' ) );
+        }
+
+        /**
+         * Test restore_current_blog() works with the fallback.
+         *
+         * Both switch_to_blog() and restore_current_blog() can use the fallback,
+         * so verify the restore path also works correctly.
+         *
+         * @ticket 23290
+         * @covers ::wp_cache_switch_to_blog
+         */
+        public function test_restore_current_blog_with_fallback() {
+                global $wp_object_cache;
+
+                $original_blog_id = get_current_blog_id();
+                $new_blog_id      = self::factory()->blog->create();
+
+                // Add a custom global group.
+                wp_cache_add_global_groups( array( 'custom_for_restore' ) );
+
+                // Store initial state.
+                $this->assertArrayHasKey( 'custom_for_restore', $wp_object_cache->global_groups );
+
+                // Switch to another blog.
+                switch_to_blog( $new_blog_id );
+                $this->assertSame( $new_blog_id, get_current_blog_id() );
+
+                // Verify custom global group is still there after switch.
+                $this->assertArrayHasKey( 'custom_for_restore', $wp_object_cache->global_groups );
+
+                // Restore to original blog.
+                restore_current_blog();
+
+                // We're back on the original blog.
+                $this->assertSame( $original_blog_id, get_current_blog_id() );
+
+                // Custom global group configuration should still be present after restore.
+                $this->assertArrayHasKey( 'custom_for_restore', $wp_object_cache->global_groups );
+        }
+
+        /**
+         * Test multiple nested blog switches and restores.
+         *
+         * @ticket 23290
+         * @covers ::wp_cache_switch_to_blog
+         */
+        public function test_nested_blog_switches_with_fallback() {
+                global $wp_object_cache;
+
+                $original_blog_id = get_current_blog_id();
+                $blog_id_1        = self::factory()->blog->create();
+                $blog_id_2        = self::factory()->blog->create();
+
+                // Add custom groups.
+                wp_cache_add_global_groups( array( 'nested_test_group' ) );
+
+                // Level 1: Switch to blog 1.
+                switch_to_blog( $blog_id_1 );
+                $this->assertSame( $blog_id_1, get_current_blog_id() );
+                $this->assertArrayHasKey( 'nested_test_group', $wp_object_cache->global_groups );
+
+                // Level 2: Switch to blog 2 from blog 1.
+                switch_to_blog( $blog_id_2 );
+                $this->assertSame( $blog_id_2, get_current_blog_id() );
+                $this->assertArrayHasKey( 'nested_test_group', $wp_object_cache->global_groups );
+
+                // Restore from level 2 to level 1.
+                restore_current_blog();
+                $this->assertSame( $blog_id_1, get_current_blog_id() );
+                $this->assertArrayHasKey( 'nested_test_group', $wp_object_cache->global_groups );
+
+                // Restore from level 1 to original.
+                restore_current_blog();
+                $this->assertSame( $original_blog_id, get_current_blog_id() );
+                $this->assertArrayHasKey( 'nested_test_group', $wp_object_cache->global_groups );
+        }
+
+        /**
+         * Test consistency across multiple rapid fallback calls.
+         *
+         * Stress test verifying the fallback maintains consistency when called
+         * multiple times in quick succession.
+         *
+         * @ticket 23290
+         * @covers ::wp_cache_switch_to_blog
+         */
+        public function test_consistency_across_rapid_fallback_calls() {
+                global $wp_object_cache;
+
+                // Add custom groups.
+                wp_cache_add_global_groups( array( 'rapid_test' ) );
+                $initial_group_count = count( $wp_object_cache->global_groups );
+
+                // Call fallback multiple times rapidly (simulating rapid blog switches).
+                for ( $i = 0; $i < 5; $i++ ) {
+                        wp_cache_switch_to_blog();
+
+                        // Verify the group is still there after each call.
+                        $this->assertArrayHasKey( 'rapid_test', $wp_object_cache->global_groups );
+
+                        // The number of global groups should remain consistent.
+                        $this->assertSame( $initial_group_count, count( $wp_object_cache->global_groups ) );
+                }
+        }
+}