WordPress.org
Get WordPress

Make WordPress Core


Ignore:
Timestamp:
08/17/2018 01:50:26 AM (8 years ago)
Author:
pento
Message:

Coding Standards: Upgrade WPCS to 1.0.0

WPCS 1.0.0 includes a bunch of new auto-fixers, which drops the number of coding standards issues across WordPress significantly. Prior to running the auto-fixers, there were 15,312 issues detected. With this commit, we now drop to 4,769 issues.

This change includes three notable additions:

  • Multiline function calls must now put each parameter on a new line.
  • Auto-formatting files is now part of the grunt precommit script.
  • Auto-fixable coding standards issues will now cause Travis failures.

Fixes #44600.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r43010 r43571  
    33if ( is_multisite() ) :
    44
    5 /**
    6  * @group ms-site
    7  * @group multisite
    8  * @group meta
    9  * @ticket 37923
    10  */
    11 class Tests_Multisite_Site_Meta 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( $factory ) {
    17                 self::$site_id = $factory->blog->create( array( 'domain' => 'wordpress.org', 'path' => '/' ) );
    18                 self::$site_id2 = $factory->blog->create( array( 'domain' => 'wordpress.org', 'path' => '/foo/' ) );
    19 
    20                 // Populate the main network flag as necessary.
    21                 self::$flag_was_set = true;
    22                 if ( false === get_network_option( get_main_network_id(), 'site_meta_supported', false ) ) {
    23                         self::$flag_was_set = false;
    24                         is_site_meta_supported();
     5        /**
     6         * @group ms-site
     7         * @group multisite
     8         * @group meta
     9         * @ticket 37923
     10         */
     11        class Tests_Multisite_Site_Meta 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( $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                        wpmu_delete_blog( self::$site_id, true );
     45                        wpmu_delete_blog( self::$site_id2, true );
     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( 'Tests 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( 'Tests 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( 'Tests 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( 'Tests 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( 'Tests 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( 'Tests 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->assertEqualSets( $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( 'Tests 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->assertEqualSets( $expected, $found );
     140                }
     141
     142                public function test_get_should_respect_single_true() {
     143                        if ( ! is_site_meta_supported() ) {
     144                                $this->markTestSkipped( 'Tests 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( 'Tests only runs with the blogmeta database table installed' );
     157                        }
     158
     159                        $actual = update_site_meta( self::$site_id, 'foo', 'bar' );
     160                        $this->assertInternalType( 'int', $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( 'Tests 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( 'Tests 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->assertEquals( 'value', get_site_meta( self::$site_id, 'unique_delete_by_key', true ) );
     190                        $this->assertEquals( '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->assertEquals( '', get_site_meta( self::$site_id, 'unique_delete_by_key', true ) );
     195                        $this->assertEquals( '', 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( 'Tests 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                        wpmu_delete_blog( $site_id, true );
     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                        global $wpdb;
     224
     225                        if ( ! is_site_meta_supported() ) {
     226                                $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
     227                        }
     228
     229                        update_site_meta( self::$site_id, 'foo', 'bar' );
     230                        update_sitemeta_cache( array( self::$site_id ) );
     231
     232                        $num_queries = $wpdb->num_queries;
     233                        get_site_meta( self::$site_id, 'foo', true );
     234                        $this->assertSame( $num_queries, $wpdb->num_queries );
     235                }
     236
     237                public function test_query_update_site_meta_cache_true() {
     238                        global $wpdb;
     239
     240                        if ( ! is_site_meta_supported() ) {
     241                                $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
     242                        }
     243
     244                        update_site_meta( self::$site_id, 'foo', 'bar' );
     245
     246                        // Do not include 'update_site_meta_cache' as true as its the default.
     247                        new WP_Site_Query(
     248                                array(
     249                                        'ID' => self::$site_id,
     250                                )
     251                        );
     252
     253                        $num_queries = $wpdb->num_queries;
     254                        get_site_meta( self::$site_id, 'foo', true );
     255                        $this->assertSame( $num_queries, $wpdb->num_queries );
     256                }
     257
     258                public function test_query_update_site_meta_cache_false() {
     259                        global $wpdb;
     260
     261                        if ( ! is_site_meta_supported() ) {
     262                                $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
     263                        }
     264
     265                        update_site_meta( self::$site_id, 'foo', 'bar' );
     266
     267                        new WP_Site_Query(
     268                                array(
     269                                        'ID'                     => self::$site_id,
     270                                        'update_site_meta_cache' => false,
     271                                )
     272                        );
     273
     274                        $num_queries = $wpdb->num_queries;
     275                        get_site_meta( self::$site_id, 'foo', true );
     276                        $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     277                }
     278
     279                /**
     280                 * @ticket 40229
     281                 */
     282                public function test_add_site_meta_should_bust_get_sites_cache() {
     283                        if ( ! is_site_meta_supported() ) {
     284                                $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
     285                        }
     286
     287                        add_site_meta( self::$site_id, 'foo', 'bar' );
     288
     289                        // Prime cache.
     290                        $found = get_sites(
     291                                array(
     292                                        'fields'     => 'ids',
     293                                        'meta_query' => array(
     294                                                array(
     295                                                        'key'   => 'foo',
     296                                                        'value' => 'bar',
     297                                                ),
     298                                        ),
     299                                )
     300                        );
     301
     302                        $this->assertEqualSets( array( self::$site_id ), $found );
     303
     304                        add_site_meta( self::$site_id2, 'foo', 'bar' );
     305
     306                        $found = get_sites(
     307                                array(
     308                                        'fields'     => 'ids',
     309                                        'meta_query' => array(
     310                                                array(
     311                                                        'key'   => 'foo',
     312                                                        'value' => 'bar',
     313                                                ),
     314                                        ),
     315                                )
     316                        );
     317
     318                        $this->assertEqualSets( array( self::$site_id, self::$site_id2 ), $found );
     319                }
     320
     321                /**
     322                 * @ticket 40229
     323                 */
     324                public function test_update_site_meta_should_bust_get_sites_cache() {
     325                        if ( ! is_site_meta_supported() ) {
     326                                $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
     327                        }
     328
     329                        add_site_meta( self::$site_id, 'foo', 'bar' );
     330                        add_site_meta( self::$site_id2, 'foo', 'baz' );
     331
     332                        // Prime cache.
     333                        $found = get_sites(
     334                                array(
     335                                        'fields'     => 'ids',
     336                                        'meta_query' => array(
     337                                                array(
     338                                                        'key'   => 'foo',
     339                                                        'value' => 'bar',
     340                                                ),
     341                                        ),
     342                                )
     343                        );
     344
     345                        $this->assertEqualSets( array( self::$site_id ), $found );
     346
     347                        update_site_meta( self::$site_id2, 'foo', 'bar' );
     348
     349                        $found = get_sites(
     350                                array(
     351                                        'fields'     => 'ids',
     352                                        'meta_query' => array(
     353                                                array(
     354                                                        'key'   => 'foo',
     355                                                        'value' => 'bar',
     356                                                ),
     357                                        ),
     358                                )
     359                        );
     360
     361                        $this->assertEqualSets( array( self::$site_id, self::$site_id2 ), $found );
     362                }
     363
     364                /**
     365                 * @ticket 40229
     366                 */
     367                public function test_delete_site_meta_should_bust_get_sites_cache() {
     368                        if ( ! is_site_meta_supported() ) {
     369                                $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
     370                        }
     371
     372                        add_site_meta( self::$site_id, 'foo', 'bar' );
     373                        add_site_meta( self::$site_id2, 'foo', 'bar' );
     374
     375                        // Prime cache.
     376                        $found = get_sites(
     377                                array(
     378                                        'fields'     => 'ids',
     379                                        'meta_query' => array(
     380                                                array(
     381                                                        'key'   => 'foo',
     382                                                        'value' => 'bar',
     383                                                ),
     384                                        ),
     385                                )
     386                        );
     387
     388                        $this->assertEqualSets( array( self::$site_id, self::$site_id2 ), $found );
     389
     390                        delete_site_meta( self::$site_id2, 'foo', 'bar' );
     391
     392                        $found = get_sites(
     393                                array(
     394                                        'fields'     => 'ids',
     395                                        'meta_query' => array(
     396                                                array(
     397                                                        'key'   => 'foo',
     398                                                        'value' => 'bar',
     399                                                ),
     400                                        ),
     401                                )
     402                        );
     403
     404                        $this->assertEqualSets( array( self::$site_id ), $found );
    25405                }
    26406        }
    27407
    28         public static function wpTearDownAfterClass() {
    29                 // Delete the possibly previously populated main network flag.
    30                 if ( ! self::$flag_was_set ) {
    31                         delete_network_option( get_main_network_id(), 'site_meta_supported' );
    32                 }
    33 
    34                 wpmu_delete_blog( self::$site_id, true );
    35                 wpmu_delete_blog( self::$site_id2, true );
    36 
    37                 wp_update_network_site_counts();
    38         }
    39 
    40         public function test_is_site_meta_supported() {
    41                 $this->assertTrue( is_site_meta_supported() );
    42         }
    43 
    44         public function test_is_site_meta_supported_filtered() {
    45                 add_filter( 'pre_site_option_site_meta_supported', '__return_zero' );
    46                 $this->assertFalse( is_site_meta_supported() );
    47         }
    48 
    49         public function test_add() {
    50                 if ( ! is_site_meta_supported() ) {
    51                         $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
    52                 }
    53 
    54                 $this->assertNotEmpty( add_site_meta( self::$site_id, 'foo', 'bar' ) );
    55                 $this->assertSame( 'bar', get_site_meta( self::$site_id, 'foo', true ) );
    56         }
    57 
    58         public function test_add_unique() {
    59                 if ( ! is_site_meta_supported() ) {
    60                         $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
    61                 }
    62 
    63                 $this->assertNotEmpty( add_site_meta( self::$site_id, 'foo', 'bar' ) );
    64                 $this->assertFalse( add_site_meta( self::$site_id, 'foo', 'bar', true ) );
    65         }
    66 
    67         public function test_delete() {
    68                 if ( ! is_site_meta_supported() ) {
    69                         $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
    70                 }
    71 
    72                 add_site_meta( self::$site_id, 'foo', 'bar' );
    73 
    74                 $this->assertTrue( delete_site_meta( self::$site_id, 'foo' ) );
    75                 $this->assertEmpty( get_site_meta( self::$site_id, 'foo', true ) );
    76         }
    77 
    78         public function test_delete_with_invalid_meta_key_should_return_false() {
    79                 if ( ! is_site_meta_supported() ) {
    80                         $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
    81                 }
    82 
    83                 $this->assertFalse( delete_site_meta( self::$site_id, 'foo' ) );
    84         }
    85 
    86         public function test_delete_should_respect_meta_value() {
    87                 if ( ! is_site_meta_supported() ) {
    88                         $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
    89                 }
    90 
    91                 add_site_meta( self::$site_id, 'foo', 'bar' );
    92                 add_site_meta( self::$site_id, 'foo', 'baz' );
    93 
    94                 $this->assertTrue( delete_site_meta( self::$site_id, 'foo', 'bar' ) );
    95 
    96                 $metas = get_site_meta( self::$site_id, 'foo' );
    97                 $this->assertSame( array( 'baz' ), $metas );
    98         }
    99 
    100         public function test_get_with_no_key_should_fetch_all_keys() {
    101                 if ( ! is_site_meta_supported() ) {
    102                         $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
    103                 }
    104 
    105                 add_site_meta( self::$site_id, 'foo', 'bar' );
    106                 add_site_meta( self::$site_id, 'foo1', 'baz' );
    107 
    108                 $found = get_site_meta( self::$site_id );
    109                 $expected = array(
    110                         'foo'  => array( 'bar' ),
    111                         'foo1' => array( 'baz' ),
    112                 );
    113 
    114                 $this->assertEqualSets( $expected, $found );
    115         }
    116 
    117         public function test_get_with_key_should_fetch_all_for_key() {
    118                 if ( ! is_site_meta_supported() ) {
    119                         $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
    120                 }
    121 
    122                 add_site_meta( self::$site_id, 'foo', 'bar' );
    123                 add_site_meta( self::$site_id, 'foo', 'baz' );
    124                 add_site_meta( self::$site_id, 'foo1', 'baz' );
    125 
    126                 $found = get_site_meta( self::$site_id, 'foo' );
    127                 $expected = array( 'bar', 'baz' );
    128 
    129                 $this->assertEqualSets( $expected, $found );
    130         }
    131 
    132         public function test_get_should_respect_single_true() {
    133                 if ( ! is_site_meta_supported() ) {
    134                         $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
    135                 }
    136 
    137                 add_site_meta( self::$site_id, 'foo', 'bar' );
    138                 add_site_meta( self::$site_id, 'foo', 'baz' );
    139 
    140                 $found = get_site_meta( self::$site_id, 'foo', true );
    141                 $this->assertSame( 'bar', $found );
    142         }
    143 
    144         public function test_update_should_pass_to_add_when_no_value_exists_for_key() {
    145                 if ( ! is_site_meta_supported() ) {
    146                         $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
    147                 }
    148 
    149                 $actual = update_site_meta( self::$site_id, 'foo', 'bar' );
    150                 $this->assertInternalType( 'int', $actual );
    151                 $this->assertNotEmpty( $actual );
    152 
    153                 $meta = get_site_meta( self::$site_id, 'foo', true );
    154                 $this->assertSame( 'bar', $meta );
    155         }
    156 
    157         public function test_update_should_return_true_when_updating_existing_value_for_key() {
    158                 if ( ! is_site_meta_supported() ) {
    159                         $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
    160                 }
    161 
    162                 add_site_meta( self::$site_id, 'foo', 'bar' );
    163 
    164                 $actual = update_site_meta( self::$site_id, 'foo', 'baz' );
    165                 $this->assertTrue( $actual );
    166 
    167                 $meta = get_site_meta( self::$site_id, 'foo', true );
    168                 $this->assertSame( 'baz', $meta );
    169         }
    170 
    171         public function test_delete_by_key() {
    172                 if ( ! is_site_meta_supported() ) {
    173                         $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
    174                 }
    175 
    176                 add_site_meta( self::$site_id, 'unique_delete_by_key', 'value', true );
    177                 add_site_meta( self::$site_id2, 'unique_delete_by_key', 'value', true );
    178 
    179                 $this->assertEquals( 'value', get_site_meta( self::$site_id, 'unique_delete_by_key', true ) );
    180                 $this->assertEquals( 'value', get_site_meta( self::$site_id2, 'unique_delete_by_key', true ) );
    181 
    182                 $this->assertTrue( delete_site_meta_by_key( 'unique_delete_by_key' ) );
    183 
    184                 $this->assertEquals( '', get_site_meta( self::$site_id, 'unique_delete_by_key', true ) );
    185                 $this->assertEquals( '', get_site_meta( self::$site_id2, 'unique_delete_by_key', true ) );
    186         }
    187 
    188         public function test_site_meta_should_be_deleted_when_site_is_deleted() {
    189                 if ( ! is_site_meta_supported() ) {
    190                         $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
    191                 }
    192 
    193                 $site_id = self::factory()->blog->create( array( 'domain' => 'foo.org', 'path' => '/' ) );
    194 
    195                 add_site_meta( $site_id, 'foo', 'bar' );
    196                 add_site_meta( $site_id, 'foo1', 'bar' );
    197 
    198                 $this->assertSame( 'bar', get_site_meta( $site_id, 'foo', true ) );
    199                 $this->assertSame( 'bar', get_site_meta( $site_id, 'foo1', true ) );
    200 
    201                 wpmu_delete_blog( $site_id, true );
    202 
    203                 $this->assertSame( '', get_site_meta( $site_id, 'foo', true ) );
    204                 $this->assertSame( '', get_site_meta( $site_id, 'foo1', true ) );
    205         }
    206 
    207         public function test_update_site_meta_cache() {
    208                 global $wpdb;
    209 
    210                 if ( ! is_site_meta_supported() ) {
    211                         $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
    212                 }
    213 
    214                 update_site_meta( self::$site_id, 'foo', 'bar' );
    215                 update_sitemeta_cache( array( self::$site_id ) );
    216 
    217                 $num_queries = $wpdb->num_queries;
    218                 get_site_meta( self::$site_id, 'foo', true );
    219                 $this->assertSame( $num_queries, $wpdb->num_queries);
    220         }
    221 
    222         public function test_query_update_site_meta_cache_true() {
    223                 global $wpdb;
    224 
    225                 if ( ! is_site_meta_supported() ) {
    226                         $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
    227                 }
    228 
    229                 update_site_meta( self::$site_id, 'foo', 'bar' );
    230 
    231                 // Do not include 'update_site_meta_cache' as true as its the default.
    232                 new WP_Site_Query( array(
    233                         'ID' => self::$site_id,
    234                 ) );
    235 
    236                 $num_queries = $wpdb->num_queries;
    237                 get_site_meta( self::$site_id, 'foo', true );
    238                 $this->assertSame( $num_queries, $wpdb->num_queries);
    239         }
    240 
    241         public function test_query_update_site_meta_cache_false() {
    242                 global $wpdb;
    243 
    244                 if ( ! is_site_meta_supported() ) {
    245                         $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
    246                 }
    247 
    248                 update_site_meta( self::$site_id, 'foo', 'bar' );
    249 
    250                 new WP_Site_Query( array(
    251                         'ID'                     => self::$site_id,
    252                         'update_site_meta_cache' => false,
    253                 ) );
    254 
    255                 $num_queries = $wpdb->num_queries;
    256                 get_site_meta( self::$site_id, 'foo', true );
    257                 $this->assertSame( $num_queries + 1, $wpdb->num_queries);
    258         }
    259 
    260         /**
    261          * @ticket 40229
    262          */
    263         public function test_add_site_meta_should_bust_get_sites_cache() {
    264                 if ( ! is_site_meta_supported() ) {
    265                         $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
    266                 }
    267 
    268                 add_site_meta( self::$site_id, 'foo', 'bar' );
    269 
    270                 // Prime cache.
    271                 $found = get_sites( array(
    272                         'fields' => 'ids',
    273                         'meta_query' => array(
    274                                 array(
    275                                         'key' => 'foo',
    276                                         'value' => 'bar',
    277                                 ),
    278                         ),
    279                 ) );
    280 
    281                 $this->assertEqualSets( array( self::$site_id ), $found );
    282 
    283                 add_site_meta( self::$site_id2, 'foo', 'bar' );
    284 
    285                 $found = get_sites( array(
    286                         'fields' => 'ids',
    287                         'meta_query' => array(
    288                                 array(
    289                                         'key' => 'foo',
    290                                         'value' => 'bar',
    291                                 ),
    292                         ),
    293                 ) );
    294 
    295                 $this->assertEqualSets( array( self::$site_id, self::$site_id2 ), $found );
    296         }
    297 
    298         /**
    299          * @ticket 40229
    300          */
    301         public function test_update_site_meta_should_bust_get_sites_cache() {
    302                 if ( ! is_site_meta_supported() ) {
    303                         $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
    304                 }
    305 
    306                 add_site_meta( self::$site_id, 'foo', 'bar' );
    307                 add_site_meta( self::$site_id2, 'foo', 'baz' );
    308 
    309                 // Prime cache.
    310                 $found = get_sites( array(
    311                         'fields' => 'ids',
    312                         'meta_query' => array(
    313                                 array(
    314                                         'key' => 'foo',
    315                                         'value' => 'bar',
    316                                 ),
    317                         ),
    318                 ) );
    319 
    320                 $this->assertEqualSets( array( self::$site_id ), $found );
    321 
    322                 update_site_meta( self::$site_id2, 'foo', 'bar' );
    323 
    324                 $found = get_sites( array(
    325                         'fields' => 'ids',
    326                         'meta_query' => array(
    327                                 array(
    328                                         'key' => 'foo',
    329                                         'value' => 'bar',
    330                                 ),
    331                         ),
    332                 ) );
    333 
    334                 $this->assertEqualSets( array( self::$site_id, self::$site_id2 ), $found );
    335         }
    336 
    337         /**
    338          * @ticket 40229
    339          */
    340         public function test_delete_site_meta_should_bust_get_sites_cache() {
    341                 if ( ! is_site_meta_supported() ) {
    342                         $this->markTestSkipped( 'Tests only runs with the blogmeta database table installed' );
    343                 }
    344 
    345                 add_site_meta( self::$site_id, 'foo', 'bar' );
    346                 add_site_meta( self::$site_id2, 'foo', 'bar' );
    347 
    348                 // Prime cache.
    349                 $found = get_sites( array(
    350                         'fields' => 'ids',
    351                         'meta_query' => array(
    352                                 array(
    353                                         'key' => 'foo',
    354                                         'value' => 'bar',
    355                                 ),
    356                         ),
    357                 ) );
    358 
    359                 $this->assertEqualSets( array( self::$site_id, self::$site_id2 ), $found );
    360 
    361                 delete_site_meta( self::$site_id2, 'foo', 'bar' );
    362 
    363                 $found = get_sites( array(
    364                         'fields' => 'ids',
    365                         'meta_query' => array(
    366                                 array(
    367                                         'key' => 'foo',
    368                                         'value' => 'bar',
    369                                 ),
    370                         ),
    371                 ) );
    372 
    373                 $this->assertEqualSets( array( self::$site_id ), $found );
    374         }
    375 }
    376 
    377408endif;
Note: See TracChangeset for help on using the changeset viewer.