WordPress.org
Get WordPress

Make WordPress Core


Ignore:
Timestamp:
04/09/2025 01:29:39 PM (6 weeks ago)
Author:
SergeyBiryukov
Message:

Tests: Use the ms-required group where appropriate.

This replaces the if ( is_multisite() ) conditional wrapping entire test classes with the ms-required group for more consistency across the test suite.

Follow-up to [40520].

See #63167.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/tests/phpunit/tests/multisite/siteMeta.php

    r55747 r60148  
    11<?php
    22
    3 if ( is_multisite() ) :
     3/**
     4 * @group ms-required
     5 * @group ms-site
     6 * @group multisite
     7 * @group meta
     8 * @ticket 37923
     9 */
     10class Tests_Multisite_SiteMeta extends WP_UnitTestCase {
     11
     12    protected static $site_id;
     13    protected static $site_id2;
     14    protected static $flag_was_set;
     15
     16    public static function wpSetUpBeforeClass( WP_UnitTest_Factory $factory ) {
     17        self::$site_id  = $factory->blog->create(
     18            array(
     19                'domain' => 'wordpress.org',
     20                'path'   => '/',
     21            )
     22        );
     23        self::$site_id2 = $factory->blog->create(
     24            array(
     25                'domain' => 'wordpress.org',
     26                'path'   => '/foo/',
     27            )
     28        );
     29
     30        // Populate the main network flag as necessary.
     31        self::$flag_was_set = true;
     32        if ( false === get_network_option( get_main_network_id(), 'site_meta_supported', false ) ) {
     33            self::$flag_was_set = false;
     34            is_site_meta_supported();
     35        }
     36    }
     37
     38    public static function wpTearDownAfterClass() {
     39        // Delete the possibly previously populated main network flag.
     40        if ( ! self::$flag_was_set ) {
     41            delete_network_option( get_main_network_id(), 'site_meta_supported' );
     42        }
     43
     44        wp_delete_site( self::$site_id );
     45        wp_delete_site( self::$site_id2 );
     46
     47        wp_update_network_site_counts();
     48    }
     49
     50    public function test_is_site_meta_supported() {
     51        $this->assertTrue( is_site_meta_supported() );
     52    }
     53
     54    public function test_is_site_meta_supported_filtered() {
     55        add_filter( 'pre_site_option_site_meta_supported', '__return_zero' );
     56        $this->assertFalse( is_site_meta_supported() );
     57    }
     58
     59    public function test_add() {
     60        if ( ! is_site_meta_supported() ) {
     61            $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
     62        }
     63
     64        $this->assertNotEmpty( add_site_meta( self::$site_id, 'foo', 'bar' ) );
     65        $this->assertSame( 'bar', get_site_meta( self::$site_id, 'foo', true ) );
     66    }
     67
     68    public function test_add_unique() {
     69        if ( ! is_site_meta_supported() ) {
     70            $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
     71        }
     72
     73        $this->assertNotEmpty( add_site_meta( self::$site_id, 'foo', 'bar' ) );
     74        $this->assertFalse( add_site_meta( self::$site_id, 'foo', 'bar', true ) );
     75    }
     76
     77    public function test_delete() {
     78        if ( ! is_site_meta_supported() ) {
     79            $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
     80        }
     81
     82        add_site_meta( self::$site_id, 'foo', 'bar' );
     83
     84        $this->assertTrue( delete_site_meta( self::$site_id, 'foo' ) );
     85        $this->assertEmpty( get_site_meta( self::$site_id, 'foo', true ) );
     86    }
     87
     88    public function test_delete_with_invalid_meta_key_should_return_false() {
     89        if ( ! is_site_meta_supported() ) {
     90            $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
     91        }
     92
     93        $this->assertFalse( delete_site_meta( self::$site_id, 'foo' ) );
     94    }
     95
     96    public function test_delete_should_respect_meta_value() {
     97        if ( ! is_site_meta_supported() ) {
     98            $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
     99        }
     100
     101        add_site_meta( self::$site_id, 'foo', 'bar' );
     102        add_site_meta( self::$site_id, 'foo', 'baz' );
     103
     104        $this->assertTrue( delete_site_meta( self::$site_id, 'foo', 'bar' ) );
     105
     106        $metas = get_site_meta( self::$site_id, 'foo' );
     107        $this->assertSame( array( 'baz' ), $metas );
     108    }
     109
     110    public function test_get_with_no_key_should_fetch_all_keys() {
     111        if ( ! is_site_meta_supported() ) {
     112            $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
     113        }
     114
     115        add_site_meta( self::$site_id, 'foo', 'bar' );
     116        add_site_meta( self::$site_id, 'foo1', 'baz' );
     117
     118        $found    = get_site_meta( self::$site_id );
     119        $expected = array(
     120            'foo'  => array( 'bar' ),
     121            'foo1' => array( 'baz' ),
     122        );
     123
     124        $this->assertSameSets( $expected, $found );
     125    }
     126
     127    public function test_get_with_key_should_fetch_all_for_key() {
     128        if ( ! is_site_meta_supported() ) {
     129            $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
     130        }
     131
     132        add_site_meta( self::$site_id, 'foo', 'bar' );
     133        add_site_meta( self::$site_id, 'foo', 'baz' );
     134        add_site_meta( self::$site_id, 'foo1', 'baz' );
     135
     136        $found    = get_site_meta( self::$site_id, 'foo' );
     137        $expected = array( 'bar', 'baz' );
     138
     139        $this->assertSameSets( $expected, $found );
     140    }
     141
     142    public function test_get_should_respect_single_true() {
     143        if ( ! is_site_meta_supported() ) {
     144            $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
     145        }
     146
     147        add_site_meta( self::$site_id, 'foo', 'bar' );
     148        add_site_meta( self::$site_id, 'foo', 'baz' );
     149
     150        $found = get_site_meta( self::$site_id, 'foo', true );
     151        $this->assertSame( 'bar', $found );
     152    }
     153
     154    public function test_update_should_pass_to_add_when_no_value_exists_for_key() {
     155        if ( ! is_site_meta_supported() ) {
     156            $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
     157        }
     158
     159        $actual = update_site_meta( self::$site_id, 'foo', 'bar' );
     160        $this->assertIsInt( $actual );
     161        $this->assertNotEmpty( $actual );
     162
     163        $meta = get_site_meta( self::$site_id, 'foo', true );
     164        $this->assertSame( 'bar', $meta );
     165    }
     166
     167    public function test_update_should_return_true_when_updating_existing_value_for_key() {
     168        if ( ! is_site_meta_supported() ) {
     169            $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
     170        }
     171
     172        add_site_meta( self::$site_id, 'foo', 'bar' );
     173
     174        $actual = update_site_meta( self::$site_id, 'foo', 'baz' );
     175        $this->assertTrue( $actual );
     176
     177        $meta = get_site_meta( self::$site_id, 'foo', true );
     178        $this->assertSame( 'baz', $meta );
     179    }
     180
     181    public function test_delete_by_key() {
     182        if ( ! is_site_meta_supported() ) {
     183            $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
     184        }
     185
     186        add_site_meta( self::$site_id, 'unique_delete_by_key', 'value', true );
     187        add_site_meta( self::$site_id2, 'unique_delete_by_key', 'value', true );
     188
     189        $this->assertSame( 'value', get_site_meta( self::$site_id, 'unique_delete_by_key', true ) );
     190        $this->assertSame( 'value', get_site_meta( self::$site_id2, 'unique_delete_by_key', true ) );
     191
     192        $this->assertTrue( delete_site_meta_by_key( 'unique_delete_by_key' ) );
     193
     194        $this->assertSame( '', get_site_meta( self::$site_id, 'unique_delete_by_key', true ) );
     195        $this->assertSame( '', get_site_meta( self::$site_id2, 'unique_delete_by_key', true ) );
     196    }
     197
     198    public function test_site_meta_should_be_deleted_when_site_is_deleted() {
     199        if ( ! is_site_meta_supported() ) {
     200            $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
     201        }
     202
     203        $site_id = self::factory()->blog->create(
     204            array(
     205                'domain' => 'foo.org',
     206                'path'   => '/',
     207            )
     208        );
     209
     210        add_site_meta( $site_id, 'foo', 'bar' );
     211        add_site_meta( $site_id, 'foo1', 'bar' );
     212
     213        $this->assertSame( 'bar', get_site_meta( $site_id, 'foo', true ) );
     214        $this->assertSame( 'bar', get_site_meta( $site_id, 'foo1', true ) );
     215
     216        wp_delete_site( $site_id );
     217
     218        $this->assertSame( '', get_site_meta( $site_id, 'foo', true ) );
     219        $this->assertSame( '', get_site_meta( $site_id, 'foo1', true ) );
     220    }
     221
     222    public function test_update_site_meta_cache() {
     223        if ( ! is_site_meta_supported() ) {
     224            $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
     225        }
     226
     227        update_site_meta( self::$site_id, 'foo', 'bar' );
     228        update_sitemeta_cache( array( self::$site_id ) );
     229
     230        $num_queries = get_num_queries();
     231        get_site_meta( self::$site_id, 'foo', true );
     232        $this->assertSame( $num_queries, get_num_queries() );
     233    }
     234
     235    public function test_query_update_site_meta_cache_true() {
     236        if ( ! is_site_meta_supported() ) {
     237            $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
     238        }
     239
     240        update_site_meta( self::$site_id, 'foo', 'bar' );
     241
     242        // Do not include 'update_site_meta_cache' as true as its the default.
     243        new WP_Site_Query(
     244            array(
     245                'ID' => self::$site_id,
     246            )
     247        );
     248
     249        $num_queries = get_num_queries();
     250        get_site_meta( self::$site_id, 'foo', true );
     251        $this->assertSame( 1, get_num_queries() - $num_queries );
     252    }
    4253
    5254    /**
    6      * @group ms-site
    7      * @group multisite
    8      * @group meta
    9      * @ticket 37923
     255     * @ticket 58185
    10256     */
    11     class Tests_Multisite_SiteMeta extends WP_UnitTestCase {
    12         protected static $site_id;
    13         protected static $site_id2;
    14         protected static $flag_was_set;
    15 
    16         public static function wpSetUpBeforeClass( WP_UnitTest_Factory $factory ) {
    17             self::$site_id  = $factory->blog->create(
    18                 array(
    19                     'domain' => 'wordpress.org',
    20                     'path'   => '/',
    21                 )
    22             );
    23             self::$site_id2 = $factory->blog->create(
    24                 array(
    25                     'domain' => 'wordpress.org',
    26                     'path'   => '/foo/',
    27                 )
    28             );
    29 
    30             // Populate the main network flag as necessary.
    31             self::$flag_was_set = true;
    32             if ( false === get_network_option( get_main_network_id(), 'site_meta_supported', false ) ) {
    33                 self::$flag_was_set = false;
    34                 is_site_meta_supported();
    35             }
    36         }
    37 
    38         public static function wpTearDownAfterClass() {
    39             // Delete the possibly previously populated main network flag.
    40             if ( ! self::$flag_was_set ) {
    41                 delete_network_option( get_main_network_id(), 'site_meta_supported' );
    42             }
    43 
    44             wp_delete_site( self::$site_id );
    45             wp_delete_site( self::$site_id2 );
    46 
    47             wp_update_network_site_counts();
    48         }
    49 
    50         public function test_is_site_meta_supported() {
    51             $this->assertTrue( is_site_meta_supported() );
    52         }
    53 
    54         public function test_is_site_meta_supported_filtered() {
    55             add_filter( 'pre_site_option_site_meta_supported', '__return_zero' );
    56             $this->assertFalse( is_site_meta_supported() );
    57         }
    58 
    59         public function test_add() {
    60             if ( ! is_site_meta_supported() ) {
    61                 $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
    62             }
    63 
    64             $this->assertNotEmpty( add_site_meta( self::$site_id, 'foo', 'bar' ) );
    65             $this->assertSame( 'bar', get_site_meta( self::$site_id, 'foo', true ) );
    66         }
    67 
    68         public function test_add_unique() {
    69             if ( ! is_site_meta_supported() ) {
    70                 $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
    71             }
    72 
    73             $this->assertNotEmpty( add_site_meta( self::$site_id, 'foo', 'bar' ) );
    74             $this->assertFalse( add_site_meta( self::$site_id, 'foo', 'bar', true ) );
    75         }
    76 
    77         public function test_delete() {
    78             if ( ! is_site_meta_supported() ) {
    79                 $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
    80             }
    81 
    82             add_site_meta( self::$site_id, 'foo', 'bar' );
    83 
    84             $this->assertTrue( delete_site_meta( self::$site_id, 'foo' ) );
    85             $this->assertEmpty( get_site_meta( self::$site_id, 'foo', true ) );
    86         }
    87 
    88         public function test_delete_with_invalid_meta_key_should_return_false() {
    89             if ( ! is_site_meta_supported() ) {
    90                 $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
    91             }
    92 
    93             $this->assertFalse( delete_site_meta( self::$site_id, 'foo' ) );
    94         }
    95 
    96         public function test_delete_should_respect_meta_value() {
    97             if ( ! is_site_meta_supported() ) {
    98                 $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
    99             }
    100 
    101             add_site_meta( self::$site_id, 'foo', 'bar' );
    102             add_site_meta( self::$site_id, 'foo', 'baz' );
    103 
    104             $this->assertTrue( delete_site_meta( self::$site_id, 'foo', 'bar' ) );
    105 
    106             $metas = get_site_meta( self::$site_id, 'foo' );
    107             $this->assertSame( array( 'baz' ), $metas );
    108         }
    109 
    110         public function test_get_with_no_key_should_fetch_all_keys() {
    111             if ( ! is_site_meta_supported() ) {
    112                 $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
    113             }
    114 
    115             add_site_meta( self::$site_id, 'foo', 'bar' );
    116             add_site_meta( self::$site_id, 'foo1', 'baz' );
    117 
    118             $found    = get_site_meta( self::$site_id );
    119             $expected = array(
    120                 'foo'  => array( 'bar' ),
    121                 'foo1' => array( 'baz' ),
    122             );
    123 
    124             $this->assertSameSets( $expected, $found );
    125         }
    126 
    127         public function test_get_with_key_should_fetch_all_for_key() {
    128             if ( ! is_site_meta_supported() ) {
    129                 $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
    130             }
    131 
    132             add_site_meta( self::$site_id, 'foo', 'bar' );
    133             add_site_meta( self::$site_id, 'foo', 'baz' );
    134             add_site_meta( self::$site_id, 'foo1', 'baz' );
    135 
    136             $found    = get_site_meta( self::$site_id, 'foo' );
    137             $expected = array( 'bar', 'baz' );
    138 
    139             $this->assertSameSets( $expected, $found );
    140         }
    141 
    142         public function test_get_should_respect_single_true() {
    143             if ( ! is_site_meta_supported() ) {
    144                 $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
    145             }
    146 
    147             add_site_meta( self::$site_id, 'foo', 'bar' );
    148             add_site_meta( self::$site_id, 'foo', 'baz' );
    149 
    150             $found = get_site_meta( self::$site_id, 'foo', true );
    151             $this->assertSame( 'bar', $found );
    152         }
    153 
    154         public function test_update_should_pass_to_add_when_no_value_exists_for_key() {
    155             if ( ! is_site_meta_supported() ) {
    156                 $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
    157             }
    158 
    159             $actual = update_site_meta( self::$site_id, 'foo', 'bar' );
    160             $this->assertIsInt( $actual );
    161             $this->assertNotEmpty( $actual );
    162 
    163             $meta = get_site_meta( self::$site_id, 'foo', true );
    164             $this->assertSame( 'bar', $meta );
    165         }
    166 
    167         public function test_update_should_return_true_when_updating_existing_value_for_key() {
    168             if ( ! is_site_meta_supported() ) {
    169                 $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
    170             }
    171 
    172             add_site_meta( self::$site_id, 'foo', 'bar' );
    173 
    174             $actual = update_site_meta( self::$site_id, 'foo', 'baz' );
    175             $this->assertTrue( $actual );
    176 
    177             $meta = get_site_meta( self::$site_id, 'foo', true );
    178             $this->assertSame( 'baz', $meta );
    179         }
    180 
    181         public function test_delete_by_key() {
    182             if ( ! is_site_meta_supported() ) {
    183                 $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
    184             }
    185 
    186             add_site_meta( self::$site_id, 'unique_delete_by_key', 'value', true );
    187             add_site_meta( self::$site_id2, 'unique_delete_by_key', 'value', true );
    188 
    189             $this->assertSame( 'value', get_site_meta( self::$site_id, 'unique_delete_by_key', true ) );
    190             $this->assertSame( 'value', get_site_meta( self::$site_id2, 'unique_delete_by_key', true ) );
    191 
    192             $this->assertTrue( delete_site_meta_by_key( 'unique_delete_by_key' ) );
    193 
    194             $this->assertSame( '', get_site_meta( self::$site_id, 'unique_delete_by_key', true ) );
    195             $this->assertSame( '', get_site_meta( self::$site_id2, 'unique_delete_by_key', true ) );
    196         }
    197 
    198         public function test_site_meta_should_be_deleted_when_site_is_deleted() {
    199             if ( ! is_site_meta_supported() ) {
    200                 $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
    201             }
    202 
    203             $site_id = self::factory()->blog->create(
    204                 array(
    205                     'domain' => 'foo.org',
    206                     'path'   => '/',
    207                 )
    208             );
    209 
    210             add_site_meta( $site_id, 'foo', 'bar' );
    211             add_site_meta( $site_id, 'foo1', 'bar' );
    212 
    213             $this->assertSame( 'bar', get_site_meta( $site_id, 'foo', true ) );
    214             $this->assertSame( 'bar', get_site_meta( $site_id, 'foo1', true ) );
    215 
    216             wp_delete_site( $site_id );
    217 
    218             $this->assertSame( '', get_site_meta( $site_id, 'foo', true ) );
    219             $this->assertSame( '', get_site_meta( $site_id, 'foo1', true ) );
    220         }
    221 
    222         public function test_update_site_meta_cache() {
    223             if ( ! is_site_meta_supported() ) {
    224                 $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
    225             }
    226 
    227             update_site_meta( self::$site_id, 'foo', 'bar' );
    228             update_sitemeta_cache( array( self::$site_id ) );
    229 
    230             $num_queries = get_num_queries();
    231             get_site_meta( self::$site_id, 'foo', true );
    232             $this->assertSame( $num_queries, get_num_queries() );
    233         }
    234 
    235         public function test_query_update_site_meta_cache_true() {
    236             if ( ! is_site_meta_supported() ) {
    237                 $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
    238             }
    239 
    240             update_site_meta( self::$site_id, 'foo', 'bar' );
    241 
    242             // Do not include 'update_site_meta_cache' as true as its the default.
    243             new WP_Site_Query(
    244                 array(
    245                     'ID' => self::$site_id,
    246                 )
    247             );
    248 
    249             $num_queries = get_num_queries();
    250             get_site_meta( self::$site_id, 'foo', true );
    251             $this->assertSame( 1, get_num_queries() - $num_queries );
    252         }
    253 
    254         /**
    255          * @ticket 58185
    256          */
    257         public function test_lazy_load_site_meta() {
    258             if ( ! is_site_meta_supported() ) {
    259                 $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
    260             }
    261 
    262             $filter = new MockAction();
    263             add_filter( 'update_blog_metadata_cache', array( $filter, 'filter' ), 10, 2 );
    264 
    265             $q = new WP_Site_Query(
    266                 array(
    267                     'ID' => self::$site_id,
    268                 )
    269             );
    270 
    271             $this->assertSameSets( array( (string) self::$site_id ), wp_list_pluck( $q->sites, 'blog_id' ), 'Site query should return the first test site' );
    272 
    273             $q = new WP_Site_Query(
    274                 array(
    275                     'ID' => self::$site_id2,
    276                 )
    277             );
    278 
    279             $this->assertSameSets( array( (string) self::$site_id2 ), wp_list_pluck( $q->sites, 'blog_id' ), 'Site query should return the second test site' );
    280 
    281             get_site_meta( self::$site_id2 );
    282 
    283             $args     = $filter->get_args();
    284             $first    = reset( $args );
    285             $site_ids = end( $first );
    286             $this->assertSameSets( $site_ids, array( self::$site_id, self::$site_id2 ), 'This should have two site\'s meta' );
    287         }
    288 
    289         /**
    290          * @ticket 58185
    291          */
    292         public function test_lazy_load_site_meta_fields_id() {
    293             if ( ! is_site_meta_supported() ) {
    294                 $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
    295             }
    296 
    297             $filter = new MockAction();
    298             add_filter( 'update_blog_metadata_cache', array( $filter, 'filter' ), 10, 2 );
    299 
    300             $q = new WP_Site_Query(
    301                 array(
    302                     'ID'     => self::$site_id,
    303                     'fields' => 'ids',
    304                 )
    305             );
    306 
    307             $this->assertSameSets( array( self::$site_id ), $q->sites, 'Site query should return the first test site' );
    308 
    309             $q = new WP_Site_Query(
    310                 array(
    311                     'ID'     => self::$site_id2,
    312                     'fields' => 'ids',
    313                 )
    314             );
    315 
    316             $this->assertSameSets( array( self::$site_id2 ), $q->sites, 'Site query should return the second test site' );
    317 
    318             get_site_meta( self::$site_id2 );
    319 
    320             $args     = $filter->get_args();
    321             $first    = reset( $args );
    322             $site_ids = end( $first );
    323             $this->assertSameSets( $site_ids, array( self::$site_id, self::$site_id2 ), 'This should have two sites meta' );
    324         }
    325 
    326         public function test_query_update_site_meta_cache_false() {
    327             if ( ! is_site_meta_supported() ) {
    328                 $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
    329             }
    330 
    331             update_site_meta( self::$site_id, 'foo', 'bar' );
    332 
    333             new WP_Site_Query(
    334                 array(
    335                     'ID'                     => self::$site_id,
    336                     'update_site_meta_cache' => false,
    337                 )
    338             );
    339 
    340             $num_queries = get_num_queries();
    341             get_site_meta( self::$site_id, 'foo', true );
    342             $this->assertSame( 1, get_num_queries() - $num_queries );
    343         }
    344 
    345         /**
    346          * @ticket 40229
    347          */
    348         public function test_add_site_meta_should_bust_get_sites_cache() {
    349             if ( ! is_site_meta_supported() ) {
    350                 $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
    351             }
    352 
    353             add_site_meta( self::$site_id, 'foo', 'bar' );
    354 
    355             // Prime cache.
    356             $found = get_sites(
    357                 array(
    358                     'fields'     => 'ids',
    359                     'meta_query' => array(
    360                         array(
    361                             'key'   => 'foo',
    362                             'value' => 'bar',
    363                         ),
    364                     ),
    365                 )
    366             );
    367 
    368             $this->assertSameSets( array( self::$site_id ), $found );
    369 
    370             add_site_meta( self::$site_id2, 'foo', 'bar' );
    371 
    372             $found = get_sites(
    373                 array(
    374                     'fields'     => 'ids',
    375                     'meta_query' => array(
    376                         array(
    377                             'key'   => 'foo',
    378                             'value' => 'bar',
    379                         ),
    380                     ),
    381                 )
    382             );
    383 
    384             $this->assertSameSets( array( self::$site_id, self::$site_id2 ), $found );
    385         }
    386 
    387         /**
    388          * @ticket 40229
    389          */
    390         public function test_update_site_meta_should_bust_get_sites_cache() {
    391             if ( ! is_site_meta_supported() ) {
    392                 $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
    393             }
    394 
    395             add_site_meta( self::$site_id, 'foo', 'bar' );
    396             add_site_meta( self::$site_id2, 'foo', 'baz' );
    397 
    398             // Prime cache.
    399             $found = get_sites(
    400                 array(
    401                     'fields'     => 'ids',
    402                     'meta_query' => array(
    403                         array(
    404                             'key'   => 'foo',
    405                             'value' => 'bar',
    406                         ),
    407                     ),
    408                 )
    409             );
    410 
    411             $this->assertSameSets( array( self::$site_id ), $found );
    412 
    413             update_site_meta( self::$site_id2, 'foo', 'bar' );
    414 
    415             $found = get_sites(
    416                 array(
    417                     'fields'     => 'ids',
    418                     'meta_query' => array(
    419                         array(
    420                             'key'   => 'foo',
    421                             'value' => 'bar',
    422                         ),
    423                     ),
    424                 )
    425             );
    426 
    427             $this->assertSameSets( array( self::$site_id, self::$site_id2 ), $found );
    428         }
    429 
    430         /**
    431          * @ticket 40229
    432          */
    433         public function test_delete_site_meta_should_bust_get_sites_cache() {
    434             if ( ! is_site_meta_supported() ) {
    435                 $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
    436             }
    437 
    438             add_site_meta( self::$site_id, 'foo', 'bar' );
    439             add_site_meta( self::$site_id2, 'foo', 'bar' );
    440 
    441             // Prime cache.
    442             $found = get_sites(
    443                 array(
    444                     'fields'     => 'ids',
    445                     'meta_query' => array(
    446                         array(
    447                             'key'   => 'foo',
    448                             'value' => 'bar',
    449                         ),
    450                     ),
    451                 )
    452             );
    453 
    454             $this->assertSameSets( array( self::$site_id, self::$site_id2 ), $found );
    455 
    456             delete_site_meta( self::$site_id2, 'foo', 'bar' );
    457 
    458             $found = get_sites(
    459                 array(
    460                     'fields'     => 'ids',
    461                     'meta_query' => array(
    462                         array(
    463                             'key'   => 'foo',
    464                             'value' => 'bar',
    465                         ),
    466                     ),
    467                 )
    468             );
    469 
    470             $this->assertSameSets( array( self::$site_id ), $found );
    471         }
    472     }
    473 
    474 endif;
     257    public function test_lazy_load_site_meta() {
     258        if ( ! is_site_meta_supported() ) {
     259            $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
     260        }
     261
     262        $filter = new MockAction();
     263        add_filter( 'update_blog_metadata_cache', array( $filter, 'filter' ), 10, 2 );
     264
     265        $q = new WP_Site_Query(
     266            array(
     267                'ID' => self::$site_id,
     268            )
     269        );
     270
     271        $this->assertSameSets( array( (string) self::$site_id ), wp_list_pluck( $q->sites, 'blog_id' ), 'Site query should return the first test site' );
     272
     273        $q = new WP_Site_Query(
     274            array(
     275                'ID' => self::$site_id2,
     276            )
     277        );
     278
     279        $this->assertSameSets( array( (string) self::$site_id2 ), wp_list_pluck( $q->sites, 'blog_id' ), 'Site query should return the second test site' );
     280
     281        get_site_meta( self::$site_id2 );
     282
     283        $args     = $filter->get_args();
     284        $first    = reset( $args );
     285        $site_ids = end( $first );
     286        $this->assertSameSets( $site_ids, array( self::$site_id, self::$site_id2 ), 'This should have two site\'s meta' );
     287    }
     288
     289    /**
     290     * @ticket 58185
     291     */
     292    public function test_lazy_load_site_meta_fields_id() {
     293        if ( ! is_site_meta_supported() ) {
     294            $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
     295        }
     296
     297        $filter = new MockAction();
     298        add_filter( 'update_blog_metadata_cache', array( $filter, 'filter' ), 10, 2 );
     299
     300        $q = new WP_Site_Query(
     301            array(
     302                'ID'     => self::$site_id,
     303                'fields' => 'ids',
     304            )
     305        );
     306
     307        $this->assertSameSets( array( self::$site_id ), $q->sites, 'Site query should return the first test site' );
     308
     309        $q = new WP_Site_Query(
     310            array(
     311                'ID'     => self::$site_id2,
     312                'fields' => 'ids',
     313            )
     314        );
     315
     316        $this->assertSameSets( array( self::$site_id2 ), $q->sites, 'Site query should return the second test site' );
     317
     318        get_site_meta( self::$site_id2 );
     319
     320        $args     = $filter->get_args();
     321        $first    = reset( $args );
     322        $site_ids = end( $first );
     323        $this->assertSameSets( $site_ids, array( self::$site_id, self::$site_id2 ), 'This should have two sites meta' );
     324    }
     325
     326    public function test_query_update_site_meta_cache_false() {
     327        if ( ! is_site_meta_supported() ) {
     328            $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
     329        }
     330
     331        update_site_meta( self::$site_id, 'foo', 'bar' );
     332
     333        new WP_Site_Query(
     334            array(
     335                'ID'                     => self::$site_id,
     336                'update_site_meta_cache' => false,
     337            )
     338        );
     339
     340        $num_queries = get_num_queries();
     341        get_site_meta( self::$site_id, 'foo', true );
     342        $this->assertSame( 1, get_num_queries() - $num_queries );
     343    }
     344
     345    /**
     346     * @ticket 40229
     347     */
     348    public function test_add_site_meta_should_bust_get_sites_cache() {
     349        if ( ! is_site_meta_supported() ) {
     350            $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
     351        }
     352
     353        add_site_meta( self::$site_id, 'foo', 'bar' );
     354
     355        // Prime cache.
     356        $found = get_sites(
     357            array(
     358                'fields'     => 'ids',
     359                'meta_query' => array(
     360                    array(
     361                        'key'   => 'foo',
     362                        'value' => 'bar',
     363                    ),
     364                ),
     365            )
     366        );
     367
     368        $this->assertSameSets( array( self::$site_id ), $found );
     369
     370        add_site_meta( self::$site_id2, 'foo', 'bar' );
     371
     372        $found = get_sites(
     373            array(
     374                'fields'     => 'ids',
     375                'meta_query' => array(
     376                    array(
     377                        'key'   => 'foo',
     378                        'value' => 'bar',
     379                    ),
     380                ),
     381            )
     382        );
     383
     384        $this->assertSameSets( array( self::$site_id, self::$site_id2 ), $found );
     385    }
     386
     387    /**
     388     * @ticket 40229
     389     */
     390    public function test_update_site_meta_should_bust_get_sites_cache() {
     391        if ( ! is_site_meta_supported() ) {
     392            $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
     393        }
     394
     395        add_site_meta( self::$site_id, 'foo', 'bar' );
     396        add_site_meta( self::$site_id2, 'foo', 'baz' );
     397
     398        // Prime cache.
     399        $found = get_sites(
     400            array(
     401                'fields'     => 'ids',
     402                'meta_query' => array(
     403                    array(
     404                        'key'   => 'foo',
     405                        'value' => 'bar',
     406                    ),
     407                ),
     408            )
     409        );
     410
     411        $this->assertSameSets( array( self::$site_id ), $found );
     412
     413        update_site_meta( self::$site_id2, 'foo', 'bar' );
     414
     415        $found = get_sites(
     416            array(
     417                'fields'     => 'ids',
     418                'meta_query' => array(
     419                    array(
     420                        'key'   => 'foo',
     421                        'value' => 'bar',
     422                    ),
     423                ),
     424            )
     425        );
     426
     427        $this->assertSameSets( array( self::$site_id, self::$site_id2 ), $found );
     428    }
     429
     430    /**
     431     * @ticket 40229
     432     */
     433    public function test_delete_site_meta_should_bust_get_sites_cache() {
     434        if ( ! is_site_meta_supported() ) {
     435            $this->markTestSkipped( 'Test only runs with the blogmeta database table installed.' );
     436        }
     437
     438        add_site_meta( self::$site_id, 'foo', 'bar' );
     439        add_site_meta( self::$site_id2, 'foo', 'bar' );
     440
     441        // Prime cache.
     442        $found = get_sites(
     443            array(
     444                'fields'     => 'ids',
     445                'meta_query' => array(
     446                    array(
     447                        'key'   => 'foo',
     448                        'value' => 'bar',
     449                    ),
     450                ),
     451            )
     452        );
     453
     454        $this->assertSameSets( array( self::$site_id, self::$site_id2 ), $found );
     455
     456        delete_site_meta( self::$site_id2, 'foo', 'bar' );
     457
     458        $found = get_sites(
     459            array(
     460                'fields'     => 'ids',
     461                'meta_query' => array(
     462                    array(
     463                        'key'   => 'foo',
     464                        'value' => 'bar',
     465                    ),
     466                ),
     467            )
     468        );
     469
     470        $this->assertSameSets( array( self::$site_id ), $found );
     471    }
     472}
Note: See TracChangeset for help on using the changeset viewer.