Make WordPress Core

Changeset 54757


Ignore:
Timestamp:
11/06/2022 04:19:15 PM (20 months ago)
Author:
SergeyBiryukov
Message:

Tests: Move update_blog_status() tests to their own file.

Reduce some of the clutter in tests/multisite/site.php and introduce tests/multisite/updateBlogStatus.php. Tests moved over are verbatim at this point.

Follow-up to [1078/tests], [29916], [30784], [30785], [33253].

See #56793.

Location:
trunk/tests/phpunit/tests/multisite
Files:
2 edited
1 copied

Legend:

Unmodified
Added
Removed
  • trunk/tests/phpunit/tests/multisite/site.php

    r54756 r54757  
    442442
    443443        /**
    444          * Updating a field returns the sme value that was passed.
    445          */
    446         public function test_update_blog_status() {
    447             $result = update_blog_status( 1, 'spam', 0 );
    448             $this->assertSame( 0, $result );
    449         }
    450 
    451         /**
    452          * Updating an invalid field returns the same value that was passed.
    453          */
    454         public function test_update_blog_status_invalid_status() {
    455             $result = update_blog_status( 1, 'doesnotexist', 'invalid' );
    456             $this->assertSame( 'invalid', $result );
    457         }
    458 
    459         public function test_update_blog_status_make_ham_blog_action() {
    460             $test_action_counter = new MockAction();
    461 
    462             $blog_id = self::factory()->blog->create();
    463             update_blog_details( $blog_id, array( 'spam' => 1 ) );
    464 
    465             add_action( 'make_ham_blog', array( $test_action_counter, 'action' ) );
    466             update_blog_status( $blog_id, 'spam', 0 );
    467             $blog = get_site( $blog_id );
    468 
    469             $this->assertSame( '0', $blog->spam );
    470             $this->assertSame( 1, $test_action_counter->get_call_count() );
    471 
    472             // The action should not fire if the status of 'spam' stays the same.
    473             update_blog_status( $blog_id, 'spam', 0 );
    474             $blog = get_site( $blog_id );
    475 
    476             $this->assertSame( '0', $blog->spam );
    477             $this->assertSame( 1, $test_action_counter->get_call_count() );
    478         }
    479 
    480         public function test_content_from_spam_blog_is_not_available() {
    481             $spam_blog_id = self::factory()->blog->create();
    482             switch_to_blog( $spam_blog_id );
    483             $post_data      = array(
    484                 'post_title'   => 'Hello World!',
    485                 'post_content' => 'Hello world content',
    486             );
    487             $post_id        = self::factory()->post->create( $post_data );
    488             $post           = get_post( $post_id );
    489             $spam_permalink = site_url() . '/?p=' . $post->ID;
    490             $spam_embed_url = get_post_embed_url( $post_id );
    491 
    492             restore_current_blog();
    493             $this->assertNotEmpty( $spam_permalink );
    494             $this->assertSame( $post_data['post_title'], $post->post_title );
    495 
    496             update_blog_status( $spam_blog_id, 'spam', 1 );
    497 
    498             $post_id = self::factory()->post->create(
    499                 array(
    500                     'post_content' => "\n $spam_permalink \n",
    501                 )
    502             );
    503             $post    = get_post( $post_id );
    504             $content = apply_filters( 'the_content', $post->post_content );
    505 
    506             $this->assertStringNotContainsString( $post_data['post_title'], $content );
    507             $this->assertStringNotContainsString( "src=\"{$spam_embed_url}#?", $content );
    508         }
    509 
    510         public function test_update_blog_status_make_spam_blog_action() {
    511             $test_action_counter = new MockAction();
    512 
    513             $blog_id = self::factory()->blog->create();
    514 
    515             add_action( 'make_spam_blog', array( $test_action_counter, 'action' ) );
    516             update_blog_status( $blog_id, 'spam', 1 );
    517             $blog = get_site( $blog_id );
    518 
    519             $this->assertSame( '1', $blog->spam );
    520             $this->assertSame( 1, $test_action_counter->get_call_count() );
    521 
    522             // The action should not fire if the status of 'spam' stays the same.
    523             update_blog_status( $blog_id, 'spam', 1 );
    524             $blog = get_site( $blog_id );
    525 
    526             $this->assertSame( '1', $blog->spam );
    527             $this->assertSame( 1, $test_action_counter->get_call_count() );
    528         }
    529 
    530         public function test_update_blog_status_archive_blog_action() {
    531             $test_action_counter = new MockAction();
    532 
    533             $blog_id = self::factory()->blog->create();
    534 
    535             add_action( 'archive_blog', array( $test_action_counter, 'action' ) );
    536             update_blog_status( $blog_id, 'archived', 1 );
    537             $blog = get_site( $blog_id );
    538 
    539             $this->assertSame( '1', $blog->archived );
    540             $this->assertSame( 1, $test_action_counter->get_call_count() );
    541 
    542             // The action should not fire if the status of 'archived' stays the same.
    543             update_blog_status( $blog_id, 'archived', 1 );
    544             $blog = get_site( $blog_id );
    545 
    546             $this->assertSame( '1', $blog->archived );
    547             $this->assertSame( 1, $test_action_counter->get_call_count() );
    548         }
    549 
    550         public function test_update_blog_status_unarchive_blog_action() {
    551             $test_action_counter = new MockAction();
    552 
    553             $blog_id = self::factory()->blog->create();
    554             update_blog_details( $blog_id, array( 'archived' => 1 ) );
    555 
    556             add_action( 'unarchive_blog', array( $test_action_counter, 'action' ) );
    557             update_blog_status( $blog_id, 'archived', 0 );
    558             $blog = get_site( $blog_id );
    559 
    560             $this->assertSame( '0', $blog->archived );
    561             $this->assertSame( 1, $test_action_counter->get_call_count() );
    562 
    563             // The action should not fire if the status of 'archived' stays the same.
    564             update_blog_status( $blog_id, 'archived', 0 );
    565             $blog = get_site( $blog_id );
    566             $this->assertSame( '0', $blog->archived );
    567             $this->assertSame( 1, $test_action_counter->get_call_count() );
    568         }
    569 
    570         public function test_update_blog_status_make_delete_blog_action() {
    571             $test_action_counter = new MockAction();
    572 
    573             $blog_id = self::factory()->blog->create();
    574 
    575             add_action( 'make_delete_blog', array( $test_action_counter, 'action' ) );
    576             update_blog_status( $blog_id, 'deleted', 1 );
    577             $blog = get_site( $blog_id );
    578 
    579             $this->assertSame( '1', $blog->deleted );
    580             $this->assertSame( 1, $test_action_counter->get_call_count() );
    581 
    582             // The action should not fire if the status of 'deleted' stays the same.
    583             update_blog_status( $blog_id, 'deleted', 1 );
    584             $blog = get_site( $blog_id );
    585 
    586             $this->assertSame( '1', $blog->deleted );
    587             $this->assertSame( 1, $test_action_counter->get_call_count() );
    588         }
    589 
    590         public function test_update_blog_status_make_undelete_blog_action() {
    591             $test_action_counter = new MockAction();
    592 
    593             $blog_id = self::factory()->blog->create();
    594             update_blog_details( $blog_id, array( 'deleted' => 1 ) );
    595 
    596             add_action( 'make_undelete_blog', array( $test_action_counter, 'action' ) );
    597             update_blog_status( $blog_id, 'deleted', 0 );
    598             $blog = get_site( $blog_id );
    599 
    600             $this->assertSame( '0', $blog->deleted );
    601             $this->assertSame( 1, $test_action_counter->get_call_count() );
    602 
    603             // The action should not fire if the status of 'deleted' stays the same.
    604             update_blog_status( $blog_id, 'deleted', 0 );
    605             $blog = get_site( $blog_id );
    606 
    607             $this->assertSame( '0', $blog->deleted );
    608             $this->assertSame( 1, $test_action_counter->get_call_count() );
    609         }
    610 
    611         public function test_update_blog_status_mature_blog_action() {
    612             $test_action_counter = new MockAction();
    613 
    614             $blog_id = self::factory()->blog->create();
    615 
    616             add_action( 'mature_blog', array( $test_action_counter, 'action' ) );
    617             update_blog_status( $blog_id, 'mature', 1 );
    618             $blog = get_site( $blog_id );
    619 
    620             $this->assertSame( '1', $blog->mature );
    621             $this->assertSame( 1, $test_action_counter->get_call_count() );
    622 
    623             // The action should not fire if the status of 'mature' stays the same.
    624             update_blog_status( $blog_id, 'mature', 1 );
    625             $blog = get_site( $blog_id );
    626 
    627             $this->assertSame( '1', $blog->mature );
    628             $this->assertSame( 1, $test_action_counter->get_call_count() );
    629         }
    630 
    631         public function test_update_blog_status_unmature_blog_action() {
    632             $test_action_counter = new MockAction();
    633 
    634             $blog_id = self::factory()->blog->create();
    635             update_blog_details( $blog_id, array( 'mature' => 1 ) );
    636 
    637             add_action( 'unmature_blog', array( $test_action_counter, 'action' ) );
    638             update_blog_status( $blog_id, 'mature', 0 );
    639 
    640             $blog = get_site( $blog_id );
    641             $this->assertSame( '0', $blog->mature );
    642             $this->assertSame( 1, $test_action_counter->get_call_count() );
    643 
    644             // The action should not fire if the status of 'mature' stays the same.
    645             update_blog_status( $blog_id, 'mature', 0 );
    646             $blog = get_site( $blog_id );
    647 
    648             $this->assertSame( '0', $blog->mature );
    649             $this->assertSame( 1, $test_action_counter->get_call_count() );
    650         }
    651 
    652         public function test_update_blog_status_update_blog_public_action() {
    653             $test_action_counter = new MockAction();
    654 
    655             $blog_id = self::factory()->blog->create();
    656 
    657             add_action( 'update_blog_public', array( $test_action_counter, 'action' ) );
    658             update_blog_status( $blog_id, 'public', 0 );
    659 
    660             $blog = get_site( $blog_id );
    661             $this->assertSame( '0', $blog->public );
    662             $this->assertSame( 1, $test_action_counter->get_call_count() );
    663 
    664             // The action should not fire if the status of 'mature' stays the same.
    665             update_blog_status( $blog_id, 'public', 0 );
    666             $blog = get_site( $blog_id );
    667 
    668             $this->assertSame( '0', $blog->public );
    669             $this->assertSame( 1, $test_action_counter->get_call_count() );
    670         }
    671 
    672         /**
    673444         * @ticket 27952
    674445         */
  • trunk/tests/phpunit/tests/multisite/updateBlogDetails.php

    r54756 r54757  
    88     */
    99    class Tests_Multisite_UpdateBlogDetails extends WP_UnitTestCase {
     10
    1011        /**
    1112         * If `update_blog_details()` is called with any kind of empty arguments, it
  • trunk/tests/phpunit/tests/multisite/updateBlogStatus.php

    r54756 r54757  
    44
    55    /**
    6      * Tests specific to sites in multisite.
    7      *
    86     * @group ms-site
    97     * @group multisite
    108     */
    11     class Tests_Multisite_Site extends WP_UnitTestCase {
    12         protected $suppress                = false;
    13         protected $site_status_hooks       = array();
    14         protected $wp_initialize_site_args = array();
    15         protected $wp_initialize_site_meta = array();
    16         protected static $network_ids;
    17         protected static $site_ids;
    18         protected static $uninitialized_site_id;
    19 
    20         public function set_up() {
    21             global $wpdb;
    22             parent::set_up();
    23             $this->suppress = $wpdb->suppress_errors();
    24         }
    25 
    26         public function tear_down() {
    27             global $wpdb;
    28             $wpdb->suppress_errors( $this->suppress );
    29             parent::tear_down();
    30         }
    31 
    32         public static function wpSetUpBeforeClass( WP_UnitTest_Factory $factory ) {
    33             self::$network_ids = array(
    34                 'make.wordpress.org/' => array(
    35                     'domain' => 'make.wordpress.org',
    36                     'path'   => '/',
    37                 ),
    38             );
    39 
    40             foreach ( self::$network_ids as &$id ) {
    41                 $id = $factory->network->create( $id );
    42             }
    43             unset( $id );
    44 
    45             self::$site_ids = array(
    46                 'make.wordpress.org/'     => array(
    47                     'domain'     => 'make.wordpress.org',
    48                     'path'       => '/',
    49                     'network_id' => self::$network_ids['make.wordpress.org/'],
    50                 ),
    51                 'make.wordpress.org/foo/' => array(
    52                     'domain'     => 'make.wordpress.org',
    53                     'path'       => '/foo/',
    54                     'network_id' => self::$network_ids['make.wordpress.org/'],
    55                 ),
    56             );
    57 
    58             foreach ( self::$site_ids as &$id ) {
    59                 $id = $factory->blog->create( $id );
    60             }
    61             unset( $id );
    62 
    63             remove_action( 'wp_initialize_site', 'wp_initialize_site', 10 );
    64             self::$uninitialized_site_id = wp_insert_site(
    65                 array(
    66                     'domain'     => 'uninitialized.org',
    67                     'path'       => '/',
    68                     'network_id' => self::$network_ids['make.wordpress.org/'],
    69                 )
    70             );
    71             add_action( 'wp_initialize_site', 'wp_initialize_site', 10, 2 );
    72         }
    73 
    74         public static function wpTearDownAfterClass() {
    75             global $wpdb;
    76 
    77             remove_action( 'wp_uninitialize_site', 'wp_uninitialize_site', 10 );
    78             wp_delete_site( self::$uninitialized_site_id );
    79             add_action( 'wp_uninitialize_site', 'wp_uninitialize_site', 10, 1 );
    80 
    81             foreach ( self::$site_ids as $id ) {
    82                 wp_delete_site( $id );
    83             }
    84 
    85             foreach ( self::$network_ids as $id ) {
    86                 $wpdb->query( $wpdb->prepare( "DELETE FROM {$wpdb->sitemeta} WHERE site_id = %d", $id ) );
    87                 $wpdb->query( $wpdb->prepare( "DELETE FROM {$wpdb->site} WHERE id= %d", $id ) );
    88             }
    89         }
    90 
    91         public function test_switch_restore_blog() {
    92             global $_wp_switched_stack, $wpdb;
    93 
    94             $this->assertSame( array(), $_wp_switched_stack );
    95             $this->assertFalse( ms_is_switched() );
    96             $current_blog_id = get_current_blog_id();
    97             $this->assertIsInt( $current_blog_id );
    98 
    99             wp_cache_set( 'switch-test', $current_blog_id, 'switch-test' );
    100             $this->assertSame( $current_blog_id, wp_cache_get( 'switch-test', 'switch-test' ) );
    101 
    102             $blog_id = self::factory()->blog->create();
    103 
    104             $cap_key = wp_get_current_user()->cap_key;
    105             switch_to_blog( $blog_id );
    106             $this->assertNotEquals( $cap_key, wp_get_current_user()->cap_key );
    107             $this->assertSame( array( $current_blog_id ), $_wp_switched_stack );
    108             $this->assertTrue( ms_is_switched() );
    109             $this->assertSame( $blog_id, $wpdb->blogid );
    110             $this->assertFalse( wp_cache_get( 'switch-test', 'switch-test' ) );
    111             wp_cache_set( 'switch-test', $blog_id, 'switch-test' );
    112             $this->assertSame( $blog_id, wp_cache_get( 'switch-test', 'switch-test' ) );
    113 
    114             switch_to_blog( $blog_id );
    115             $this->assertSame( array( $current_blog_id, $blog_id ), $_wp_switched_stack );
    116             $this->assertTrue( ms_is_switched() );
    117             $this->assertSame( $blog_id, $wpdb->blogid );
    118             $this->assertSame( $blog_id, wp_cache_get( 'switch-test', 'switch-test' ) );
    119 
    120             restore_current_blog();
    121             $this->assertSame( array( $current_blog_id ), $_wp_switched_stack );
    122             $this->assertTrue( ms_is_switched() );
    123             $this->assertSame( $blog_id, $wpdb->blogid );
    124             $this->assertSame( $blog_id, wp_cache_get( 'switch-test', 'switch-test' ) );
    125 
    126             restore_current_blog();
    127             $this->assertSame( $cap_key, wp_get_current_user()->cap_key );
    128             $this->assertSame( $current_blog_id, get_current_blog_id() );
    129             $this->assertSame( array(), $_wp_switched_stack );
    130             $this->assertFalse( ms_is_switched() );
    131             $this->assertSame( $current_blog_id, wp_cache_get( 'switch-test', 'switch-test' ) );
    132 
    133             $this->assertFalse( restore_current_blog() );
    134         }
    135 
    136         /**
    137          * Test the cache keys and database tables setup through the creation of a site.
    138          */
    139         public function test_created_site_details() {
    140             global $wpdb;
    141 
    142             $blog_id = self::factory()->blog->create();
    143 
    144             $this->assertIsInt( $blog_id );
    145             $prefix = $wpdb->get_blog_prefix( $blog_id );
    146 
    147             // $get_all = false, only retrieve details from the blogs table.
    148             $details = get_blog_details( $blog_id, false );
    149 
    150             // Combine domain and path for a site specific cache key.
    151             $key = md5( $details->domain . $details->path );
    152 
    153             $this->assertEquals( $details, wp_cache_get( $blog_id . 'short', 'blog-details' ) );
    154 
    155             // get_blogaddress_by_name().
    156             $this->assertSame( 'http://' . $details->domain . $details->path, get_blogaddress_by_name( trim( $details->path, '/' ) ) );
    157 
    158             // These are empty until get_blog_details() is called with $get_all = true.
    159             $this->assertFalse( wp_cache_get( $blog_id, 'blog-details' ) );
    160             $this->assertFalse( wp_cache_get( $key, 'blog-lookup' ) );
    161 
    162             // $get_all = true, populate the full blog-details cache and the blog slug lookup cache.
    163             $details = get_blog_details( $blog_id, true );
    164             $this->assertEquals( $details, wp_cache_get( $blog_id, 'blog-details' ) );
    165             $this->assertEquals( $details, wp_cache_get( $key, 'blog-lookup' ) );
    166 
    167             // Check existence of each database table for the created site.
    168             foreach ( $wpdb->tables( 'blog', false ) as $table ) {
    169                 $suppress = $wpdb->suppress_errors();
    170 
    171                 // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared
    172                 $table_fields = $wpdb->get_results( "DESCRIBE $prefix$table;" );
    173 
    174                 $wpdb->suppress_errors( $suppress );
    175 
    176                 // The table should exist.
    177                 $this->assertNotEmpty( $table_fields );
    178 
    179                 // And the table should not be empty, unless commentmeta, termmeta, or links.
    180                 // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared
    181                 $result = $wpdb->get_results( "SELECT * FROM $prefix$table LIMIT 1" );
    182 
    183                 if ( 'commentmeta' === $table || 'termmeta' === $table || 'links' === $table ) {
    184                     $this->assertEmpty( $result );
    185                 } else {
    186                     $this->assertNotEmpty( $result );
    187                 }
    188             }
    189 
    190             // Update the blog count cache to use get_blog_count().
    191             wp_update_network_counts();
    192             $this->assertSame( 2, (int) get_blog_count() );
    193         }
    194 
    195         public function test_site_caches_should_invalidate_when_invalidation_is_not_suspended() {
    196             $site_id = self::factory()->blog->create();
    197 
    198             $details = get_site( $site_id );
    199 
    200             $suspend = wp_suspend_cache_invalidation( false );
    201             update_blog_details( $site_id, array( 'path' => '/a-non-random-test-path/' ) );
    202             $new_details = get_site( $site_id );
    203             wp_suspend_cache_invalidation( $suspend );
    204 
    205             $this->assertNotEquals( $details->path, $new_details->path );
    206         }
    207 
    208         public function test_site_caches_should_not_invalidate_when_invalidation_is_suspended() {
    209             $site_id = self::factory()->blog->create();
    210 
    211             $details = get_site( $site_id );
    212 
    213             $suspend = wp_suspend_cache_invalidation();
    214             update_blog_details( $site_id, array( 'path' => '/a-non-random-test-path/' ) );
    215             $new_details = get_site( $site_id );
    216             wp_suspend_cache_invalidation( $suspend );
    217 
    218             $this->assertSame( $details->path, $new_details->path );
    219         }
    220 
    221         /**
    222          * When a site is flagged as 'deleted', its data should be cleared from cache.
    223          */
    224         public function test_data_in_cache_after_wpmu_delete_blog_drop_false() {
    225             $blog_id = self::factory()->blog->create();
    226 
    227             $details = get_blog_details( $blog_id, false );
    228             $key     = md5( $details->domain . $details->path );
    229 
    230             // Delete the site without forcing a table drop.
    231             wpmu_delete_blog( $blog_id, false );
    232 
    233             $this->assertFalse( wp_cache_get( $blog_id, 'blog-details' ) );
    234             $this->assertFalse( wp_cache_get( $blog_id . 'short', 'blog-details' ) );
    235             $this->assertFalse( wp_cache_get( $key, 'blog-lookup' ) );
    236             $this->assertFalse( wp_cache_get( $key, 'blog-id-cache' ) );
    237         }
    238 
    239         /**
    240          * When a site is flagged as 'deleted', its data should remain in the database.
    241          */
    242         public function test_data_in_tables_after_wpmu_delete_blog_drop_false() {
    243             global $wpdb;
    244 
    245             $blog_id = self::factory()->blog->create();
    246 
    247             // Delete the site without forcing a table drop.
    248             wpmu_delete_blog( $blog_id, false );
    249 
    250             $prefix = $wpdb->get_blog_prefix( $blog_id );
    251             foreach ( $wpdb->tables( 'blog', false ) as $table ) {
    252                 $suppress = $wpdb->suppress_errors();
    253 
    254                 // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared
    255                 $table_fields = $wpdb->get_results( "DESCRIBE $prefix$table;" );
    256 
    257                 $wpdb->suppress_errors( $suppress );
    258                 $this->assertNotEmpty( $table_fields, $prefix . $table );
    259             }
    260         }
    261 
    262         /**
    263          * When a site is fully deleted, its data should be cleared from cache.
    264          */
    265         public function test_data_in_cache_after_wpmu_delete_blog_drop_true() {
    266             $blog_id = self::factory()->blog->create();
    267 
    268             $details = get_blog_details( $blog_id, false );
    269             $key     = md5( $details->domain . $details->path );
    270 
    271             // Delete the site and force a table drop.
    272             wpmu_delete_blog( $blog_id, true );
    273 
    274             $this->assertFalse( wp_cache_get( $blog_id, 'blog-details' ) );
    275             $this->assertFalse( wp_cache_get( $blog_id . 'short', 'blog-details' ) );
    276             $this->assertFalse( wp_cache_get( $key, 'blog-lookup' ) );
    277             $this->assertFalse( wp_cache_get( $key, 'blog-id-cache' ) );
    278         }
    279 
    280         /**
    281          * When a site is fully deleted, its data should be removed from the database.
    282          */
    283         public function test_data_in_tables_after_wpmu_delete_blog_drop_true() {
    284             global $wpdb;
    285 
    286             $blog_id = self::factory()->blog->create();
    287 
    288             // Delete the site and force a table drop.
    289             wpmu_delete_blog( $blog_id, true );
    290 
    291             $prefix = $wpdb->get_blog_prefix( $blog_id );
    292             foreach ( $wpdb->tables( 'blog', false ) as $table ) {
    293                 $suppress = $wpdb->suppress_errors();
    294 
    295                 // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared
    296                 $table_fields = $wpdb->get_results( "DESCRIBE $prefix$table;" );
    297 
    298                 $wpdb->suppress_errors( $suppress );
    299                 $this->assertEmpty( $table_fields );
    300             }
    301         }
    302 
    303         /**
    304          * When the main site of a network is fully deleted, its data should be cleared from cache.
    305          */
    306         public function test_data_in_cache_after_wpmu_delete_blog_main_site_drop_true() {
    307             $blog_id = 1; // The main site in our test suite has an ID of 1.
    308 
    309             $details = get_blog_details( $blog_id, false );
    310             $key     = md5( $details->domain . $details->path );
    311 
    312             // Delete the site and force a table drop.
    313             wpmu_delete_blog( $blog_id, true );
    314 
    315             $this->assertFalse( wp_cache_get( $blog_id, 'blog-details' ) );
    316             $this->assertFalse( wp_cache_get( $blog_id . 'short', 'blog-details' ) );
    317             $this->assertFalse( wp_cache_get( $key, 'blog-lookup' ) );
    318             $this->assertFalse( wp_cache_get( $key, 'blog-id-cache' ) );
    319         }
    320 
    321         /**
    322          * When the main site of a network is fully deleted, its data should remain in the database.
    323          */
    324         public function test_data_in_tables_after_wpmu_delete_blog_main_site_drop_true() {
    325             global $wpdb;
    326 
    327             $blog_id = 1; // The main site in our test suite has an ID of 1.
    328 
    329             // Delete the site and force a table drop.
    330             wpmu_delete_blog( $blog_id, true );
    331 
    332             $prefix = $wpdb->get_blog_prefix( $blog_id );
    333             foreach ( $wpdb->tables( 'blog', false ) as $table ) {
    334                 $suppress = $wpdb->suppress_errors();
    335 
    336                 // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared
    337                 $table_fields = $wpdb->get_results( "DESCRIBE $prefix$table;" );
    338 
    339                 $wpdb->suppress_errors( $suppress );
    340                 $this->assertNotEmpty( $table_fields, $prefix . $table );
    341             }
    342         }
    343 
    344         /**
    345          * The site count of a network should change when a site is flagged as 'deleted'.
    346          */
    347         public function test_network_count_after_wpmu_delete_blog_drop_false() {
    348             $blog_id = self::factory()->blog->create();
    349 
    350             // Delete the site without forcing a table drop.
    351             wpmu_delete_blog( $blog_id, false );
    352 
    353             // Update the blog count cache to use get_blog_count().
    354             wp_update_network_counts();
    355             $this->assertSame( 1, get_blog_count() );
    356         }
    357 
    358         /**
    359          * The site count of a network should change when a site is fully deleted.
    360          */
    361         public function test_blog_count_after_wpmu_delete_blog_drop_true() {
    362             $blog_id = self::factory()->blog->create();
    363 
    364             // Delete the site and force a table drop.
    365             wpmu_delete_blog( $blog_id, true );
    366 
    367             // Update the blog count cache to use get_blog_count().
    368             wp_update_network_counts();
    369             $this->assertSame( 1, get_blog_count() );
    370         }
    371 
    372         /**
    373          * When a site is deleted with wpmu_delete_blog(), only the files associated with
    374          * that site should be removed. When wpmu_delete_blog() is run a second time, nothing
    375          * should change with upload directories.
    376          */
    377         public function test_upload_directories_after_multiple_wpmu_delete_blog() {
    378             $filename = __FUNCTION__ . '.jpg';
    379             $contents = __FUNCTION__ . '_contents';
    380 
    381             // Upload a file to the main site on the network.
    382             $file1 = wp_upload_bits( $filename, null, $contents );
    383 
    384             $blog_id = self::factory()->blog->create();
    385 
    386             switch_to_blog( $blog_id );
    387             $file2 = wp_upload_bits( $filename, null, $contents );
    388             restore_current_blog();
    389 
    390             wpmu_delete_blog( $blog_id, true );
    391 
    392             // The file on the main site should still exist. The file on the deleted site should not.
    393             $this->assertFileExists( $file1['file'] );
    394             $this->assertFileDoesNotExist( $file2['file'] );
    395 
    396             wpmu_delete_blog( $blog_id, true );
    397 
    398             // The file on the main site should still exist. The file on the deleted site should not.
    399             $this->assertFileExists( $file1['file'] );
    400             $this->assertFileDoesNotExist( $file2['file'] );
    401         }
    402 
    403         public function test_wpmu_update_blogs_date() {
    404             global $wpdb;
    405 
    406             wpmu_update_blogs_date();
    407 
    408             $blog         = get_site( get_current_blog_id() );
    409             $current_time = time();
    410 
    411             // Compare the update time with the current time, allow delta < 2.
    412             $this->assertEqualsWithDelta( $current_time, strtotime( $blog->last_updated ), 2, 'The dates should be equal' );
    413         }
    414 
    415         /**
    416          * Test cached data for a site that does not exist and then again after it exists.
    417          *
    418          * @ticket 23405
    419          */
    420         public function test_get_blog_details_when_site_does_not_exist() {
    421             // Create an unused site so that we can then assume an invalid site ID.
    422             $blog_id = self::factory()->blog->create();
    423             $blog_id++;
    424 
    425             // Prime the cache for an invalid site.
    426             get_blog_details( $blog_id );
    427 
    428             // When the cache is primed with an invalid site, the value is set to -1.
    429             $this->assertSame( -1, wp_cache_get( $blog_id, 'blog-details' ) );
    430 
    431             // Create a site in the invalid site's place.
    432             self::factory()->blog->create();
    433 
    434             // When a new site is created, its cache is cleared through refresh_blog_details.
    435             $this->assertFalse( wp_cache_get( $blog_id, 'blog-details' ) );
    436 
    437             $blog = get_blog_details( $blog_id );
    438 
    439             // When the cache is refreshed, it should now equal the site data.
    440             $this->assertEquals( $blog, wp_cache_get( $blog_id, 'blog-details' ) );
    441         }
     9    class Tests_Multisite_UpdateBlogStatus extends WP_UnitTestCase {
    44210
    44311        /**
     
    669237            $this->assertSame( 1, $test_action_counter->get_call_count() );
    670238        }
    671 
    672         /**
    673          * @ticket 27952
    674          */
    675         public function test_posts_count() {
    676             self::factory()->post->create();
    677             $post2 = self::factory()->post->create();
    678             $this->assertSame( 2, get_site()->post_count );
    679 
    680             wp_delete_post( $post2 );
    681             $this->assertSame( 1, get_site()->post_count );
    682         }
    683 
    684         /**
    685          * @ticket 26410
    686          */
    687         public function test_blog_details_cache_invalidation() {
    688             update_option( 'blogname', 'foo' );
    689             $details = get_site( get_current_blog_id() );
    690             $this->assertSame( 'foo', $details->blogname );
    691 
    692             update_option( 'blogname', 'bar' );
    693             $details = get_site( get_current_blog_id() );
    694             $this->assertSame( 'bar', $details->blogname );
    695         }
    696 
    697         /**
    698          * Test the original and cached responses for a created and then deleted site when
    699          * the blog ID is requested through get_blog_id_from_url().
    700          */
    701         public function test_get_blog_id_from_url() {
    702             $blog_id = self::factory()->blog->create();
    703             $details = get_site( $blog_id );
    704             $key     = md5( $details->domain . $details->path );
    705 
    706             // Test the original response and cached response for the newly created site.
    707             $this->assertSame( $blog_id, get_blog_id_from_url( $details->domain, $details->path ) );
    708             $this->assertSame( $blog_id, wp_cache_get( $key, 'blog-id-cache' ) );
    709         }
    710 
    711         /**
    712          * Test the case insensitivity of the site lookup.
    713          */
    714         public function test_get_blog_id_from_url_is_case_insensitive() {
    715             $blog_id = self::factory()->blog->create(
    716                 array(
    717                     'domain' => 'example.com',
    718                     'path'   => '/xyz',
    719                 )
    720             );
    721             $details = get_site( $blog_id );
    722 
    723             $this->assertSame( $blog_id, get_blog_id_from_url( strtoupper( $details->domain ), strtoupper( $details->path ) ) );
    724         }
    725 
    726         /**
    727          * Test the first and cached responses for a site that does not exist.
    728          */
    729         public function test_get_blog_id_from_url_that_does_not_exist() {
    730             $blog_id = self::factory()->blog->create( array( 'path' => '/xyz' ) );
    731             $details = get_site( $blog_id );
    732 
    733             $this->assertSame( 0, get_blog_id_from_url( $details->domain, 'foo' ) );
    734             $this->assertSame( -1, wp_cache_get( md5( $details->domain . 'foo' ), 'blog-id-cache' ) );
    735         }
    736 
    737         /**
    738          * A blog ID is still available if only the `deleted` flag is set for a site. The same
    739          * behavior would be expected if passing `false` explicitly to `wpmu_delete_blog()`.
    740          */
    741         public function test_get_blog_id_from_url_with_deleted_flag() {
    742             $blog_id = self::factory()->blog->create();
    743             $details = get_site( $blog_id );
    744             $key     = md5( $details->domain . $details->path );
    745             wpmu_delete_blog( $blog_id );
    746 
    747             $this->assertSame( $blog_id, get_blog_id_from_url( $details->domain, $details->path ) );
    748             $this->assertSame( $blog_id, wp_cache_get( $key, 'blog-id-cache' ) );
    749         }
    750 
    751         /**
    752          * When deleted with the drop parameter as true, the cache will first be false, then set to
    753          * -1 after an attempt at `get_blog_id_from_url()` is made.
    754          */
    755         public function test_get_blog_id_from_url_after_dropped() {
    756             $blog_id = self::factory()->blog->create();
    757             $details = get_site( $blog_id );
    758             $key     = md5( $details->domain . $details->path );
    759             wpmu_delete_blog( $blog_id, true );
    760 
    761             $this->assertFalse( wp_cache_get( $key, 'blog-id-cache' ) );
    762             $this->assertSame( 0, get_blog_id_from_url( $details->domain, $details->path ) );
    763             $this->assertSame( -1, wp_cache_get( $key, 'blog-id-cache' ) );
    764         }
    765 
    766         /**
    767          * Test with default parameter of site_id as null.
    768          */
    769         public function test_is_main_site() {
    770             $this->assertTrue( is_main_site() );
    771         }
    772 
    773         /**
    774          * Test with a site id of get_current_blog_id(), which should be the same as the
    775          * default parameter tested above.
    776          */
    777         public function test_current_blog_id_is_main_site() {
    778             $this->assertTrue( is_main_site( get_current_blog_id() ) );
    779         }
    780 
    781         /**
    782          * Test with a site ID other than the main site to ensure a false response.
    783          */
    784         public function test_is_main_site_is_false_with_other_blog_id() {
    785             $blog_id = self::factory()->blog->create();
    786 
    787             $this->assertFalse( is_main_site( $blog_id ) );
    788         }
    789 
    790         /**
    791          * Test with no passed ID after switching to another site ID.
    792          */
    793         public function test_is_main_site_is_false_after_switch_to_blog() {
    794             $blog_id = self::factory()->blog->create();
    795             switch_to_blog( $blog_id );
    796 
    797             $this->assertFalse( is_main_site() );
    798 
    799             restore_current_blog();
    800         }
    801 
    802         public function test_switch_upload_dir() {
    803             $this->assertTrue( is_main_site() );
    804 
    805             $site = get_current_site();
    806             $date = date_format( date_create( 'now' ), 'Y/m' );
    807 
    808             $info = wp_upload_dir();
    809             $this->assertSame( 'http://' . $site->domain . '/wp-content/uploads/' . $date, $info['url'] );
    810             $this->assertSame( ABSPATH . 'wp-content/uploads/' . $date, $info['path'] );
    811             $this->assertSame( '/' . $date, $info['subdir'] );
    812             $this->assertFalse( $info['error'] );
    813 
    814             $blog_id = self::factory()->blog->create();
    815 
    816             switch_to_blog( $blog_id );
    817             $info = wp_upload_dir();
    818             $this->assertSame( 'http://' . $site->domain . '/wp-content/uploads/sites/' . get_current_blog_id() . '/' . $date, $info['url'] );
    819             $this->assertSame( ABSPATH . 'wp-content/uploads/sites/' . get_current_blog_id() . '/' . $date, $info['path'] );
    820             $this->assertSame( '/' . $date, $info['subdir'] );
    821             $this->assertFalse( $info['error'] );
    822             restore_current_blog();
    823 
    824             $info = wp_upload_dir();
    825             $this->assertSame( 'http://' . $site->domain . '/wp-content/uploads/' . $date, $info['url'] );
    826             $this->assertSame( ABSPATH . 'wp-content/uploads/' . $date, $info['path'] );
    827             $this->assertSame( '/' . $date, $info['subdir'] );
    828             $this->assertFalse( $info['error'] );
    829         }
    830 
    831         /**
    832          * Test the primary purpose of get_blog_post(), to retrieve a post from
    833          * another site on the network.
    834          */
    835         public function test_get_blog_post_from_another_site_on_network() {
    836             $blog_id = self::factory()->blog->create();
    837             $post_id = self::factory()->post->create(); // Create a post on the primary site, ID 1.
    838             $post    = get_post( $post_id );
    839             switch_to_blog( $blog_id );
    840 
    841             // The post created and retrieved on the main site should match the one retrieved "remotely".
    842             $this->assertEquals( $post, get_blog_post( 1, $post_id ) );
    843 
    844             restore_current_blog();
    845         }
    846 
    847         /**
    848          * If get_blog_post() is used on the same site, it should still work.
    849          */
    850         public function test_get_blog_post_from_same_site() {
    851             $post_id = self::factory()->post->create();
    852 
    853             $this->assertEquals( get_blog_post( 1, $post_id ), get_post( $post_id ) );
    854         }
    855 
    856         /**
    857          * A null response should be returned if an invalid post is requested.
    858          */
    859         public function test_get_blog_post_invalid_returns_null() {
    860             $this->assertNull( get_blog_post( 1, 999999 ) );
    861         }
    862 
    863         /**
    864          * Added as a callback to the domain_exists filter to provide manual results for
    865          * the testing of the filter and for a test which does not need the database.
    866          */
    867         public function domain_exists_cb( $exists, $domain, $path, $site_id ) {
    868             if ( 'foo' === $domain && 'bar/' === $path ) {
    869                 return 1234;
    870             } else {
    871                 return null;
    872             }
    873         }
    874 
    875         public function test_domain_exists_with_default_site_id() {
    876             $details = get_site( 1 );
    877 
    878             $this->assertSame( 1, domain_exists( $details->domain, $details->path ) );
    879         }
    880 
    881         public function test_domain_exists_with_specified_site_id() {
    882             $details = get_site( 1 );
    883 
    884             $this->assertSame( 1, domain_exists( $details->domain, $details->path, $details->site_id ) );
    885         }
    886 
    887         /**
    888          * When the domain is valid, but the resulting site does not belong to the specified network,
    889          * it is marked as not existing.
    890          */
    891         public function test_domain_does_not_exist_with_invalid_site_id() {
    892             $details = get_site( 1 );
    893 
    894             $this->assertNull( domain_exists( $details->domain, $details->path, 999 ) );
    895         }
    896 
    897         public function test_invalid_domain_does_not_exist_with_default_site_id() {
    898             $this->assertNull( domain_exists( 'foo', 'bar' ) );
    899         }
    900 
    901         public function test_domain_filtered_to_exist() {
    902             add_filter( 'domain_exists', array( $this, 'domain_exists_cb' ), 10, 4 );
    903             $exists = domain_exists( 'foo', 'bar' );
    904             remove_filter( 'domain_exists', array( $this, 'domain_exists_cb' ), 10, 4 );
    905             $this->assertSame( 1234, $exists );
    906         }
    907 
    908         /**
    909          * When a path is passed to domain_exists, it is immediately trailing slashed. A path
    910          * value with or without the slash should result in the same return value.
    911          */
    912         public function test_slashed_path_in_domain_exists() {
    913             add_filter( 'domain_exists', array( $this, 'domain_exists_cb' ), 10, 4 );
    914             $exists1 = domain_exists( 'foo', 'bar' );
    915             $exists2 = domain_exists( 'foo', 'bar/' );
    916             remove_filter( 'domain_exists', array( $this, 'domain_exists_cb' ), 10, 4 );
    917 
    918             // Make sure the same result is returned with or without a trailing slash.
    919             $this->assertSame( $exists1, $exists2 );
    920         }
    921 
    922         /**
    923          * Tests returning an address for a given valid ID.
    924          */
    925         public function test_get_blogaddress_by_id_with_valid_id() {
    926             $blogaddress = get_blogaddress_by_id( 1 );
    927             $this->assertSame( 'http://' . WP_TESTS_DOMAIN . '/', $blogaddress );
    928         }
    929 
    930         /**
    931          * Tests returning the appropriate response for a invalid id given.
    932          */
    933         public function test_get_blogaddress_by_id_with_invalid_id() {
    934             $blogaddress = get_blogaddress_by_id( 42 );
    935             $this->assertSame( '', $blogaddress );
    936         }
    937 
    938         /**
    939          * @ticket 14867
    940          */
    941         public function test_get_blogaddress_by_id_scheme_reflects_blog_scheme() {
    942             $blog = self::factory()->blog->create();
    943 
    944             $this->assertSame( 'http', parse_url( get_blogaddress_by_id( $blog ), PHP_URL_SCHEME ) );
    945 
    946             update_blog_option( $blog, 'home', set_url_scheme( get_blog_option( $blog, 'home' ), 'https' ) );
    947 
    948             $this->assertSame( 'https', parse_url( get_blogaddress_by_id( $blog ), PHP_URL_SCHEME ) );
    949         }
    950 
    951         /**
    952          * @ticket 14867
    953          */
    954         public function test_get_blogaddress_by_id_scheme_is_unaffected_by_request() {
    955             $blog = self::factory()->blog->create();
    956 
    957             $this->assertFalse( is_ssl() );
    958             $this->assertSame( 'http', parse_url( get_blogaddress_by_id( $blog ), PHP_URL_SCHEME ) );
    959 
    960             $_SERVER['HTTPS'] = 'on';
    961 
    962             $is_ssl  = is_ssl();
    963             $address = parse_url( get_blogaddress_by_id( $blog ), PHP_URL_SCHEME );
    964 
    965             $this->assertTrue( $is_ssl );
    966             $this->assertSame( 'http', $address );
    967         }
    968 
    969         /**
    970          * @ticket 33620
    971          * @dataProvider data_new_blog_url_schemes
    972          */
    973         public function test_new_blog_url_schemes( $home_scheme, $siteurl_scheme, $force_ssl_admin ) {
    974             $current_site = get_current_site();
    975 
    976             $home    = get_option( 'home' );
    977             $siteurl = get_site_option( 'siteurl' );
    978             $admin   = force_ssl_admin();
    979 
    980             // Setup:
    981             update_option( 'home', set_url_scheme( $home, $home_scheme ) );
    982             update_site_option( 'siteurl', set_url_scheme( $siteurl, $siteurl_scheme ) );
    983             force_ssl_admin( $force_ssl_admin );
    984 
    985             // Install:
    986             $new = wpmu_create_blog( $current_site->domain, '/new-blog/', 'New Blog', get_current_user_id() );
    987 
    988             // Reset:
    989             update_option( 'home', $home );
    990             update_site_option( 'siteurl', $siteurl );
    991             force_ssl_admin( $admin );
    992 
    993             // Assert:
    994             $this->assertNotWPError( $new );
    995             $this->assertSame( $home_scheme, parse_url( get_blog_option( $new, 'home' ), PHP_URL_SCHEME ) );
    996             $this->assertSame( $siteurl_scheme, parse_url( get_blog_option( $new, 'siteurl' ), PHP_URL_SCHEME ) );
    997         }
    998 
    999         public function data_new_blog_url_schemes() {
    1000             return array(
    1001                 array(
    1002                     'https',
    1003                     'https',
    1004                     false,
    1005                 ),
    1006                 array(
    1007                     'http',
    1008                     'https',
    1009                     false,
    1010                 ),
    1011                 array(
    1012                     'https',
    1013                     'http',
    1014                     false,
    1015                 ),
    1016                 array(
    1017                     'http',
    1018                     'http',
    1019                     false,
    1020                 ),
    1021                 array(
    1022                     'http',
    1023                     'http',
    1024                     true,
    1025                 ),
    1026             );
    1027         }
    1028 
    1029         /**
    1030          * @ticket 36918
    1031          */
    1032         public function test_new_blog_locale() {
    1033             $current_site = get_current_site();
    1034 
    1035             add_filter( 'sanitize_option_WPLANG', array( $this, 'filter_allow_unavailable_languages' ), 10, 3 );
    1036             update_site_option( 'WPLANG', 'de_DE' );
    1037             remove_filter( 'sanitize_option_WPLANG', array( $this, 'filter_allow_unavailable_languages' ), 10 );
    1038 
    1039             // No locale, use default locale.
    1040             add_filter( 'sanitize_option_WPLANG', array( $this, 'filter_allow_unavailable_languages' ), 10, 3 );
    1041             $blog_id = wpmu_create_blog( $current_site->domain, '/de-de/', 'New Blog', get_current_user_id() );
    1042             remove_filter( 'sanitize_option_WPLANG', array( $this, 'filter_allow_unavailable_languages' ), 10 );
    1043 
    1044             $this->assertNotWPError( $blog_id );
    1045             $this->assertSame( 'de_DE', get_blog_option( $blog_id, 'WPLANG' ) );
    1046 
    1047             // Custom locale.
    1048             add_filter( 'sanitize_option_WPLANG', array( $this, 'filter_allow_unavailable_languages' ), 10, 3 );
    1049             $blog_id = wpmu_create_blog( $current_site->domain, '/es-es/', 'New Blog', get_current_user_id(), array( 'WPLANG' => 'es_ES' ) );
    1050             remove_filter( 'sanitize_option_WPLANG', array( $this, 'filter_allow_unavailable_languages' ), 10 );
    1051 
    1052             $this->assertNotWPError( $blog_id );
    1053             $this->assertSame( 'es_ES', get_blog_option( $blog_id, 'WPLANG' ) );
    1054 
    1055             // en_US locale.
    1056             add_filter( 'sanitize_option_WPLANG', array( $this, 'filter_allow_unavailable_languages' ), 10, 3 );
    1057             $blog_id = wpmu_create_blog( $current_site->domain, '/en-us/', 'New Blog', get_current_user_id(), array( 'WPLANG' => '' ) );
    1058             remove_filter( 'sanitize_option_WPLANG', array( $this, 'filter_allow_unavailable_languages' ), 10 );
    1059 
    1060             $this->assertNotWPError( $blog_id );
    1061             $this->assertSame( '', get_blog_option( $blog_id, 'WPLANG' ) );
    1062         }
    1063 
    1064         /**
    1065          * @ticket 40503
    1066          */
    1067         public function test_different_network_language() {
    1068             $network = get_network( self::$network_ids['make.wordpress.org/'] );
    1069 
    1070             add_filter( 'sanitize_option_WPLANG', array( $this, 'filter_allow_unavailable_languages' ), 10, 3 );
    1071 
    1072             update_network_option( self::$network_ids['make.wordpress.org/'], 'WPLANG', 'wibble' );
    1073             $blog_id = wpmu_create_blog( $network->domain, '/de-de/', 'New Blog', get_current_user_id(), array(), $network->id );
    1074 
    1075             remove_filter( 'sanitize_option_WPLANG', array( $this, 'filter_allow_unavailable_languages' ), 10 );
    1076 
    1077             $this->assertSame( get_network_option( self::$network_ids['make.wordpress.org/'], 'WPLANG' ), get_blog_option( $blog_id, 'WPLANG' ) );
    1078         }
    1079 
    1080         /**
    1081          * Allows to set the WPLANG option to any language.
    1082          *
    1083          * @param string $value          The sanitized option value.
    1084          * @param string $option         The option name.
    1085          * @param string $original_value The original value passed to the function.
    1086          * @return string The orginal value.
    1087          */
    1088         public function filter_allow_unavailable_languages( $value, $option, $original_value ) {
    1089             return $original_value;
    1090         }
    1091 
    1092         /**
    1093          * @ticket 29684
    1094          */
    1095         public function test_is_main_site_different_network() {
    1096             $this->assertTrue( is_main_site( self::$site_ids['make.wordpress.org/'], self::$network_ids['make.wordpress.org/'] ) );
    1097         }
    1098 
    1099         /**
    1100          * @ticket 29684
    1101          */
    1102         public function test_is_main_site_different_network_random_site() {
    1103             $this->assertFalse( is_main_site( self::$site_ids['make.wordpress.org/foo/'], self::$network_ids['make.wordpress.org/'] ) );
    1104         }
    1105 
    1106         /**
    1107          * @ticket 40201
    1108          * @dataProvider data_get_site_caches
    1109          */
    1110         public function test_clean_blog_cache( $key, $group ) {
    1111             $site = get_site( self::$site_ids['make.wordpress.org/'] );
    1112 
    1113             $replacements = array(
    1114                 '%blog_id%'         => $site->blog_id,
    1115                 '%domain%'          => $site->domain,
    1116                 '%path%'            => $site->path,
    1117                 '%domain_path_key%' => md5( $site->domain . $site->path ),
    1118             );
    1119 
    1120             $key = str_replace( array_keys( $replacements ), array_values( $replacements ), $key );
    1121 
    1122             if ( 'sites' === $group ) { // This needs to be actual data for get_site() lookups.
    1123                 wp_cache_set( $key, (object) $site->to_array(), $group );
    1124             } else {
    1125                 wp_cache_set( $key, 'something', $group );
    1126             }
    1127 
    1128             clean_blog_cache( $site );
    1129             $this->assertFalse( wp_cache_get( $key, $group ) );
    1130         }
    1131 
    1132         /**
    1133          * @ticket 40201
    1134          * @dataProvider data_get_site_caches
    1135          */
    1136         public function test_clean_blog_cache_with_id( $key, $group ) {
    1137             $site = get_site( self::$site_ids['make.wordpress.org/'] );
    1138 
    1139             $replacements = array(
    1140                 '%blog_id%'         => $site->blog_id,
    1141                 '%domain%'          => $site->domain,
    1142                 '%path%'            => $site->path,
    1143                 '%domain_path_key%' => md5( $site->domain . $site->path ),
    1144             );
    1145 
    1146             $key = str_replace( array_keys( $replacements ), array_values( $replacements ), $key );
    1147 
    1148             if ( 'sites' === $group ) { // This needs to be actual data for get_site() lookups.
    1149                 wp_cache_set( $key, (object) $site->to_array(), $group );
    1150             } else {
    1151                 wp_cache_set( $key, 'something', $group );
    1152             }
    1153 
    1154             clean_blog_cache( $site->blog_id );
    1155             $this->assertFalse( wp_cache_get( $key, $group ) );
    1156         }
    1157 
    1158         /**
    1159          * @ticket 40201
    1160          */
    1161         public function test_clean_blog_cache_resets_last_changed() {
    1162             $site = get_site( self::$site_ids['make.wordpress.org/'] );
    1163 
    1164             wp_cache_delete( 'last_changed', 'sites' );
    1165 
    1166             clean_blog_cache( $site );
    1167             $this->assertNotFalse( wp_cache_get( 'last_changed', 'sites' ) );
    1168         }
    1169 
    1170         /**
    1171          * @ticket 40201
    1172          */
    1173         public function test_clean_blog_cache_fires_action() {
    1174             $site = get_site( self::$site_ids['make.wordpress.org/'] );
    1175 
    1176             $old_count = did_action( 'clean_site_cache' );
    1177 
    1178             clean_blog_cache( $site );
    1179             $this->assertSame( $old_count + 1, did_action( 'clean_site_cache' ) );
    1180         }
    1181 
    1182         /**
    1183          * @ticket 40201
    1184          */
    1185         public function test_clean_blog_cache_bails_on_suspend_cache_invalidation() {
    1186             $site = get_site( self::$site_ids['make.wordpress.org/'] );
    1187 
    1188             $old_count = did_action( 'clean_site_cache' );
    1189 
    1190             $suspend = wp_suspend_cache_invalidation();
    1191             clean_blog_cache( $site );
    1192             wp_suspend_cache_invalidation( $suspend );
    1193             $this->assertSame( $old_count, did_action( 'clean_site_cache' ) );
    1194         }
    1195 
    1196         /**
    1197          * @ticket 40201
    1198          */
    1199         public function test_clean_blog_cache_bails_on_empty_input() {
    1200             $old_count = did_action( 'clean_site_cache' );
    1201 
    1202             clean_blog_cache( null );
    1203             $this->assertSame( $old_count, did_action( 'clean_site_cache' ) );
    1204         }
    1205 
    1206         /**
    1207          * @ticket 40201
    1208          */
    1209         public function test_clean_blog_cache_bails_on_non_numeric_input() {
    1210             $old_count = did_action( 'clean_site_cache' );
    1211 
    1212             clean_blog_cache( 'something' );
    1213             $this->assertSame( $old_count, did_action( 'clean_site_cache' ) );
    1214         }
    1215 
    1216         /**
    1217          * @ticket 40201
    1218          */
    1219         public function test_clean_blog_cache_works_with_deleted_site() {
    1220             $site_id = 12345;
    1221 
    1222             wp_cache_set( $site_id, 'something', 'site-details' );
    1223 
    1224             clean_blog_cache( $site_id );
    1225             $this->assertFalse( wp_cache_get( $site_id, 'site-details' ) );
    1226         }
    1227 
    1228         /**
    1229          * @ticket 40201
    1230          * @dataProvider data_get_site_caches
    1231          */
    1232         public function test_refresh_blog_details( $key, $group ) {
    1233             $site = get_site( self::$site_ids['make.wordpress.org/'] );
    1234 
    1235             $replacements = array(
    1236                 '%blog_id%'         => $site->blog_id,
    1237                 '%domain%'          => $site->domain,
    1238                 '%path%'            => $site->path,
    1239                 '%domain_path_key%' => md5( $site->domain . $site->path ),
    1240             );
    1241 
    1242             $key = str_replace( array_keys( $replacements ), array_values( $replacements ), $key );
    1243 
    1244             if ( 'sites' === $group ) { // This needs to be actual data for get_site() lookups.
    1245                 wp_cache_set( $key, (object) $site->to_array(), $group );
    1246             } else {
    1247                 wp_cache_set( $key, 'something', $group );
    1248             }
    1249 
    1250             refresh_blog_details( $site->blog_id );
    1251             $this->assertFalse( wp_cache_get( $key, $group ) );
    1252         }
    1253 
    1254         /**
    1255          * @ticket 40201
    1256          */
    1257         public function test_refresh_blog_details_works_with_deleted_site() {
    1258             $site_id = 12345;
    1259 
    1260             wp_cache_set( $site_id, 'something', 'site-details' );
    1261 
    1262             refresh_blog_details( $site_id );
    1263             $this->assertFalse( wp_cache_get( $site_id, 'site-details' ) );
    1264         }
    1265 
    1266         /**
    1267          * @ticket 40201
    1268          */
    1269         public function test_refresh_blog_details_uses_current_site_as_default() {
    1270             $site_id = get_current_blog_id();
    1271 
    1272             wp_cache_set( $site_id, 'something', 'site-details' );
    1273 
    1274             refresh_blog_details();
    1275             $this->assertFalse( wp_cache_get( $site_id, 'site-details' ) );
    1276         }
    1277 
    1278         public function data_get_site_caches() {
    1279             return array(
    1280                 array( '%blog_id%', 'sites' ),
    1281                 array( '%blog_id%', 'site-details' ),
    1282                 array( '%blog_id%', 'blog-details' ),
    1283                 array( '%blog_id%' . 'short', 'blog-details' ),
    1284                 array( '%domain_path_key%', 'blog-lookup' ),
    1285                 array( '%domain_path_key%', 'blog-id-cache' ),
    1286             );
    1287         }
    1288 
    1289         /**
    1290          * @ticket 40364
    1291          * @dataProvider data_wp_insert_site
    1292          */
    1293         public function test_wp_insert_site( $site_data, $expected_data ) {
    1294             remove_action( 'wp_initialize_site', 'wp_initialize_site', 10 );
    1295             $site_id = wp_insert_site( $site_data );
    1296 
    1297             $this->assertIsInt( $site_id );
    1298 
    1299             $site = get_site( $site_id );
    1300             foreach ( $expected_data as $key => $value ) {
    1301                 $this->assertEquals( $value, $site->$key );
    1302             }
    1303         }
    1304 
    1305         public function data_wp_insert_site() {
    1306             return array(
    1307                 array(
    1308                     array(
    1309                         'domain' => 'example.com',
    1310                     ),
    1311                     array(
    1312                         'domain'     => 'example.com',
    1313                         'path'       => '/',
    1314                         'network_id' => 1,
    1315                         'public'     => 1,
    1316                         'archived'   => 0,
    1317                         'mature'     => 0,
    1318                         'spam'       => 0,
    1319                         'deleted'    => 0,
    1320                         'lang_id'    => 0,
    1321                     ),
    1322                 ),
    1323                 array(
    1324                     array(
    1325                         'domain'     => 'example.com',
    1326                         'path'       => '/foo',
    1327                         'network_id' => 2,
    1328                     ),
    1329                     array(
    1330                         'domain'     => 'example.com',
    1331                         'path'       => '/foo/',
    1332                         'network_id' => 2,
    1333                     ),
    1334                 ),
    1335                 array(
    1336                     array(
    1337                         'domain'  => 'example.com',
    1338                         'path'    => '/bar/',
    1339                         'site_id' => 2,
    1340                     ),
    1341                     array(
    1342                         'domain'     => 'example.com',
    1343                         'path'       => '/bar/',
    1344                         'network_id' => 2,
    1345                     ),
    1346                 ),
    1347                 array(
    1348                     array(
    1349                         'domain'     => 'example.com',
    1350                         'path'       => '/bar/',
    1351                         'site_id'    => 2,
    1352                         'network_id' => 3,
    1353                     ),
    1354                     array(
    1355                         'domain'     => 'example.com',
    1356                         'path'       => '/bar/',
    1357                         'network_id' => 3,
    1358                     ),
    1359                 ),
    1360                 array(
    1361                     array(
    1362                         'domain'   => 'example.com',
    1363                         'path'     => 'foobar',
    1364                         'public'   => 0,
    1365                         'archived' => 1,
    1366                         'mature'   => 1,
    1367                         'spam'     => 1,
    1368                         'deleted'  => 1,
    1369                         'lang_id'  => 1,
    1370                     ),
    1371                     array(
    1372                         'domain'   => 'example.com',
    1373                         'path'     => '/foobar/',
    1374                         'public'   => 0,
    1375                         'archived' => 1,
    1376                         'mature'   => 1,
    1377                         'spam'     => 1,
    1378                         'deleted'  => 1,
    1379                         'lang_id'  => 1,
    1380                     ),
    1381                 ),
    1382             );
    1383         }
    1384 
    1385         /**
    1386          * @ticket 50324
    1387          */
    1388         public function test_wp_insert_site_with_clean_site_cache() {
    1389             remove_action( 'wp_initialize_site', 'wp_initialize_site', 10 );
    1390 
    1391             add_action( 'clean_site_cache', array( $this, 'action_database_insert_on_clean_site_cache' ) );
    1392 
    1393             $site_id = wp_insert_site(
    1394                 array(
    1395                     'domain'     => 'valid-domain.com',
    1396                     'path'       => '/valid-path/',
    1397                     'network_id' => 1,
    1398                 )
    1399             );
    1400 
    1401             remove_action( 'clean_site_cache', array( $this, 'action_database_insert_on_clean_site_cache' ) );
    1402 
    1403             $this->assertIsInt( $site_id );
    1404 
    1405         }
    1406 
    1407         public function action_database_insert_on_clean_site_cache() {
    1408             update_site_option( 'database_write_test.' . time(), true );
    1409         }
    1410 
    1411         /**
    1412          * @ticket 40364
    1413          */
    1414         public function test_wp_insert_site_empty_domain() {
    1415             remove_action( 'wp_initialize_site', 'wp_initialize_site', 10 );
    1416             $site_id = wp_insert_site( array( 'public' => 0 ) );
    1417 
    1418             $this->assertWPError( $site_id );
    1419             $this->assertSame( 'site_empty_domain', $site_id->get_error_code() );
    1420         }
    1421 
    1422         /**
    1423          * @ticket 40364
    1424          * @dataProvider data_wp_update_site
    1425          */
    1426         public function test_wp_update_site( $site_data, $expected_data ) {
    1427             $site_id = self::factory()->blog->create();
    1428 
    1429             $old_site = get_site( $site_id );
    1430 
    1431             $result = wp_update_site( $site_id, $site_data );
    1432 
    1433             $this->assertSame( $site_id, $result );
    1434 
    1435             $new_site = get_site( $site_id );
    1436             foreach ( $new_site->to_array() as $key => $value ) {
    1437                 if ( isset( $expected_data[ $key ] ) ) {
    1438                     $this->assertEquals( $expected_data[ $key ], $value );
    1439                 } elseif ( 'last_updated' === $key ) {
    1440                     $this->assertTrue( $old_site->last_updated <= $value );
    1441                 } else {
    1442                     $this->assertSame( $old_site->$key, $value );
    1443                 }
    1444             }
    1445         }
    1446 
    1447         public function data_wp_update_site() {
    1448             return array(
    1449                 array(
    1450                     array(
    1451                         'domain'     => 'example.com',
    1452                         'network_id' => 2,
    1453                     ),
    1454                     array(
    1455                         'domain'  => 'example.com',
    1456                         'site_id' => 2,
    1457                     ),
    1458                 ),
    1459                 array(
    1460                     array(
    1461                         'path' => 'foo',
    1462                     ),
    1463                     array(
    1464                         'path' => '/foo/',
    1465                     ),
    1466                 ),
    1467                 array(
    1468                     array(
    1469                         'public'   => 0,
    1470                         'archived' => 1,
    1471                         'mature'   => 1,
    1472                         'spam'     => 1,
    1473                         'deleted'  => 1,
    1474                         'lang_id'  => 1,
    1475                     ),
    1476                     array(
    1477                         'public'   => 0,
    1478                         'archived' => 1,
    1479                         'mature'   => 1,
    1480                         'spam'     => 1,
    1481                         'deleted'  => 1,
    1482                         'lang_id'  => 1,
    1483                     ),
    1484                 ),
    1485             );
    1486         }
    1487 
    1488         /**
    1489          * @ticket 40364
    1490          */
    1491         public function test_wp_update_site_empty_domain() {
    1492             $site_id = self::factory()->blog->create();
    1493 
    1494             $result = wp_update_site( $site_id, array( 'domain' => '' ) );
    1495 
    1496             $this->assertWPError( $result );
    1497             $this->assertSame( 'site_empty_domain', $result->get_error_code() );
    1498         }
    1499 
    1500         /**
    1501          * @ticket 40364
    1502          */
    1503         public function test_wp_update_site_invalid_id() {
    1504             $result = wp_update_site( 444444, array( 'domain' => 'example.com' ) );
    1505 
    1506             $this->assertWPError( $result );
    1507             $this->assertSame( 'site_not_exist', $result->get_error_code() );
    1508         }
    1509 
    1510         /**
    1511          * @ticket 40364
    1512          */
    1513         public function test_wp_update_site_cleans_cache() {
    1514             $site_id = self::factory()->blog->create();
    1515             $site1   = get_site( $site_id );
    1516 
    1517             $result = wp_update_site( $site_id, array( 'public' => 0 ) );
    1518             $site2  = get_site( $site_id );
    1519 
    1520             $result = wp_update_site( $site_id, array( 'public' => 1 ) );
    1521             $site3  = get_site( $site_id );
    1522 
    1523             $this->assertSame( '1', $site1->public );
    1524             $this->assertSame( '0', $site2->public );
    1525             $this->assertSame( '1', $site3->public );
    1526         }
    1527 
    1528         /**
    1529          * @ticket 40364
    1530          */
    1531         public function test_wp_delete_site() {
    1532             $site_id = self::factory()->blog->create();
    1533 
    1534             $site = get_site( $site_id );
    1535 
    1536             $result = wp_delete_site( $site_id );
    1537 
    1538             $this->assertInstanceOf( 'WP_Site', $result );
    1539             $this->assertSame( $result->to_array(), $site->to_array() );
    1540         }
    1541 
    1542         /**
    1543          * @ticket 40364
    1544          */
    1545         public function test_wp_delete_site_invalid_id() {
    1546             $result = wp_delete_site( 444444 );
    1547 
    1548             $this->assertWPError( $result );
    1549             $this->assertSame( 'site_not_exist', $result->get_error_code() );
    1550         }
    1551 
    1552         /**
    1553          * @ticket 41333
    1554          */
    1555         public function test_wp_delete_site_validate_site_deletion_action() {
    1556             add_action( 'wp_validate_site_deletion', array( $this, 'action_wp_validate_site_deletion_prevent_deletion' ) );
    1557             $result = wp_delete_site( self::$site_ids['make.wordpress.org/'] );
    1558             $this->assertWPError( $result );
    1559             $this->assertSame( 'action_does_not_like_deletion', $result->get_error_code() );
    1560         }
    1561 
    1562         public function action_wp_validate_site_deletion_prevent_deletion( $errors ) {
    1563             $errors->add( 'action_does_not_like_deletion', 'You cannot delete this site because the action does not like it.' );
    1564         }
    1565 
    1566         /**
    1567          * @ticket 40364
    1568          * @dataProvider data_wp_normalize_site_data
    1569          */
    1570         public function test_wp_normalize_site_data( $data, $expected ) {
    1571             $result = wp_normalize_site_data( $data );
    1572 
    1573             $this->assertSameSetsWithIndex( $expected, $result );
    1574         }
    1575 
    1576         public function data_wp_normalize_site_data() {
    1577             return array(
    1578                 array(
    1579                     array(
    1580                         'network_id' => '4',
    1581                     ),
    1582                     array(
    1583                         'network_id' => 4,
    1584                     ),
    1585                 ),
    1586                 array(
    1587                     array(
    1588                         'domain' => 'invalid domain .com',
    1589                         'path'   => 'foo',
    1590                     ),
    1591                     array(
    1592                         'domain' => 'invaliddomain.com',
    1593                         'path'   => '/foo/',
    1594                     ),
    1595                 ),
    1596                 array(
    1597                     array(
    1598                         'domain' => '<yet>/another-invalid-domain.com',
    1599                     ),
    1600                     array(
    1601                         'domain' => 'another-invalid-domain.com',
    1602                     ),
    1603                 ),
    1604                 array(
    1605                     array(
    1606                         'path' => '',
    1607                     ),
    1608                     array(
    1609                         'path' => '/',
    1610                     ),
    1611                 ),
    1612                 array(
    1613                     array(
    1614                         'public'   => '0',
    1615                         'archived' => '1',
    1616                         'mature'   => '1',
    1617                         'spam'     => true,
    1618                         'deleted'  => true,
    1619                     ),
    1620                     array(
    1621                         'public'   => 0,
    1622                         'archived' => 1,
    1623                         'mature'   => 1,
    1624                         'spam'     => 1,
    1625                         'deleted'  => 1,
    1626                     ),
    1627                 ),
    1628                 array(
    1629                     array(
    1630                         'registered'   => '',
    1631                         'last_updated' => '',
    1632                     ),
    1633                     array(),
    1634                 ),
    1635                 array(
    1636                     array(
    1637                         'registered'   => '0000-00-00 00:00:00',
    1638                         'last_updated' => '0000-00-00 00:00:00',
    1639                     ),
    1640                     array(),
    1641                 ),
    1642             );
    1643         }
    1644 
    1645         /**
    1646          * @ticket 40364
    1647          * @dataProvider data_wp_validate_site_data
    1648          */
    1649         public function test_wp_validate_site_data( $data, $expected_errors ) {
    1650             $result = new WP_Error();
    1651             wp_validate_site_data( $result, $data );
    1652 
    1653             if ( empty( $expected_errors ) ) {
    1654                 $this->assertEmpty( $result->errors );
    1655             } else {
    1656                 $this->assertSameSets( $expected_errors, array_keys( $result->errors ) );
    1657             }
    1658         }
    1659 
    1660         public function data_wp_validate_site_data() {
    1661             $date = current_time( 'mysql', true );
    1662 
    1663             return array(
    1664                 array(
    1665                     array(
    1666                         'domain'       => 'example-site.com',
    1667                         'path'         => '/',
    1668                         'network_id'   => 1,
    1669                         'registered'   => $date,
    1670                         'last_updated' => $date,
    1671                     ),
    1672                     array(),
    1673                 ),
    1674                 array(
    1675                     array(
    1676                         'path'         => '/',
    1677                         'network_id'   => 1,
    1678                         'registered'   => $date,
    1679                         'last_updated' => $date,
    1680                     ),
    1681                     array( 'site_empty_domain' ),
    1682                 ),
    1683                 array(
    1684                     array(
    1685                         'domain'       => 'example-site.com',
    1686                         'network_id'   => 1,
    1687                         'registered'   => $date,
    1688                         'last_updated' => $date,
    1689                     ),
    1690                     array( 'site_empty_path' ),
    1691                 ),
    1692                 array(
    1693                     array(
    1694                         'domain'       => 'example-site.com',
    1695                         'path'         => '/',
    1696                         'registered'   => $date,
    1697                         'last_updated' => $date,
    1698                     ),
    1699                     array( 'site_empty_network_id' ),
    1700                 ),
    1701                 array(
    1702                     array(
    1703                         'domain'       => get_site()->domain,
    1704                         'path'         => get_site()->path,
    1705                         'network_id'   => get_site()->network_id,
    1706                         'registered'   => $date,
    1707                         'last_updated' => $date,
    1708                     ),
    1709                     array( 'site_taken' ),
    1710                 ),
    1711                 array(
    1712                     array(
    1713                         'domain'       => 'valid-domain.com',
    1714                         'path'         => '/valid-path/',
    1715                         'network_id'   => 1,
    1716                         'registered'   => '',
    1717                         'last_updated' => $date,
    1718                     ),
    1719                     array( 'site_empty_registered' ),
    1720                 ),
    1721                 array(
    1722                     array(
    1723                         'domain'       => 'valid-domain.com',
    1724                         'path'         => '/valid-path/',
    1725                         'network_id'   => 1,
    1726                         'registered'   => $date,
    1727                         'last_updated' => '',
    1728                     ),
    1729                     array( 'site_empty_last_updated' ),
    1730                 ),
    1731                 array(
    1732                     array(
    1733                         'domain'       => 'valid-domain.com',
    1734                         'path'         => '/valid-path/',
    1735                         'network_id'   => 1,
    1736                         'registered'   => '2000-13-32 25:25:61',
    1737                         'last_updated' => $date,
    1738                     ),
    1739                     array( 'site_invalid_registered' ),
    1740                 ),
    1741                 array(
    1742                     array(
    1743                         'domain'       => 'valid-domain.com',
    1744                         'path'         => '/valid-path/',
    1745                         'network_id'   => 1,
    1746                         'registered'   => $date,
    1747                         'last_updated' => '2000-13-32 25:25:61',
    1748                     ),
    1749                     array( 'site_invalid_last_updated' ),
    1750                 ),
    1751                 array(
    1752                     array(
    1753                         'domain'       => 'valid-domain.com',
    1754                         'path'         => '/valid-path/',
    1755                         'network_id'   => 1,
    1756                         'registered'   => '0000-00-00 00:00:00',
    1757                         'last_updated' => $date,
    1758                     ),
    1759                     array(),
    1760                 ),
    1761                 array(
    1762                     array(
    1763                         'domain'       => 'valid-domain.com',
    1764                         'path'         => '/valid-path/',
    1765                         'network_id'   => 1,
    1766                         'registered'   => $date,
    1767                         'last_updated' => '0000-00-00 00:00:00',
    1768                     ),
    1769                     array(),
    1770                 ),
    1771             );
    1772         }
    1773 
    1774         /**
    1775          * @ticket 40364
    1776          */
    1777         public function test_site_dates_are_gmt() {
    1778             $first_date = current_time( 'mysql', true );
    1779 
    1780             remove_action( 'wp_initialize_site', 'wp_initialize_site', 10 );
    1781             $site_id = wp_insert_site(
    1782                 array(
    1783                     'domain'     => 'valid-domain.com',
    1784                     'path'       => '/valid-path/',
    1785                     'network_id' => 1,
    1786                 )
    1787             );
    1788             $this->assertIsInt( $site_id );
    1789 
    1790             $site = get_site( $site_id );
    1791             $this->assertEqualsWithDelta( strtotime( $first_date ), strtotime( $site->registered ), 2, 'The dates should be equal' );
    1792             $this->assertEqualsWithDelta( strtotime( $first_date ), strtotime( $site->last_updated ), 2, 'The dates should be equal' );
    1793 
    1794             $second_date = current_time( 'mysql', true );
    1795             $site_id     = wp_update_site( $site_id, array() );
    1796             $this->assertIsInt( $site_id );
    1797 
    1798             $site = get_site( $site_id );
    1799             $this->assertEqualsWithDelta( strtotime( $first_date ), strtotime( $site->registered ), 2, 'The dates should be equal' );
    1800             $this->assertEqualsWithDelta( strtotime( $second_date ), strtotime( $site->last_updated ), 2, 'The dates should be equal' );
    1801         }
    1802 
    1803         /**
    1804          * @ticket 40364
    1805          */
    1806         public function test_wp_delete_site_cleans_cache() {
    1807             $site_id = self::factory()->blog->create();
    1808 
    1809             get_site( $site_id );
    1810 
    1811             wp_delete_site( $site_id );
    1812 
    1813             $this->assertNull( get_site( $site_id ) );
    1814         }
    1815 
    1816         /**
    1817          * @ticket 40364
    1818          */
    1819         public function test_wp_update_site_cleans_old_cache_on_domain_change() {
    1820             $old_domain = 'old.wordpress.org';
    1821             $new_domain = 'new.wordpress.org';
    1822 
    1823             $site = self::factory()->blog->create_and_get(
    1824                 array(
    1825                     'domain' => $old_domain,
    1826                     'path'   => '/',
    1827                 )
    1828             );
    1829 
    1830             // Populate the caches.
    1831             get_blog_details(
    1832                 array(
    1833                     'domain' => $old_domain,
    1834                     'path'   => '/',
    1835                 )
    1836             );
    1837             get_blog_id_from_url( $old_domain, '/' );
    1838             get_blog_details(
    1839                 array(
    1840                     'domain' => $new_domain,
    1841                     'path'   => '/',
    1842                 )
    1843             );
    1844             get_blog_id_from_url( $new_domain, '/' );
    1845 
    1846             wp_update_site(
    1847                 $site->id,
    1848                 array(
    1849                     'domain' => $new_domain,
    1850                 )
    1851             );
    1852 
    1853             $domain_path_key_old = md5( $old_domain . '/' );
    1854             $domain_path_key_new = md5( $new_domain . '/' );
    1855 
    1856             // Ensure all respective cache values are empty.
    1857             $result = array(
    1858                 wp_cache_get( $domain_path_key_old, 'blog-lookup' ),
    1859                 wp_cache_get( $domain_path_key_old, 'blog-id-cache' ),
    1860                 wp_cache_get( 'current_blog_' . $old_domain, 'site-options' ),
    1861                 wp_cache_get( 'current_blog_' . $old_domain . '/', 'site-options' ),
    1862                 wp_cache_get( $domain_path_key_new, 'blog-lookup' ),
    1863                 wp_cache_get( $domain_path_key_new, 'blog-id-cache' ),
    1864                 wp_cache_get( 'current_blog_' . $new_domain, 'site-options' ),
    1865                 wp_cache_get( 'current_blog_' . $new_domain . '/', 'site-options' ),
    1866             );
    1867 
    1868             $this->assertEmpty( array_filter( $result ) );
    1869         }
    1870 
    1871         /**
    1872          * @ticket 40364
    1873          */
    1874         public function test_wp_update_site_cleans_old_cache_on_path_change() {
    1875             $old_path = '/foo/';
    1876             $new_path = '/bar/';
    1877 
    1878             $site = self::factory()->blog->create_and_get(
    1879                 array(
    1880                     'domain' => 'test.wordpress.org',
    1881                     'path'   => $old_path,
    1882                 )
    1883             );
    1884 
    1885             // Populate the caches.
    1886             get_blog_details(
    1887                 array(
    1888                     'domain' => 'test.wordpress.org',
    1889                     'path'   => $old_path,
    1890                 )
    1891             );
    1892             get_blog_id_from_url( 'test.wordpress.org', $old_path );
    1893             get_blog_details(
    1894                 array(
    1895                     'domain' => 'test.wordpress.org',
    1896                     'path'   => $new_path,
    1897                 )
    1898             );
    1899             get_blog_id_from_url( 'test.wordpress.org', $new_path );
    1900 
    1901             wp_update_site(
    1902                 $site->id,
    1903                 array(
    1904                     'path' => $new_path,
    1905                 )
    1906             );
    1907 
    1908             $domain_path_key_old = md5( 'test.wordpress.org' . $old_path );
    1909             $domain_path_key_new = md5( 'test.wordpress.org' . $new_path );
    1910 
    1911             // Ensure all respective cache values are empty.
    1912             $result = array(
    1913                 wp_cache_get( $domain_path_key_old, 'blog-lookup' ),
    1914                 wp_cache_get( $domain_path_key_old, 'blog-id-cache' ),
    1915                 wp_cache_get( 'current_blog_test.wordpress.org' . $old_path, 'site-options' ),
    1916                 wp_cache_get( $domain_path_key_new, 'blog-lookup' ),
    1917                 wp_cache_get( $domain_path_key_new, 'blog-id-cache' ),
    1918                 wp_cache_get( 'current_blog_test.wordpress.org' . $new_path, 'site-options' ),
    1919             );
    1920 
    1921             $this->assertEmpty( array_filter( $result ) );
    1922         }
    1923 
    1924         /**
    1925          * @ticket 40364
    1926          * @dataProvider data_site_status_hook_triggers
    1927          */
    1928         public function test_site_status_hook_triggers( $insert_site_data, $expected_insert_hooks, $update_site_data, $expected_update_hooks ) {
    1929             // First: Insert a site.
    1930             $this->listen_to_site_status_hooks();
    1931 
    1932             $site_data = array_merge(
    1933                 array(
    1934                     'domain' => 'example-site.com',
    1935                     'path'   => '/',
    1936                 ),
    1937                 $insert_site_data
    1938             );
    1939 
    1940             $site_id = wp_insert_site( $site_data );
    1941 
    1942             $insert_expected = array_fill_keys( $expected_insert_hooks, $site_id );
    1943             $insert_result   = $this->get_listen_to_site_status_hooks_result();
    1944 
    1945             // Second: Update that site.
    1946             $this->listen_to_site_status_hooks();
    1947 
    1948             wp_update_site( $site_id, $update_site_data );
    1949 
    1950             $update_expected = array_fill_keys( $expected_update_hooks, $site_id );
    1951             $update_result   = $this->get_listen_to_site_status_hooks_result();
    1952 
    1953             // Check both insert and update results.
    1954             $this->assertSameSetsWithIndex( $insert_expected, $insert_result );
    1955             $this->assertSameSetsWithIndex( $update_expected, $update_result );
    1956         }
    1957 
    1958         public function data_site_status_hook_triggers() {
    1959             return array(
    1960                 array(
    1961                     array(
    1962                         'public'   => 1,
    1963                         'archived' => 1,
    1964                         'mature'   => 1,
    1965                         'spam'     => 1,
    1966                         'deleted'  => 1,
    1967                     ),
    1968                     array(
    1969                         'archive_blog',
    1970                         'mature_blog',
    1971                         'make_spam_blog',
    1972                         'make_delete_blog',
    1973                     ),
    1974                     array(
    1975                         'public'   => 0,
    1976                         'archived' => 0,
    1977                         'mature'   => 0,
    1978                         'spam'     => 0,
    1979                         'deleted'  => 0,
    1980                     ),
    1981                     array(
    1982                         'update_blog_public',
    1983                         'unarchive_blog',
    1984                         'unmature_blog',
    1985                         'make_ham_blog',
    1986                         'make_undelete_blog',
    1987                     ),
    1988                 ),
    1989                 array(
    1990                     array(
    1991                         'public'   => 0,
    1992                         'archived' => 0,
    1993                         'mature'   => 0,
    1994                         'spam'     => 0,
    1995                         'deleted'  => 0,
    1996                     ),
    1997                     array(
    1998                         'update_blog_public',
    1999                     ),
    2000                     array(
    2001                         'public'   => 1,
    2002                         'archived' => 1,
    2003                         'mature'   => 1,
    2004                         'spam'     => 1,
    2005                         'deleted'  => 1,
    2006                     ),
    2007                     array(
    2008                         'update_blog_public',
    2009                         'archive_blog',
    2010                         'mature_blog',
    2011                         'make_spam_blog',
    2012                         'make_delete_blog',
    2013                     ),
    2014                 ),
    2015                 array(
    2016                     array(
    2017                         'public'   => 0,
    2018                         'archived' => 0,
    2019                         'mature'   => 1,
    2020                         'spam'     => 1,
    2021                         'deleted'  => 1,
    2022                     ),
    2023                     array(
    2024                         'update_blog_public',
    2025                         'mature_blog',
    2026                         'make_spam_blog',
    2027                         'make_delete_blog',
    2028                     ),
    2029                     array(
    2030                         'public'   => 0,
    2031                         'archived' => 1,
    2032                         'mature'   => 1,
    2033                         'spam'     => 1,
    2034                         'deleted'  => 0,
    2035                     ),
    2036                     array(
    2037                         'archive_blog',
    2038                         'make_undelete_blog',
    2039                     ),
    2040                 ),
    2041             );
    2042         }
    2043 
    2044         private function listen_to_site_status_hooks() {
    2045             $this->site_status_hooks = array();
    2046 
    2047             $hooknames = array(
    2048                 'make_spam_blog',
    2049                 'make_ham_blog',
    2050                 'mature_blog',
    2051                 'unmature_blog',
    2052                 'archive_blog',
    2053                 'unarchive_blog',
    2054                 'make_delete_blog',
    2055                 'make_undelete_blog',
    2056                 'update_blog_public',
    2057             );
    2058 
    2059             foreach ( $hooknames as $hookname ) {
    2060                 add_action( $hookname, array( $this, 'action_site_status_hook' ), 10, 1 );
    2061             }
    2062         }
    2063 
    2064         private function get_listen_to_site_status_hooks_result() {
    2065             $hooknames = array(
    2066                 'make_spam_blog',
    2067                 'make_ham_blog',
    2068                 'mature_blog',
    2069                 'unmature_blog',
    2070                 'archive_blog',
    2071                 'unarchive_blog',
    2072                 'make_delete_blog',
    2073                 'make_undelete_blog',
    2074                 'update_blog_public',
    2075             );
    2076 
    2077             foreach ( $hooknames as $hookname ) {
    2078                 remove_action( $hookname, array( $this, 'action_site_status_hook' ), 10 );
    2079             }
    2080 
    2081             return $this->site_status_hooks;
    2082         }
    2083 
    2084         public function action_site_status_hook( $site_id ) {
    2085             $this->site_status_hooks[ current_action() ] = $site_id;
    2086         }
    2087 
    2088         /**
    2089          * @ticket 41333
    2090          * @dataProvider data_wp_initialize_site
    2091          */
    2092         public function test_wp_initialize_site( $args, $expected_options, $expected_meta ) {
    2093             $result = wp_initialize_site( self::$uninitialized_site_id, $args );
    2094 
    2095             switch_to_blog( self::$uninitialized_site_id );
    2096 
    2097             $options = array();
    2098             foreach ( $expected_options as $option => $value ) {
    2099                 $options[ $option ] = get_option( $option );
    2100             }
    2101 
    2102             $meta = array();
    2103             foreach ( $expected_meta as $meta_key => $value ) {
    2104                 $meta[ $meta_key ] = get_site_meta( self::$uninitialized_site_id, $meta_key, true );
    2105             }
    2106 
    2107             restore_current_blog();
    2108 
    2109             $initialized = wp_is_site_initialized( self::$uninitialized_site_id );
    2110 
    2111             wp_uninitialize_site( self::$uninitialized_site_id );
    2112 
    2113             $this->assertTrue( $result );
    2114             $this->assertTrue( $initialized );
    2115             $this->assertSame( $expected_options, $options );
    2116             $this->assertSame( $expected_meta, $meta );
    2117         }
    2118 
    2119         public function data_wp_initialize_site() {
    2120             return array(
    2121                 array(
    2122                     array(),
    2123                     array(
    2124                         'home'        => 'http://uninitialized.org',
    2125                         'siteurl'     => 'http://uninitialized.org',
    2126                         'admin_email' => '',
    2127                         'blog_public' => '1',
    2128                     ),
    2129                     array(),
    2130                 ),
    2131                 array(
    2132                     array(
    2133                         'options' => array(
    2134                             'home'    => 'https://uninitialized.org',
    2135                             'siteurl' => 'https://uninitialized.org',
    2136                             'key'     => 'value',
    2137                         ),
    2138                         'meta'    => array(
    2139                             'key1' => 'value1',
    2140                             'key2' => 'value2',
    2141                         ),
    2142                     ),
    2143                     array(
    2144                         'home'    => 'https://uninitialized.org',
    2145                         'siteurl' => 'https://uninitialized.org',
    2146                         'key'     => 'value',
    2147                     ),
    2148                     array(
    2149                         'key1' => 'value1',
    2150                         'key2' => 'value2',
    2151                         'key3' => '',
    2152                     ),
    2153                 ),
    2154                 array(
    2155                     array(
    2156                         'title'   => 'My New Site',
    2157                         'options' => array(
    2158                             'blogdescription' => 'Just My New Site',
    2159                         ),
    2160                     ),
    2161                     array(
    2162                         'blogname'        => 'My New Site',
    2163                         'blogdescription' => 'Just My New Site',
    2164                     ),
    2165                     array(),
    2166                 ),
    2167             );
    2168         }
    2169 
    2170         /**
    2171          * @ticket 41333
    2172          */
    2173         public function test_wp_initialize_site_user_roles() {
    2174             global $wpdb;
    2175 
    2176             $result = wp_initialize_site( self::$uninitialized_site_id, array() );
    2177 
    2178             switch_to_blog( self::$uninitialized_site_id );
    2179             $table_prefix = $wpdb->get_blog_prefix( self::$uninitialized_site_id );
    2180             $roles        = get_option( $table_prefix . 'user_roles' );
    2181             restore_current_blog();
    2182 
    2183             wp_uninitialize_site( self::$uninitialized_site_id );
    2184 
    2185             $this->assertTrue( $result );
    2186             $this->assertSameSets(
    2187                 array(
    2188                     'administrator',
    2189                     'editor',
    2190                     'author',
    2191                     'contributor',
    2192                     'subscriber',
    2193                 ),
    2194                 array_keys( $roles )
    2195             );
    2196         }
    2197 
    2198         /**
    2199          * @ticket 41333
    2200          */
    2201         public function test_wp_initialize_site_user_is_admin() {
    2202             $result = wp_initialize_site( self::$uninitialized_site_id, array( 'user_id' => 1 ) );
    2203 
    2204             switch_to_blog( self::$uninitialized_site_id );
    2205             $user_is_admin = user_can( 1, 'manage_options' );
    2206             $admin_email   = get_option( 'admin_email' );
    2207             restore_current_blog();
    2208 
    2209             wp_uninitialize_site( self::$uninitialized_site_id );
    2210 
    2211             $this->assertTrue( $result );
    2212             $this->assertTrue( $user_is_admin );
    2213             $this->assertSame( get_userdata( 1 )->user_email, $admin_email );
    2214         }
    2215 
    2216         /**
    2217          * @ticket 41333
    2218          */
    2219         public function test_wp_initialize_site_args_filter() {
    2220             add_filter( 'wp_initialize_site_args', array( $this, 'filter_wp_initialize_site_args' ), 10, 3 );
    2221             $result = wp_initialize_site( self::$uninitialized_site_id, array( 'title' => 'My Site' ) );
    2222 
    2223             switch_to_blog( self::$uninitialized_site_id );
    2224             $site_title = get_option( 'blogname' );
    2225             restore_current_blog();
    2226 
    2227             wp_uninitialize_site( self::$uninitialized_site_id );
    2228 
    2229             $this->assertSame(
    2230                 sprintf( 'My Site %1$d in Network %2$d', self::$uninitialized_site_id, get_site( self::$uninitialized_site_id )->network_id ),
    2231                 $site_title
    2232             );
    2233         }
    2234 
    2235         public function filter_wp_initialize_site_args( $args, $site, $network ) {
    2236             $args['title'] = sprintf( 'My Site %1$d in Network %2$d', $site->id, $network->id );
    2237 
    2238             return $args;
    2239         }
    2240 
    2241         /**
    2242          * @ticket 41333
    2243          */
    2244         public function test_wp_initialize_site_empty_id() {
    2245             $result = wp_initialize_site( 0 );
    2246             $this->assertWPError( $result );
    2247             $this->assertSame( 'site_empty_id', $result->get_error_code() );
    2248         }
    2249 
    2250         /**
    2251          * @ticket 41333
    2252          */
    2253         public function test_wp_initialize_site_invalid_id() {
    2254             $result = wp_initialize_site( 123 );
    2255             $this->assertWPError( $result );
    2256             $this->assertSame( 'site_invalid_id', $result->get_error_code() );
    2257         }
    2258 
    2259         /**
    2260          * @ticket 41333
    2261          */
    2262         public function test_wp_initialize_site_already_initialized() {
    2263             $result = wp_initialize_site( get_current_blog_id() );
    2264             $this->assertWPError( $result );
    2265             $this->assertSame( 'site_already_initialized', $result->get_error_code() );
    2266         }
    2267 
    2268         /**
    2269          * @ticket 41333
    2270          */
    2271         public function test_wp_uninitialize_site() {
    2272             $site_id = self::factory()->blog->create();
    2273 
    2274             $result = wp_uninitialize_site( $site_id );
    2275             $this->assertTrue( $result );
    2276             $this->assertFalse( wp_is_site_initialized( $site_id ) );
    2277         }
    2278 
    2279         /**
    2280          * @ticket 41333
    2281          */
    2282         public function test_wp_uninitialize_site_empty_id() {
    2283             $result = wp_uninitialize_site( 0 );
    2284             $this->assertWPError( $result );
    2285             $this->assertSame( 'site_empty_id', $result->get_error_code() );
    2286         }
    2287 
    2288         /**
    2289          * @ticket 41333
    2290          */
    2291         public function test_wp_uninitialize_site_invalid_id() {
    2292             $result = wp_uninitialize_site( 123 );
    2293             $this->assertWPError( $result );
    2294             $this->assertSame( 'site_invalid_id', $result->get_error_code() );
    2295         }
    2296 
    2297         /**
    2298          * @ticket 41333
    2299          */
    2300         public function test_wp_uninitialize_site_already_uninitialized() {
    2301             $result = wp_uninitialize_site( self::$uninitialized_site_id );
    2302             $this->assertWPError( $result );
    2303             $this->assertSame( 'site_already_uninitialized', $result->get_error_code() );
    2304         }
    2305 
    2306         /**
    2307          * @ticket 41333
    2308          */
    2309         public function test_wp_is_site_initialized() {
    2310             $this->assertTrue( wp_is_site_initialized( get_current_blog_id() ) );
    2311             $this->assertFalse( wp_is_site_initialized( self::$uninitialized_site_id ) );
    2312         }
    2313 
    2314         /**
    2315          * @ticket 41333
    2316          */
    2317         public function test_wp_is_site_initialized_prefilter() {
    2318             add_filter( 'pre_wp_is_site_initialized', '__return_false' );
    2319             $this->assertFalse( wp_is_site_initialized( get_current_blog_id() ) );
    2320 
    2321             add_filter( 'pre_wp_is_site_initialized', '__return_true' );
    2322             $this->assertTrue( wp_is_site_initialized( self::$uninitialized_site_id ) );
    2323         }
    2324 
    2325         /**
    2326          * @ticket 41333
    2327          */
    2328         public function test_wp_insert_site_forwards_args_to_wp_initialize_site() {
    2329             $args = array(
    2330                 'user_id' => 1,
    2331                 'title'   => 'My Site',
    2332                 'options' => array( 'option1' => 'value1' ),
    2333                 'meta'    => array( 'meta1' => 'value1' ),
    2334             );
    2335 
    2336             add_filter( 'wp_initialize_site_args', array( $this, 'filter_wp_initialize_site_args_catch_args' ) );
    2337             $site_id = wp_insert_site(
    2338                 array_merge(
    2339                     array(
    2340                         'domain' => 'testsite.org',
    2341                         'path'   => '/',
    2342                     ),
    2343                     $args
    2344                 )
    2345             );
    2346 
    2347             $passed_args                   = $this->wp_initialize_site_args;
    2348             $this->wp_initialize_site_args = null;
    2349 
    2350             $this->assertSameSetsWithIndex( $args, $passed_args );
    2351         }
    2352 
    2353         public function filter_wp_initialize_site_args_catch_args( $args ) {
    2354             $this->wp_initialize_site_args = $args;
    2355 
    2356             return $args;
    2357         }
    2358 
    2359         /**
    2360          * @ticket 46125
    2361          */
    2362         public function test_wpmu_create_blog_cache_cleanup_backward_compatible() {
    2363             add_action( 'populate_options', array( $this, 'populate_options_callback' ) );
    2364 
    2365             $blog_id = wpmu_create_blog( 'testsite1.example.org', '/test', 'test', 1, array( 'public' => 1 ), 2 );
    2366 
    2367             // Should not hit blog_details cache initialised in $this->populate_options_callback tirggered during
    2368             // populate_options callback's call of get_blog_details.
    2369             $this->assertSame( 'http://testsite1.example.org/test', get_blog_details( $blog_id )->siteurl );
    2370             $this->assertSame( 'http://testsite1.example.org/test', get_site( $blog_id )->siteurl );
    2371 
    2372             remove_action( 'populate_options', array( $this, 'populate_options_callback' ) );
    2373         }
    2374 
    2375         /**
    2376          * Populate options callback to warm cache for blog-details / site-details cache group
    2377          */
    2378         public function populate_options_callback() {
    2379             // Cache blog details.
    2380             $blog_id = get_current_blog_id();
    2381             get_blog_details( $blog_id );
    2382             get_site( $blog_id )->siteurl;
    2383             // Set siteurl.
    2384             update_option( 'siteurl', 'http://testsite1.example.org/test' );
    2385         }
    2386 
    2387         /**
    2388          * Tests whether all expected meta are provided in deprecated `wpmu_new_blog` action.
    2389          *
    2390          * @dataProvider data_wpmu_new_blog_action_backward_commpatible
    2391          *
    2392          * @ticket 46351
    2393          */
    2394         public function test_wpmu_new_blog_action_backward_compatible( $meta, $expected_meta ) {
    2395             // We are testing deprecated hook. Register it to expected deprecated notices.
    2396             $this->setExpectedDeprecated( 'wpmu_new_blog' );
    2397             add_action( 'wpmu_new_blog', array( $this, 'wpmu_new_blog_callback' ), 10, 6 );
    2398 
    2399             wpmu_create_blog( 'testsite1.example.org', '/new-blog/', 'New Blog', get_current_user_id(), $meta, 1 );
    2400 
    2401             $this->assertSameSetsWithIndex( $expected_meta, $this->wp_initialize_site_meta );
    2402 
    2403             $this->wp_initialize_site_meta = array();
    2404         }
    2405 
    2406         /**
    2407          * @ticket 42251
    2408          */
    2409         public function test_get_site_not_found_cache() {
    2410             global $wpdb;
    2411 
    2412             $new_site_id = $this->_get_next_site_id();
    2413             $this->assertNull( get_site( $new_site_id ) );
    2414 
    2415             $num_queries = $wpdb->num_queries;
    2416             $this->assertNull( get_site( $new_site_id ) );
    2417             $this->assertSame( $num_queries, $wpdb->num_queries );
    2418         }
    2419 
    2420         /**
    2421          * @ticket 42251
    2422          */
    2423         public function test_get_site_not_found_cache_clear() {
    2424             $new_site_id = $this->_get_next_site_id();
    2425             $this->assertNull( get_site( $new_site_id ) );
    2426 
    2427             $new_site = self::factory()->blog->create_and_get();
    2428 
    2429             // Double-check we got the ID of the new site correct.
    2430             $this->assertEquals( $new_site_id, $new_site->blog_id );
    2431 
    2432             // Verify that if we fetch the site now, it's no longer false.
    2433             $fetched_site = get_site( $new_site_id );
    2434             $this->assertInstanceOf( 'WP_Site', $fetched_site );
    2435             $this->assertEquals( $new_site_id, $fetched_site->blog_id );
    2436 
    2437         }
    2438 
    2439         /**
    2440          * Gets the ID of the next site that will get inserted
    2441          * @return int
    2442          */
    2443         protected function _get_next_site_id() {
    2444             global $wpdb;
    2445             // Create an entry.
    2446             static::factory()->blog->create();
    2447             // Get the ID after it.
    2448             return (int) $wpdb->get_var( 'SELECT blog_id FROM ' . $wpdb->blogs . ' ORDER BY blog_ID DESC LIMIT 1' ) + 1;
    2449         }
    2450 
    2451         /**
    2452          * Capture the $meta value passed to the wpmu_new_blog action and compare it.
    2453          */
    2454         public function wpmu_new_blog_callback( $blog_id, $user_id, $domain, $path, $network_id, $meta ) {
    2455             $this->wp_initialize_site_meta = $meta;
    2456         }
    2457 
    2458         public function data_wpmu_new_blog_action_backward_commpatible() {
    2459             return array(
    2460                 'default values' => array(
    2461                     array(),
    2462                     array(
    2463                         'public' => 0, // `public` is one of the default metas in `wpmu_create_blog()' function prior to WordPress 5.1.0.
    2464                         'WPLANG' => 'en_US', // WPLANG is another default meta in `wpmu_create_blog()` function prior to WordPress 5.1.0.
    2465                     ),
    2466                 ),
    2467                 'public site'    => array(
    2468                     array(
    2469                         'public' => 1,
    2470                     ),
    2471                     array(
    2472                         'public' => 1,
    2473                         'WPLANG' => 'en_US',
    2474                     ),
    2475                 ),
    2476                 'allowed_keys'   => array(
    2477                     array(
    2478                         'public'   => -1,
    2479                         'archived' => 0,
    2480                         'mature'   => 0,
    2481                         'spam'     => 0,
    2482                         'deleted'  => 0,
    2483                         'lang_id'  => 11,
    2484 
    2485                     ),
    2486                     array(
    2487                         'public'   => -1,
    2488                         'WPLANG'   => 'en_US',
    2489                         'archived' => 0,
    2490                         'mature'   => 0,
    2491                         'spam'     => 0,
    2492                         'deleted'  => 0,
    2493                         'lang_id'  => 11,
    2494                     ),
    2495                 ),
    2496                 'extra meta key' => array(
    2497                     array(
    2498                         'foo' => 'bar',
    2499                     ),
    2500                     array(
    2501                         'public' => 0,
    2502                         'foo'    => 'bar',
    2503                         'WPLANG' => 'en_US',
    2504                     ),
    2505                 ),
    2506             );
    2507         }
    2508239    }
    2509240
Note: See TracChangeset for help on using the changeset viewer.