WordPress.org

Make WordPress Core

Ticket #29896: 29896.3.diff

File 29896.3.diff, 202.3 KB (added by jeremyfelt, 6 years ago)
  • tests/phpunit/tests/ms.php

     
    1 <?php
    2 
    3 if ( is_multisite() ) :
    4 
    5 /**
    6  * A set of unit tests for WordPress Multisite
    7  *
    8  * @group multisite
    9  */
    10 class Tests_MS extends WP_UnitTestCase {
    11         protected $plugin_hook_count = 0;
    12         protected $suppress = false;
    13 
    14         function setUp() {
    15                 global $wpdb;
    16                 parent::setUp();
    17                 $this->suppress = $wpdb->suppress_errors();
    18 
    19                 $_SERVER['REMOTE_ADDR'] = '';
    20         }
    21 
    22         function tearDown() {
    23                 global $wpdb;
    24                 parent::tearDown();
    25                 $wpdb->suppress_errors( $this->suppress );
    26         }
    27 
    28         function test_remove_user_from_blog() {
    29                 $user1 = $this->factory->user->create_and_get();
    30                 $user2 = $this->factory->user->create_and_get();
    31 
    32                 $post_id = $this->factory->post->create( array( 'post_author' => $user1->ID ) );
    33 
    34                 remove_user_from_blog( $user1->ID, 1, $user2->ID );
    35 
    36                 $post = get_post( $post_id );
    37 
    38                 $this->assertNotEquals( $user1->ID, $post->post_author );
    39                 $this->assertEquals( $user2->ID, $post->post_author );
    40         }
    41 
    42         /**
    43          * @ticket 22917
    44          */
    45         function test_enable_live_network_site_counts_filter() {
    46                 $site_count_start = get_blog_count();
    47                 // false for large networks by default
    48                 add_filter( 'enable_live_network_counts', '__return_false' );
    49                 $this->factory->blog->create_many( 4 );
    50 
    51                 // count only updated when cron runs, so unchanged
    52                 $this->assertEquals( $site_count_start, (int) get_blog_count() );
    53 
    54                 add_filter( 'enable_live_network_counts', '__return_true' );
    55                 $site_ids = $this->factory->blog->create_many( 4 );
    56 
    57                 $this->assertEquals( $site_count_start + 9, (int) get_blog_count() );
    58 
    59                 //clean up
    60                 remove_filter( 'enable_live_network_counts', '__return_false' );
    61                 remove_filter( 'enable_live_network_counts', '__return_true' );
    62                 foreach ( $site_ids as $site_id ) {
    63                         wpmu_delete_blog( $site_id, true );
    64                 }
    65         }
    66 
    67         /**
    68          * @ticket 22917
    69          */
    70         function test_enable_live_network_user_counts_filter() {
    71                 // false for large networks by default
    72                 add_filter( 'enable_live_network_counts', '__return_false' );
    73 
    74                 // Refresh the cache
    75                 wp_update_network_counts();
    76                 $start_count = get_user_count();
    77 
    78                 wpmu_create_user( 'user', 'pass', 'email' );
    79 
    80                 // No change, cache not refreshed
    81                 $count = get_user_count();
    82 
    83                 $this->assertEquals( $start_count, $count );
    84 
    85                 wp_update_network_counts();
    86                 $start_count = get_user_count();
    87 
    88                 add_filter( 'enable_live_network_counts', '__return_true' );
    89 
    90                 wpmu_create_user( 'user2', 'pass2', 'email2' );
    91 
    92                 $count = get_user_count();
    93                 $this->assertEquals( $start_count + 1, $count );
    94 
    95                 remove_filter( 'enable_live_network_counts', '__return_false' );
    96                 remove_filter( 'enable_live_network_counts', '__return_true' );
    97         }
    98 
    99         function test_create_and_delete_blog() {
    100                 global $wpdb;
    101 
    102                 $blog_ids = $this->factory->blog->create_many( 4 );
    103                 foreach ( $blog_ids as $blog_id ) {
    104                         $this->assertInternalType( 'int', $blog_id );
    105                         $prefix = $wpdb->get_blog_prefix( $blog_id );
    106 
    107                         // $get_all = false
    108                         $details = get_blog_details( $blog_id, false );
    109                         $this->assertEquals( $details, wp_cache_get( $blog_id . 'short', 'blog-details' ) );
    110 
    111                         // get_id_from_blogname(), see #20950
    112                         $this->assertEquals( $blog_id, get_id_from_blogname( $details->path ) );
    113                         $this->assertEquals( $blog_id, wp_cache_get( 'get_id_from_blogname_' . trim( $details->path, '/' ), 'blog-details' ) );
    114 
    115                         // get_blog_id_from_url()
    116                         $this->assertEquals( $blog_id, get_blog_id_from_url( $details->domain, $details->path ) );
    117                         $key = md5( $details->domain . $details->path );
    118                         $this->assertEquals( $blog_id, wp_cache_get( $key, 'blog-id-cache' ) );
    119 
    120                         // These are empty until get_blog_details() is called with $get_all = true
    121                         $this->assertEquals( false, wp_cache_get( $blog_id, 'blog-details' ) );
    122                         $key = md5( $details->domain . $details->path );
    123                         $this->assertEquals( false, wp_cache_get( $key, 'blog-lookup' ) );
    124 
    125                         // $get_all = true should propulate the full blog-details cache and the blog slug lookup cache
    126                         $details = get_blog_details( $blog_id, true );
    127                         $this->assertEquals( $details, wp_cache_get( $blog_id, 'blog-details' ) );
    128                         $this->assertEquals( $details, wp_cache_get( $key, 'blog-lookup' ) );
    129 
    130                         foreach ( $wpdb->tables( 'blog', false ) as $table ) {
    131                                 $suppress = $wpdb->suppress_errors();
    132                                 $table_fields = $wpdb->get_results( "DESCRIBE $prefix$table;" );
    133                                 $wpdb->suppress_errors( $suppress );
    134                                 $this->assertNotEmpty( $table_fields );
    135                                 $result = $wpdb->get_results( "SELECT * FROM $prefix$table LIMIT 1" );
    136                                 if ( 'commentmeta' == $table || 'links' == $table )
    137                                         $this->assertEmpty( $result );
    138                                 else
    139                                         $this->assertNotEmpty( $result );
    140                         }
    141                 }
    142 
    143                 // update the blog count cache to use get_blog_count()
    144                 wp_update_network_counts();
    145                 $this->assertEquals( 4 + 1, (int) get_blog_count() );
    146 
    147                 $drop_tables = false;
    148                 // delete all blogs
    149                 foreach ( $blog_ids as $blog_id ) {
    150                         // drop tables for every second blog
    151                         $drop_tables = ! $drop_tables;
    152                         $details = get_blog_details( $blog_id, false );
    153 
    154                         wpmu_delete_blog( $blog_id, $drop_tables );
    155 
    156                         $this->assertEquals( false, wp_cache_get( 'get_id_from_blogname_' . trim( $details->path, '/' ), 'blog-details' ) );
    157                         $this->assertEquals( false, wp_cache_get( $blog_id, 'blog-details' ) );
    158                         $this->assertEquals( false, wp_cache_get( $blog_id . 'short', 'blog-details' ) );
    159                         $key = md5( $details->domain . $details->path );
    160                         $this->assertEquals( false, wp_cache_get( $key, 'blog-lookup' ) );
    161                         $this->assertEquals( false, wp_cache_get( $key, 'blog-id-cache' ) );
    162 
    163                         $prefix = $wpdb->get_blog_prefix( $blog_id );
    164                         foreach ( $wpdb->tables( 'blog', false ) as $table ) {
    165                                 $suppress = $wpdb->suppress_errors();
    166                                 $table_fields = $wpdb->get_results( "DESCRIBE $prefix$table;" );
    167                                 $wpdb->suppress_errors( $suppress );
    168                                 if ( $drop_tables )
    169                                         $this->assertEmpty( $table_fields );
    170                                 else
    171                                         $this->assertNotEmpty( $table_fields, $prefix . $table );
    172                         }
    173                 }
    174 
    175                 // update the blog count cache to use get_blog_count()
    176                 wp_update_network_counts();
    177                 $this->assertEquals( 1, get_blog_count() );
    178         }
    179 
    180         function test_get_blogs_of_user() {
    181                 // Logged out users don't have blogs.
    182                 $this->assertEquals( array(), get_blogs_of_user( 0 ) );
    183 
    184                 $user1_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    185                 $blog_ids = $this->factory->blog->create_many( 10, array( 'user_id' => $user1_id ) );
    186 
    187                 foreach ( $blog_ids as $blog_id )
    188                         $this->assertInternalType( 'int', $blog_id );
    189 
    190                 $blogs_of_user = array_keys( get_blogs_of_user( $user1_id, false ) );
    191                 sort( $blogs_of_user );
    192                 $this->assertEquals ( array_merge( array( 1 ), $blog_ids), $blogs_of_user );
    193 
    194                 $this->assertTrue( remove_user_from_blog( $user1_id, 1 ) );
    195 
    196                 $blogs_of_user = array_keys( get_blogs_of_user( $user1_id, false ) );
    197                 sort( $blogs_of_user );
    198                 $this->assertEquals ( $blog_ids, $blogs_of_user );
    199 
    200                 foreach ( get_blogs_of_user( $user1_id, false ) as $blog ) {
    201                         $this->assertTrue( isset( $blog->userblog_id ) );
    202                         $this->assertTrue( isset( $blog->blogname ) );
    203                         $this->assertTrue( isset( $blog->domain ) );
    204                         $this->assertTrue( isset( $blog->path ) );
    205                         $this->assertTrue( isset( $blog->site_id ) );
    206                         $this->assertTrue( isset( $blog->siteurl ) );
    207                         $this->assertTrue( isset( $blog->archived ) );
    208                         $this->assertTrue( isset( $blog->spam ) );
    209                         $this->assertTrue( isset( $blog->deleted ) );
    210                 }
    211 
    212                 // Non-existent users don't have blogs.
    213                 wpmu_delete_user( $user1_id );
    214                 $user = new WP_User( $user1_id );
    215                 $this->assertFalse( $user->exists(), 'WP_User->exists' );
    216                 $this->assertEquals( array(), get_blogs_of_user( $user1_id ) );
    217         }
    218 
    219         /**
    220          * @expectedDeprecated is_blog_user
    221          */
    222         function test_is_blog_user() {
    223                 global $wpdb;
    224 
    225                 $user1_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    226 
    227                 $old_current = get_current_user_id();
    228                 wp_set_current_user( $user1_id );
    229 
    230                 $this->assertTrue( is_blog_user() );
    231                 $this->assertTrue( is_blog_user( $wpdb->blogid ) );
    232 
    233                 $blog_ids = array();
    234 
    235                 $blog_ids = $this->factory->blog->create_many( 5 );
    236                 foreach ( $blog_ids as $blog_id ) {
    237                         $this->assertInternalType( 'int', $blog_id );
    238                         $this->assertTrue( is_blog_user( $blog_id ) );
    239                         $this->assertTrue( remove_user_from_blog( $user1_id, $blog_id ) );
    240                         $this->assertFalse( is_blog_user( $blog_id ) );
    241                 }
    242 
    243                 wp_set_current_user( $old_current );
    244         }
    245 
    246         function test_is_user_member_of_blog() {
    247                 global $wpdb;
    248 
    249                 $user1_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    250 
    251                 $old_current = get_current_user_id();
    252                 wp_set_current_user( $user1_id );
    253 
    254                 $this->assertTrue( is_user_member_of_blog() );
    255                 $this->assertTrue( is_user_member_of_blog( 0, 0 ) );
    256                 $this->assertTrue( is_user_member_of_blog( 0, $wpdb->blogid ) );
    257                 $this->assertTrue( is_user_member_of_blog( $user1_id ) );
    258                 $this->assertTrue( is_user_member_of_blog( $user1_id, $wpdb->blogid ) );
    259 
    260                 $blog_ids = $this->factory->blog->create_many( 5 );
    261                 foreach ( $blog_ids as $blog_id ) {
    262                         $this->assertInternalType( 'int', $blog_id );
    263                         $this->assertTrue( is_user_member_of_blog( $user1_id, $blog_id ) );
    264                         $this->assertTrue( remove_user_from_blog( $user1_id, $blog_id ) );
    265                         $this->assertFalse( is_user_member_of_blog( $user1_id, $blog_id ) );
    266                 }
    267 
    268                 wpmu_delete_user( $user1_id );
    269                 $user = new WP_User( $user1_id );
    270                 $this->assertFalse( $user->exists(), 'WP_User->exists' );
    271                 $this->assertFalse( is_user_member_of_blog( $user1_id ), 'is_user_member_of_blog' );
    272 
    273                 wp_set_current_user( $old_current );
    274         }
    275 
    276         function test_active_network_plugins() {
    277                 $path = "hello.php";
    278 
    279                 // local activate, should be invisible for the network
    280                 activate_plugin($path); // $network_wide = false
    281                 $active_plugins = wp_get_active_network_plugins();
    282                 $this->assertEquals( Array(), $active_plugins );
    283 
    284                 add_action( 'deactivated_plugin', array( $this, '_helper_deactivate_hook' ) );
    285 
    286                 // activate the plugin sitewide
    287                 activate_plugin($path, '', $network_wide = true);
    288                 $active_plugins = wp_get_active_network_plugins();
    289                 $this->assertEquals( Array(WP_PLUGIN_DIR . '/hello.php'), $active_plugins );
    290 
    291                 //deactivate the plugin
    292                 deactivate_plugins($path);
    293                 $active_plugins = wp_get_active_network_plugins();
    294                 $this->assertEquals( Array(), $active_plugins );
    295 
    296                 $this->assertEquals( 1, $this->plugin_hook_count ); // testing actions and silent mode
    297 
    298                 activate_plugin($path, '', $network_wide = true);
    299                 deactivate_plugins($path, true); // silent
    300 
    301                 $this->assertEquals( 1, $this->plugin_hook_count ); // testing actions and silent mode
    302         }
    303 
    304         /**
    305          * @ticket 28651
    306          */
    307         function test_duplicate_network_active_plugin() {
    308                 $path = "hello.php";
    309                 $mock = new MockAction();
    310                 add_action( 'activate_' . $path, array ( $mock, 'action' ) );
    311 
    312                 // should activate on the first try
    313                 activate_plugin( $path, '', true );
    314                 $active_plugins = wp_get_active_network_plugins();
    315                 $this->assertCount( 1, $active_plugins );
    316                 $this->assertEquals( 1, $mock->get_call_count() );
    317 
    318                 // should do nothing on the second try
    319                 activate_plugin( $path, '', true );
    320                 $active_plugins = wp_get_active_network_plugins();
    321                 $this->assertCount( 1, $active_plugins );
    322                 $this->assertEquals( 1, $mock->get_call_count() );
    323 
    324                 remove_action( 'activate_' . $path, array ( $mock, 'action' ) );
    325         }
    326 
    327         function _helper_deactivate_hook() {
    328                 $this->plugin_hook_count++;
    329         }
    330 
    331         function test_get_user_count() {
    332                 // Refresh the cache
    333                 wp_update_network_counts();
    334                 $start_count = get_user_count();
    335 
    336                 // Only false for large networks as of 3.7
    337                 add_filter( 'enable_live_network_counts', '__return_false' );
    338                 $this->factory->user->create( array( 'role' => 'administrator' ) );
    339 
    340                 $count = get_user_count(); // No change, cache not refreshed
    341                 $this->assertEquals( $start_count, $count );
    342 
    343                 wp_update_network_counts(); // Magic happens here
    344 
    345                 $count = get_user_count();
    346                 $this->assertEquals( $start_count + 1, $count );
    347                 remove_filter( 'enable_live_network_counts', '__return_false' );
    348         }
    349 
    350         function test_wp_schedule_update_network_counts() {
    351                 $this->assertFalse(wp_next_scheduled('update_network_counts'));
    352 
    353                 // We can't use wp_schedule_update_network_counts() because WP_INSTALLING is set
    354                 wp_schedule_event(time(), 'twicedaily', 'update_network_counts');
    355 
    356                 $this->assertInternalType('int', wp_next_scheduled('update_network_counts'));
    357         }
    358 
    359         function test_users_can_register_signup_filter() {
    360 
    361                 $registration = get_site_option('registration');
    362                 $this->assertFalse( users_can_register_signup_filter() );
    363 
    364                 update_site_option('registration', 'all');
    365                 $this->assertTrue( users_can_register_signup_filter() );
    366 
    367                 update_site_option('registration', 'user');
    368                 $this->assertTrue( users_can_register_signup_filter() );
    369 
    370                 update_site_option('registration', 'none');
    371                 $this->assertFalse( users_can_register_signup_filter() );
    372         }
    373 
    374         /**
    375          * @expectedDeprecated get_dashboard_blog
    376          */
    377         function test_get_dashboard_blog() {
    378                 // if there is no dashboard blog set, current blog is used
    379                 $dashboard_blog = get_dashboard_blog();
    380                 $this->assertEquals( 1, $dashboard_blog->blog_id );
    381 
    382                 $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    383                 $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id ) );
    384                 $this->assertInternalType( 'int', $blog_id );
    385 
    386                 // set the dashboard blog to another one
    387                 update_site_option( 'dashboard_blog', $blog_id );
    388                 $dashboard_blog = get_dashboard_blog();
    389                 $this->assertEquals( $blog_id, $dashboard_blog->blog_id );
    390         }
    391 
    392         function test_wpmu_log_new_registrations() {
    393                 global $wpdb;
    394 
    395                 $user = new WP_User( 1 );
    396                 $ip = preg_replace( '/[^0-9., ]/', '',$_SERVER['REMOTE_ADDR'] );
    397 
    398                 wpmu_log_new_registrations(1,1);
    399 
    400                 // currently there is no wrapper function for the registration_log
    401                 $reg_blog = $wpdb->get_col( "SELECT email FROM {$wpdb->registration_log} WHERE {$wpdb->registration_log}.blog_id = 1 AND IP LIKE '" . $ip . "'" );
    402                 $this->assertEquals( $user->user_email, $reg_blog[ count( $reg_blog )-1 ] );
    403         }
    404 
    405         /**
    406          * @ticket 18119
    407          */
    408         function test_upload_is_user_over_quota() {
    409                 $default_space_allowed = 100;
    410                 $echo = false;
    411 
    412                 $this->assertFalse( upload_is_user_over_quota( $echo ) );
    413                 $this->assertTrue( is_upload_space_available() );
    414 
    415                 update_site_option('upload_space_check_disabled', true);
    416                 $this->assertFalse( upload_is_user_over_quota( $echo ) );
    417                 $this->assertTrue( is_upload_space_available() );
    418 
    419                 update_site_option( 'blog_upload_space', 0 );
    420                 $this->assertFalse( upload_is_user_over_quota( $echo ) );
    421                 $this->assertEquals( $default_space_allowed, get_space_allowed() );
    422                 $this->assertTrue( is_upload_space_available() );
    423 
    424                 update_site_option('upload_space_check_disabled', false);
    425                 $this->assertFalse( upload_is_user_over_quota( $echo ) );
    426                 $this->assertTrue( is_upload_space_available() );
    427 
    428                 if ( defined( 'BLOGSUPLOADDIR' ) && ! file_exists( BLOGSUPLOADDIR ) )
    429                         $this->markTestSkipped( 'This test is broken when blogs.dir does not exist. ');
    430 
    431                 /*
    432                 This is broken when blogs.dir does not exist, as get_upload_space_available()
    433                 simply returns the value of blog_upload_space (converted to bytes), which would
    434                 be negative but still not false. When blogs.dir does exist, < 0 is returned as 0.
    435                 */
    436 
    437                 update_site_option( 'blog_upload_space', -1 );
    438                 $this->assertTrue( upload_is_user_over_quota( $echo ) );
    439                 $this->assertEquals( -1, get_space_allowed() );
    440                 $this->assertFalse( is_upload_space_available() );
    441 
    442                 update_option( 'blog_upload_space', 0 );
    443                 $this->assertFalse( upload_is_user_over_quota( $echo ) );
    444                 $this->assertEquals( $default_space_allowed, get_space_allowed() );
    445                 $this->assertTrue( is_upload_space_available() );
    446 
    447                 update_option( 'blog_upload_space', -1 );
    448                 $this->assertTrue( upload_is_user_over_quota( $echo ) );
    449                 $this->assertEquals( -1, get_space_allowed() );
    450                 $this->assertFalse( is_upload_space_available() );
    451         }
    452 
    453         function test_wpmu_update_blogs_date() {
    454                 global $wpdb;
    455 
    456                 wpmu_update_blogs_date();
    457 
    458                 // compare the update time with the current time, allow delta < 2
    459                 $blog = get_blog_details( $wpdb->blogid );
    460                 $current_time = time();
    461                 $time_difference = $current_time - strtotime( $blog->last_updated );
    462                 $this->assertLessThan( 2, $time_difference );
    463         }
    464 
    465         function test_getters(){
    466                 global $current_site;
    467 
    468                 $blog_id = get_current_blog_id();
    469                 $blog = get_blog_details( $blog_id );
    470                 $this->assertEquals( $blog_id, $blog->blog_id );
    471                 $this->assertEquals( $current_site->domain, $blog->domain );
    472                 $this->assertEquals( '/', $blog->path );
    473 
    474                 // Test defaulting to current blog
    475                 $this->assertEquals( $blog, get_blog_details() );
    476 
    477                 $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    478                 $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id, 'path' => '/test_blogname', 'title' => 'Test Title' ) );
    479                 $this->assertInternalType( 'int', $blog_id );
    480 
    481                 $this->assertEquals( 'http://' . $current_site->domain . $current_site->path . 'test_blogname/', get_blogaddress_by_name('test_blogname') );
    482 
    483                 $this->assertEquals( $blog_id, get_id_from_blogname('test_blogname') );
    484         }
    485 
    486         function _action_counter_cb( $blog_id ) {
    487                 global $test_action_counter;
    488                 $test_action_counter++;
    489         }
    490 
    491         function test_update_blog_details() {
    492                 global $test_action_counter;
    493 
    494                 $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    495                 $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id, 'path' => '/test_blogpath', 'title' => 'Test Title' ) );
    496                 $this->assertInternalType( 'int', $blog_id );
    497 
    498                 $result = update_blog_details( $blog_id, array('domain' => 'example.com', 'path' => 'my_path/') );
    499                 $this->assertTrue( $result );
    500 
    501                 $blog = get_blog_details( $blog_id );
    502                 $this->assertEquals( 'example.com', $blog->domain );
    503                 $this->assertEquals( 'my_path/', $blog->path );
    504                 $this->assertEquals( '0', $blog->spam );
    505 
    506                 $result = update_blog_details( $blog_id, array('domain' => 'example2.com','spam' => 1) );
    507                 $this->assertTrue( $result );
    508                 $blog = get_blog_details( $blog_id );
    509                 $this->assertEquals( 'example2.com', $blog->domain );
    510                 $this->assertEquals( 'my_path/', $blog->path );
    511                 $this->assertEquals( '1', $blog->spam );
    512 
    513                 $result = update_blog_details( $blog_id );
    514                 $this->assertFalse( $result );
    515                 $blog = get_blog_details( $blog_id );
    516                 $this->assertEquals( 'example2.com', $blog->domain );
    517                 $this->assertEquals( 'my_path/', $blog->path );
    518                 $this->assertEquals( '1', $blog->spam );
    519 
    520                 $test_action_counter = 0;
    521 
    522                 add_action( 'make_ham_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    523                 $result = update_blog_details( $blog_id, array( 'spam' => 0 ) );
    524                 $this->assertTrue( $result );
    525                 $blog = get_blog_details( $blog_id );
    526                 $this->assertEquals( '0', $blog->spam );
    527                 $this->assertEquals( 1, $test_action_counter );
    528 
    529                 // Same again
    530                 $result = update_blog_details( $blog_id, array( 'spam' => 0 ) );
    531                 $this->assertTrue( $result );
    532                 $blog = get_blog_details( $blog_id );
    533                 $this->assertEquals( '0', $blog->spam );
    534                 $this->assertEquals( 1, $test_action_counter );
    535                 remove_action( 'make_ham_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    536 
    537                 add_action( 'make_spam_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    538                 $result = update_blog_details( $blog_id, array( 'spam' => 1 ) );
    539                 $this->assertTrue( $result );
    540                 $blog = get_blog_details( $blog_id );
    541                 $this->assertEquals( '1', $blog->spam );
    542                 $this->assertEquals( 2, $test_action_counter );
    543 
    544                 // Same again
    545                 $result = update_blog_details( $blog_id, array( 'spam' => 1 ) );
    546                 $this->assertTrue( $result );
    547                 $blog = get_blog_details( $blog_id );
    548                 $this->assertEquals( '1', $blog->spam );
    549                 $this->assertEquals( 2, $test_action_counter );
    550                 remove_action( 'make_spam_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    551 
    552                 add_action( 'archive_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    553                 $result = update_blog_details( $blog_id, array( 'archived' => 1 ) );
    554                 $this->assertTrue( $result );
    555                 $blog = get_blog_details( $blog_id );
    556                 $this->assertEquals( '1', $blog->archived );
    557                 $this->assertEquals( 3, $test_action_counter );
    558 
    559                 // Same again
    560                 $result = update_blog_details( $blog_id, array( 'archived' => 1 ) );
    561                 $this->assertTrue( $result );
    562                 $blog = get_blog_details( $blog_id );
    563                 $this->assertEquals( '1', $blog->archived );
    564                 $this->assertEquals( 3, $test_action_counter );
    565                 remove_action( 'archive_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    566 
    567                 add_action( 'unarchive_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    568                 $result = update_blog_details( $blog_id, array( 'archived' => 0 ) );
    569                 $this->assertTrue( $result );
    570                 $blog = get_blog_details( $blog_id );
    571                 $this->assertEquals( '0', $blog->archived );
    572                 $this->assertEquals( 4, $test_action_counter );
    573 
    574                 // Same again
    575                 $result = update_blog_details( $blog_id, array( 'archived' => 0 ) );
    576                 $this->assertTrue( $result );
    577                 $blog = get_blog_details( $blog_id );
    578                 $this->assertEquals( '0', $blog->archived );
    579                 $this->assertEquals( 4, $test_action_counter );
    580                 remove_action( 'unarchive_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    581 
    582                 add_action( 'make_delete_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    583                 $result = update_blog_details( $blog_id, array( 'deleted' => 1 ) );
    584                 $this->assertTrue( $result );
    585                 $blog = get_blog_details( $blog_id );
    586                 $this->assertEquals( '1', $blog->deleted );
    587                 $this->assertEquals( 5, $test_action_counter );
    588 
    589                 // Same again
    590                 $result = update_blog_details( $blog_id, array( 'deleted' => 1 ) );
    591                 $this->assertTrue( $result );
    592                 $blog = get_blog_details( $blog_id );
    593                 $this->assertEquals( '1', $blog->deleted );
    594                 $this->assertEquals( 5, $test_action_counter );
    595                 remove_action( 'make_delete_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    596 
    597                 add_action( 'make_undelete_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    598                 $result = update_blog_details( $blog_id, array( 'deleted' => 0 ) );
    599                 $this->assertTrue( $result );
    600                 $blog = get_blog_details( $blog_id );
    601                 $this->assertEquals( '0', $blog->deleted );
    602                 $this->assertEquals( 6, $test_action_counter );
    603 
    604                 // Same again
    605                 $result = update_blog_details( $blog_id, array( 'deleted' => 0 ) );
    606                 $this->assertTrue( $result );
    607                 $blog = get_blog_details( $blog_id );
    608                 $this->assertEquals( '0', $blog->deleted );
    609                 $this->assertEquals( 6, $test_action_counter );
    610                 remove_action( 'make_undelete_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    611 
    612                 add_action( 'mature_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    613                 $result = update_blog_details( $blog_id, array( 'mature' => 1 ) );
    614                 $this->assertTrue( $result );
    615                 $blog = get_blog_details( $blog_id );
    616                 $this->assertEquals( '1', $blog->mature );
    617                 $this->assertEquals( 7, $test_action_counter );
    618 
    619                 // Same again
    620                 $result = update_blog_details( $blog_id, array( 'mature' => 1 ) );
    621                 $this->assertTrue( $result );
    622                 $blog = get_blog_details( $blog_id );
    623                 $this->assertEquals( '1', $blog->mature );
    624                 $this->assertEquals( 7, $test_action_counter );
    625                 remove_action( 'mature_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    626 
    627                 add_action( 'unmature_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    628                 $result = update_blog_details( $blog_id, array( 'mature' => 0 ) );
    629                 $this->assertTrue( $result );
    630                 $blog = get_blog_details( $blog_id );
    631                 $this->assertEquals( '0', $blog->mature );
    632                 $this->assertEquals( 8, $test_action_counter );
    633 
    634                 // Same again
    635                 $result = update_blog_details( $blog_id, array( 'mature' => 0 ) );
    636                 $this->assertTrue( $result );
    637                 $blog = get_blog_details( $blog_id );
    638                 $this->assertEquals( '0', $blog->mature );
    639                 $this->assertEquals( 8, $test_action_counter );
    640                 remove_action( 'unmature_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    641         }
    642 
    643         /**
    644          * Test fetching a blog that doesn't exist and again after it exists.
    645          *
    646          * @ticket 23405
    647          */
    648         function test_get_blog_details_blog_does_not_exist() {
    649                 global $wpdb;
    650 
    651                 $blog_id = $wpdb->get_var( "SELECT MAX(blog_id) FROM $wpdb->blogs" );
    652 
    653                 // An idosyncrancy of the unit tests is that the max blog_id gets reset
    654                 // to 1 in between test cases but picks up where it previously left off
    655                 // on the next insert. If 1 is reported, burn a blog create to get
    656                 // the max counter back in sync.
    657                 if ( 1 == $blog_id ) {
    658                         $blog_id = $this->factory->blog->create();
    659                 }
    660                 $blog_id++;
    661 
    662                 $this->assertFalse( wp_cache_get( $blog_id, 'blog-details' ) );
    663                 $this->assertFalse( get_blog_details( $blog_id ) );
    664                 $this->assertEquals( -1, wp_cache_get( $blog_id, 'blog-details' ) );
    665                 $this->assertFalse( get_blog_details( $blog_id ) );
    666                 $this->assertEquals( -1, wp_cache_get( $blog_id, 'blog-details' ) );
    667 
    668                 $this->assertEquals( $blog_id, $this->factory->blog->create() );
    669                 $this->assertFalse( wp_cache_get( $blog_id, 'blog-details' )  );
    670 
    671                 $blog = get_blog_details( $blog_id );
    672                 $this->assertEquals( $blog_id, $blog->blog_id );
    673                 $this->assertEquals( $blog, wp_cache_get( $blog_id, 'blog-details' ) );
    674 
    675                 wpmu_delete_blog( $blog_id );
    676                 $this->assertFalse( wp_cache_get( $blog_id, 'blog-details' ) );
    677                 $blog->deleted = '1';
    678                 $this->assertEQuals( $blog, get_blog_details( $blog_id ) );
    679                 $this->assertEquals( $blog, wp_cache_get( $blog_id, 'blog-details' ) );
    680 
    681                 wpmu_delete_blog( $blog_id, true );
    682                 $this->assertFalse( get_blog_details( $blog_id ) );
    683                 $this->assertEquals( -1, wp_cache_get( $blog_id, 'blog-details' ) );
    684         }
    685 
    686         function test_update_blog_status() {
    687                 global $test_action_counter;
    688 
    689                 $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    690                 $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id, 'path' => '/test_blogpath', 'title' => 'Test Title' ) );
    691                 $this->assertInternalType( 'int', $blog_id );
    692 
    693                 $test_action_counter = 0;
    694                 $count = 1;
    695 
    696                 add_action( 'make_ham_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    697                 $result = update_blog_status( $blog_id, 'spam', 0 );
    698                 $this->assertEquals( 0, $result );
    699                 $blog = get_blog_details( $blog_id );
    700                 $this->assertEquals( '0', $blog->spam );
    701                 $this->assertEquals( $count, $test_action_counter );
    702 
    703                 // Same again
    704                 $count++;
    705                 $result = update_blog_status( $blog_id, 'spam', 0 );
    706                 $this->assertEquals( 0, $result );
    707                 $blog = get_blog_details( $blog_id );
    708                 $this->assertEquals( '0', $blog->spam );
    709                 $this->assertEquals( $count, $test_action_counter );
    710                 remove_action( 'make_ham_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    711 
    712                 $count++;
    713                 add_action( 'make_spam_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    714                 $result = update_blog_status( $blog_id, 'spam', 1 );
    715                 $this->assertEquals( 1, $result );
    716                 $blog = get_blog_details( $blog_id );
    717                 $this->assertEquals( '1', $blog->spam );
    718                 $this->assertEquals( $count, $test_action_counter );
    719 
    720                 // Same again
    721                 $count++;
    722                 $result = update_blog_status( $blog_id, 'spam', 1 );
    723                 $this->assertEquals( 1, $result );
    724                 $blog = get_blog_details( $blog_id );
    725                 $this->assertEquals( '1', $blog->spam );
    726                 $this->assertEquals( $count, $test_action_counter );
    727                 remove_action( 'make_spam_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    728 
    729                 add_action( 'archive_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    730                 $count++;
    731                 $result = update_blog_status( $blog_id, 'archived', 1 );
    732                 $this->assertEquals( 1, $result );
    733                 $blog = get_blog_details( $blog_id );
    734                 $this->assertEquals( '1', $blog->archived );
    735                 $this->assertEquals( $count, $test_action_counter );
    736 
    737                 // Same again
    738                 $count++;
    739                 $result = update_blog_status( $blog_id, 'archived', 1 );
    740                 $this->assertEquals( 1, $result );
    741                 $blog = get_blog_details( $blog_id );
    742                 $this->assertEquals( '1', $blog->archived );
    743                 $this->assertEquals( $count, $test_action_counter );
    744                 remove_action( 'archive_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    745 
    746                 add_action( 'unarchive_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    747                 $count++;
    748                 $result = update_blog_status( $blog_id, 'archived', 0 );
    749                 $this->assertEquals( 0, $result );
    750                 $blog = get_blog_details( $blog_id );
    751                 $this->assertEquals( '0', $blog->archived );
    752                 $this->assertEquals( $count, $test_action_counter );
    753 
    754                 // Same again
    755                 $result = update_blog_status( $blog_id, 'archived', 0 );
    756                 $count++;
    757                 $this->assertEquals( 0, $result );
    758                 $blog = get_blog_details( $blog_id );
    759                 $this->assertEquals( '0', $blog->archived );
    760                 $this->assertEquals( $count, $test_action_counter );
    761                 remove_action( 'unarchive_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    762 
    763                 add_action( 'make_delete_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    764                 $count++;
    765                 $result = update_blog_status( $blog_id, 'deleted', 1 );
    766                 $this->assertEquals( 1, $result );
    767                 $blog = get_blog_details( $blog_id );
    768                 $this->assertEquals( '1', $blog->deleted );
    769                 $this->assertEquals( $count, $test_action_counter );
    770 
    771                 // Same again
    772                 $count++;
    773                 $result = update_blog_status( $blog_id, 'deleted', 1 );
    774                 $this->assertEquals( 1, $result );
    775                 $blog = get_blog_details( $blog_id );
    776                 $this->assertEquals( '1', $blog->deleted );
    777                 $this->assertEquals( $count, $test_action_counter );
    778                 remove_action( 'make_delete_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    779 
    780                 add_action( 'make_undelete_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    781                 $count++;
    782                 $result = update_blog_status( $blog_id, 'deleted', 0 );
    783                 $this->assertEquals( 0, $result );
    784                 $blog = get_blog_details( $blog_id );
    785                 $this->assertEquals( '0', $blog->deleted );
    786                 $this->assertEquals( $count, $test_action_counter );
    787 
    788                 // Same again
    789                 $count++;
    790                 $result = update_blog_status( $blog_id, 'deleted', 0 );
    791                 $this->assertEquals( 0, $result );
    792                 $blog = get_blog_details( $blog_id );
    793                 $this->assertEquals( '0', $blog->deleted );
    794                 $this->assertEquals( $count, $test_action_counter );
    795                 remove_action( 'make_undelete_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    796 
    797                 add_action( 'mature_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    798                 $count++;
    799                 $result = update_blog_status( $blog_id, 'mature', 1 );
    800                 $this->assertEquals( 1, $result );
    801                 $blog = get_blog_details( $blog_id );
    802                 $this->assertEquals( '1', $blog->mature );
    803                 $this->assertEquals( $count, $test_action_counter );
    804 
    805                 // Same again
    806                 $count++;
    807                 $result = update_blog_status( $blog_id, 'mature', 1 );
    808                 $this->assertEquals( 1, $result );
    809                 $blog = get_blog_details( $blog_id );
    810                 $this->assertEquals( '1', $blog->mature );
    811                 $this->assertEquals( $count, $test_action_counter );
    812                 remove_action( 'mature_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    813 
    814                 add_action( 'unmature_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    815                 $count++;
    816                 $result = update_blog_status( $blog_id, 'mature', 0 );
    817                 $this->assertEquals( 0, $result );
    818                 $blog = get_blog_details( $blog_id );
    819                 $this->assertEquals( '0', $blog->mature );
    820                 $this->assertEquals( $count, $test_action_counter );
    821 
    822                 // Same again
    823                 $count++;
    824                 $result = update_blog_status( $blog_id, 'mature', 0 );
    825                 $this->assertEquals( 0, $result );
    826                 $blog = get_blog_details( $blog_id );
    827                 $this->assertEquals( '0', $blog->mature );
    828                 $this->assertEquals( $count, $test_action_counter );
    829                 remove_action( 'unmature_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    830 
    831                 add_action( 'update_blog_public', array( $this, '_action_counter_cb' ), 10, 1 );
    832                 $count++;
    833                 $result = update_blog_status( $blog_id, 'public', 0 );
    834                 $this->assertEquals( 0, $result );
    835                 $blog = get_blog_details( $blog_id );
    836                 $this->assertEquals( '0', $blog->public );
    837                 $this->assertEquals( $count, $test_action_counter );
    838 
    839                 // Same again
    840                 $count++;
    841                 $result = update_blog_status( $blog_id, 'public', 0 );
    842                 $this->assertEquals( 0, $result );
    843                 $blog = get_blog_details( $blog_id );
    844                 $this->assertEquals( '0', $blog->public );
    845                 $this->assertEquals( $count, $test_action_counter );
    846                 remove_action( 'update_blog_public', array( $this, '_action_counter_cb' ), 10, 1 );
    847 
    848                 add_action( 'update_blog_public', array( $this, '_action_counter_cb' ), 10, 1 );
    849                 $count++;
    850                 $result = update_blog_status( $blog_id, 'public', 1 );
    851                 $this->assertEquals( 1, $result );
    852                 $blog = get_blog_details( $blog_id );
    853                 $this->assertEquals( '1', $blog->public );
    854                 $this->assertEquals( $count, $test_action_counter );
    855 
    856                 // Same again
    857                 $count++;
    858                 $result = update_blog_status( $blog_id, 'public', 1 );
    859                 $this->assertEquals( 1, $result );
    860                 $blog = get_blog_details( $blog_id );
    861                 $this->assertEquals( '1', $blog->public );
    862                 $this->assertEquals( $count, $test_action_counter );
    863                 remove_action( 'update_blog_public', array( $this, '_action_counter_cb' ), 10, 1 );
    864 
    865                 // Updating a dummy field returns the value passed. Go fig.
    866                 $result = update_blog_status( $blog_id, 'doesnotexist', 1 );
    867                 $this->assertEquals( 1, $result );
    868         }
    869 
    870         function test_switch_restore_blog() {
    871                 global $_wp_switched_stack, $wpdb;
    872 
    873                 $this->assertEquals( array(), $_wp_switched_stack );
    874                 $this->assertFalse( ms_is_switched() );
    875                 $current_blog_id = get_current_blog_id();
    876                 $this->assertInternalType( 'integer', $current_blog_id );
    877 
    878                 wp_cache_set( 'switch-test', $current_blog_id, 'switch-test' );
    879                 $this->assertEquals( $current_blog_id, wp_cache_get( 'switch-test', 'switch-test' ) );
    880 
    881                 $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    882                 $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id, 'path' => '/test_blogpath', 'title' => 'Test Title' ) );
    883 
    884                 $cap_key = wp_get_current_user()->cap_key;
    885                 switch_to_blog( $blog_id );
    886                 $this->assertNotEquals( $cap_key, wp_get_current_user()->cap_key );
    887                 $this->assertEquals( array( $current_blog_id ), $_wp_switched_stack );
    888                 $this->assertTrue( ms_is_switched() );
    889                 $this->assertEquals( $blog_id, $wpdb->blogid );
    890                 $this->assertFalse( wp_cache_get( 'switch-test', 'switch-test' ) );
    891                 wp_cache_set( 'switch-test', $blog_id, 'switch-test' );
    892                 $this->assertEquals( $blog_id, wp_cache_get( 'switch-test', 'switch-test' ) );
    893 
    894                 switch_to_blog( $blog_id );
    895                 $this->assertEquals( array( $current_blog_id, $blog_id ), $_wp_switched_stack );
    896                 $this->assertTrue( ms_is_switched() );
    897                 $this->assertEquals( $blog_id, $wpdb->blogid );
    898                 $this->assertEquals( $blog_id, wp_cache_get( 'switch-test', 'switch-test' ) );
    899 
    900                 restore_current_blog();
    901                 $this->assertEquals( array( $current_blog_id ), $_wp_switched_stack );
    902                 $this->assertTrue( ms_is_switched() );
    903                 $this->assertEquals( $blog_id, $wpdb->blogid );
    904                 $this->assertEquals( $blog_id, wp_cache_get( 'switch-test', 'switch-test' ) );
    905 
    906                 restore_current_blog();
    907                 $this->assertEquals( $cap_key, wp_get_current_user()->cap_key );
    908                 $this->assertEquals( $current_blog_id, get_current_blog_id() );
    909                 $this->assertEquals( array(), $_wp_switched_stack );
    910                 $this->assertFalse( ms_is_switched() );
    911                 $this->assertEquals( $current_blog_id, wp_cache_get( 'switch-test', 'switch-test' ) );
    912 
    913                 $this->assertFalse( restore_current_blog() );
    914         }
    915 
    916         function test_get_blog_post() {
    917                 $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    918                 $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id, 'path' => '/test_blogpath', 'title' => 'Test Title' ) );
    919                 $current_blog_id = get_current_blog_id();
    920 
    921                 $post_id = $this->factory->post->create();
    922                 $this->assertInstanceOf( 'WP_Post', get_post( $post_id ) );
    923                 switch_to_blog( $blog_id );
    924                 $this->assertNull( get_post( $post_id ) );
    925                 $post = get_blog_post( $current_blog_id, $post_id );
    926                 $this->assertInstanceOf( 'WP_Post', $post );
    927                 $this->assertEquals( $post_id, $post->ID );
    928                 restore_current_blog();
    929 
    930                 wp_update_post( array( 'ID' => $post_id, 'post_title' => 'A Different Title' ) );
    931                 switch_to_blog( $blog_id );
    932                 $post = get_blog_post( $current_blog_id, $post_id );
    933                 // Make sure cache is good
    934                 $this->assertEquals( 'A Different Title', $post->post_title );
    935 
    936                 $post_id2 = $this->factory->post->create();
    937                 // Test get_blog_post() with currently active blog ID.
    938                 $post = get_blog_post( $blog_id, $post_id2 );
    939                 $this->assertInstanceOf( 'WP_Post', $post );
    940                 $this->assertEquals( $post_id2, $post->ID );
    941                 restore_current_blog();
    942         }
    943 
    944         /**
    945          * @ticket 21570
    946          */
    947         function test_aggressiveness_of_is_email_address_unsafe() {
    948                 update_site_option( 'banned_email_domains', array( 'bar.com', 'foo.co' ) );
    949 
    950                 foreach ( array( 'test@bar.com', 'test@foo.bar.com', 'test@foo.co', 'test@subdomain.foo.co' ) as $email_address ) {
    951                         $this->assertTrue( is_email_address_unsafe( $email_address ), "$email_address should be UNSAFE" );
    952                 }
    953 
    954                 foreach ( array( 'test@foobar.com', 'test@foo-bar.com', 'test@foo.com', 'test@subdomain.foo.com' ) as $email_address ) {
    955                         $this->assertFalse( is_email_address_unsafe( $email_address ), "$email_address should be SAFE" );
    956                 }
    957         }
    958 
    959         /**
    960          * @ticket 25046
    961          */
    962         function test_case_sensitivity_of_is_email_address_unsafe() {
    963                 update_site_option( 'banned_email_domains', array( 'baR.com', 'Foo.co', 'barfoo.COM', 'BAZ.com' ) );
    964 
    965                 foreach ( array( 'test@Bar.com', 'tEst@bar.com', 'test@barFoo.com', 'tEst@foo.bar.com', 'test@baz.Com' ) as $email_address ) {
    966                         $this->assertTrue( is_email_address_unsafe( $email_address ), "$email_address should be UNSAFE" );
    967                 }
    968 
    969                 foreach ( array( 'test@Foobar.com', 'test@Foo-bar.com', 'tEst@foobar.com', 'test@Subdomain.Foo.com', 'test@fooBAz.com' ) as $email_address ) {
    970                         $this->assertFalse( is_email_address_unsafe( $email_address ), "$email_address should be SAFE" );
    971                 }
    972 
    973         }
    974         /**
    975          * @ticket 21552
    976          * @ticket 23418
    977          */
    978         function test_sanitize_ms_options() {
    979                 update_site_option( 'illegal_names', array( '', 'Woo', '' ) );
    980                 update_site_option( 'limited_email_domains', array(  'woo', '', 'boo.com', 'foo.net.biz..'  ) );
    981                 update_site_option( 'banned_email_domains', array(  'woo', '', 'boo.com', 'foo.net.biz..'  ) );
    982 
    983                 $this->assertEquals( array( 'Woo' ), get_site_option( 'illegal_names' ) );
    984                 $this->assertEquals( array( 'woo', 'boo.com' ), get_site_option( 'limited_email_domains' ) );
    985                 $this->assertEquals( array( 'woo', 'boo.com' ), get_site_option( 'banned_email_domains' ) );
    986 
    987                 update_site_option( 'illegal_names', 'foo bar' );
    988                 update_site_option( 'limited_email_domains', "foo\nbar" );
    989                 update_site_option( 'banned_email_domains', "foo\nbar" );
    990 
    991                 $this->assertEquals( array( 'foo', 'bar' ), get_site_option( 'illegal_names' ) );
    992                 $this->assertEquals( array( 'foo', 'bar' ), get_site_option( 'limited_email_domains' ) );
    993                 $this->assertEquals( array( 'foo', 'bar' ), get_site_option( 'banned_email_domains' ) );
    994 
    995                 foreach ( array( 'illegal_names', 'limited_email_domains', 'banned_email_domains' ) as $option ) {
    996                         update_site_option( $option, array() );
    997                         $this->assertSame( '', get_site_option( $option ) );
    998                 }
    999         }
    1000 
    1001         function _domain_exists_cb( $exists, $domain, $path, $site_id ) {
    1002                 if ( 'foo' == $domain && 'bar/' == $path )
    1003                         return 1234;
    1004                 else
    1005                         return null;
    1006         }
    1007 
    1008         function test_domain_exists() {
    1009                 $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    1010                 $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id, 'path' => '/testdomainexists', 'title' => 'Test Title' ) );
    1011 
    1012                 $details = get_blog_details( $blog_id, false );
    1013 
    1014                 $this->assertEquals( $blog_id, domain_exists( $details->domain, $details->path ) );
    1015                 $this->assertEquals( $blog_id, domain_exists( $details->domain, $details->path, $details->site_id ) );
    1016                 $this->assertEquals( null, domain_exists( $details->domain, $details->path, 999 ) );
    1017                 $this->assertEquals( null, domain_exists( 'foo', 'bar' ) );
    1018 
    1019                 add_filter( 'domain_exists', array( $this, '_domain_exists_cb' ), 10, 4 );
    1020                 $this->assertEquals( 1234, domain_exists( 'foo', 'bar' ) );
    1021                 $this->assertEquals( null, domain_exists( 'foo', 'baz' ) );
    1022                 $this->assertEquals( null, domain_exists( 'bar', 'foo' ) );
    1023 
    1024                 // Make sure the same result is returned with or without a trailing slash
    1025                 $this->assertEquals( domain_exists( 'foo', 'bar' ), domain_exists( 'foo', 'bar/' ) );
    1026 
    1027                 remove_filter( 'domain_exists', array( $this, '_domain_exists_cb' ), 10, 4 );
    1028                 $this->assertEquals( null, domain_exists( 'foo', 'bar' ) );
    1029 
    1030                 wpmu_delete_blog( $blog_id );
    1031                 $this->assertEquals( $blog_id, domain_exists( $details->domain, $details->path ) );
    1032                 wpmu_delete_blog( $blog_id, true );
    1033                 $this->assertEquals( null, domain_exists( $details->domain, $details->path ) );
    1034         }
    1035 
    1036         function test_get_blog_id_from_url() {
    1037                 $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    1038                 $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id, 'path' => '/testdomainexists', 'title' => 'Test Title' ) );
    1039 
    1040                 $details = get_blog_details( $blog_id, false );
    1041 
    1042                 $this->assertEquals( $blog_id, get_blog_id_from_url( $details->domain, $details->path ) );
    1043                 $key = md5( $details->domain . $details->path );
    1044                 $this->assertEquals( $blog_id, wp_cache_get( $key, 'blog-id-cache' ) );
    1045 
    1046                 $this->assertEquals( 0, get_blog_id_from_url( $details->domain, 'foo' ) );
    1047 
    1048                 wpmu_delete_blog( $blog_id );
    1049                 $this->assertEquals( $blog_id, get_blog_id_from_url( $details->domain, $details->path ) );
    1050                 wpmu_delete_blog( $blog_id, true );
    1051 
    1052                 $this->assertEquals( false, wp_cache_get( $key, 'blog-id-cache' ) );
    1053                 $this->assertEquals( 0, get_blog_id_from_url( $details->domain, $details->path ) );
    1054         }
    1055 
    1056         function test_is_main_site() {
    1057                 $this->assertTrue( is_main_site() );
    1058                 $this->assertTrue( is_main_site( get_current_blog_id() ) );
    1059 
    1060                 $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    1061                 $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id ) );
    1062 
    1063                 switch_to_blog( $blog_id  );
    1064                 $this->assertFalse( is_main_site( $blog_id ) );
    1065                 $this->assertFalse( is_main_site( get_current_blog_id() ) );
    1066                 $this->assertFalse( is_main_site() );
    1067 
    1068                 restore_current_blog();
    1069         }
    1070 
    1071         function test_switch_upload_dir() {
    1072                 $this->assertTrue( is_main_site() );
    1073 
    1074                 $site = get_current_site();
    1075 
    1076                 $info = wp_upload_dir();
    1077                 $this->assertEquals( 'http://' . $site->domain . '/wp-content/uploads/' . gmstrftime('%Y/%m'), $info['url'] );
    1078                 $this->assertEquals( ABSPATH . 'wp-content/uploads/' . gmstrftime('%Y/%m'), $info['path'] );
    1079                 $this->assertEquals( gmstrftime('/%Y/%m'), $info['subdir'] );
    1080                 $this->assertEquals( '', $info['error'] );
    1081 
    1082                 $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    1083                 $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id ) );
    1084 
    1085                 switch_to_blog( $blog_id );
    1086                 $info = wp_upload_dir();
    1087                 $this->assertEquals( 'http://' . $site->domain . '/wp-content/uploads/sites/' . get_current_blog_id() . '/' . gmstrftime('%Y/%m'), $info['url'] );
    1088                 $this->assertEquals( ABSPATH . 'wp-content/uploads/sites/' . get_current_blog_id() . '/' . gmstrftime('%Y/%m'), $info['path'] );
    1089                 $this->assertEquals( gmstrftime('/%Y/%m'), $info['subdir'] );
    1090                 $this->assertEquals( '', $info['error'] );
    1091                 restore_current_blog();
    1092 
    1093                 $info = wp_upload_dir();
    1094                 $this->assertEquals( 'http://' . $site->domain . '/wp-content/uploads/' . gmstrftime('%Y/%m'), $info['url'] );
    1095                 $this->assertEquals( ABSPATH . 'wp-content/uploads/' . gmstrftime('%Y/%m'), $info['path'] );
    1096                 $this->assertEquals( gmstrftime('/%Y/%m'), $info['subdir'] );
    1097                 $this->assertEquals( '', $info['error'] );
    1098 
    1099                 update_site_option( 'ms_files_rewriting', 1 );
    1100                 ms_upload_constants();
    1101 
    1102                 $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    1103                 $blog_id2 = $this->factory->blog->create( array( 'user_id' => $user_id ) );
    1104                 $info = wp_upload_dir();
    1105                 $this->assertEquals( 'http://' . $site->domain . '/wp-content/uploads/' . gmstrftime('%Y/%m'), $info['url'] );
    1106                 $this->assertEquals( ABSPATH . 'wp-content/uploads/' . gmstrftime('%Y/%m'), $info['path'] );
    1107                 $this->assertEquals( gmstrftime('/%Y/%m'), $info['subdir'] );
    1108                 $this->assertEquals( '', $info['error'] );
    1109 
    1110                 switch_to_blog( $blog_id2 );
    1111                 $info2 = wp_upload_dir();
    1112                 $this->assertNotEquals( $info, $info2 );
    1113                 $this->assertEquals( get_option( 'siteurl' )  . '/wp-content/blogs.dir/' . get_current_blog_id() . '/files/' . gmstrftime('%Y/%m'), $info2['url'] );
    1114                 $this->assertEquals( ABSPATH . 'wp-content/blogs.dir/' . get_current_blog_id() . '/files/' . gmstrftime('%Y/%m'), $info2['path'] );
    1115                 $this->assertEquals( gmstrftime('/%Y/%m'), $info2['subdir'] );
    1116                 $this->assertEquals( '', $info2['error'] );
    1117                 restore_current_blog();
    1118                 update_site_option( 'ms_files_rewriting', 0 );
    1119         }
    1120 
    1121         /**
    1122          * @ticket 23192
    1123          */
    1124         function test_is_user_spammy() {
    1125                 $user_id = $this->factory->user->create( array(
    1126                         'role' => 'author',
    1127                         'user_login' => 'testuser1',
    1128                 ) );
    1129 
    1130                 $spam_username = (string) $user_id;
    1131                 $spam_user_id = $this->factory->user->create( array(
    1132                         'role' => 'author',
    1133                         'user_login' => $spam_username,
    1134                 ) );
    1135                 update_user_status( $spam_user_id, 'spam', '1' );
    1136 
    1137                 $this->assertTrue( is_user_spammy( $spam_username ) );
    1138                 $this->assertFalse( is_user_spammy( 'testuser1' ) );
    1139         }
    1140 
    1141         /**
    1142          * @ticket 14511
    1143          */
    1144         function test_wp_get_sites() {
    1145                 $this->factory->blog->create_many( 2, array( 'site_id' => 2, 'meta' => array( 'public' => 1 ) ) );
    1146                 $this->factory->blog->create_many( 3, array( 'site_id' => 3, 'meta' => array( 'public' => 0 ) ) );
    1147 
    1148                 // Expect no sites when passed an invalid network_id
    1149                 $this->assertCount( 0, wp_get_sites( array( 'network_id' => 0 ) ) );
    1150                 $this->assertCount( 0, wp_get_sites( array( 'network_id' => 4 ) ) );
    1151 
    1152                 // Expect 1 site when no network_id is specified - defaults to current network.
    1153                 $this->assertCount( 1, wp_get_sites() );
    1154                 // Expect 6 sites when network_id = null.
    1155                 $this->assertCount( 6, wp_get_sites( array( 'network_id' => null ) ) );
    1156 
    1157                 // Expect 1 site with a network_id of 1, 2 for network_id 2, 3 for 3
    1158                 $this->assertCount( 1, wp_get_sites( array( 'network_id' => 1 ) ) );
    1159                 $this->assertCount( 2, wp_get_sites( array( 'network_id' => 2 ) ) );
    1160                 $this->assertCount( 3, wp_get_sites( array( 'network_id' => 3 ) ) );
    1161 
    1162                 // Expect 6 sites when public is null (across all networks)
    1163                 $this->assertCount( 6, wp_get_sites( array( 'public' => null, 'network_id' => null ) ) );
    1164 
    1165                 // Expect 3 sites when public is 1
    1166                 $this->assertCount( 3, wp_get_sites( array( 'public' => 1, 'network_id' => null ) ) );
    1167 
    1168                 // Expect 2 sites when public is 1 and network_id is 2
    1169                 $this->assertCount( 2, wp_get_sites( array( 'network_id' => 2, 'public' => 1 ) ) );
    1170 
    1171                 // Expect no sites when public is set to 0 and network_id is not 3
    1172                 $this->assertCount( 0, wp_get_sites( array( 'network_id' => 1, 'public' => 0 ) ) );
    1173 
    1174                 // Test public + network_id = 3
    1175                 $this->assertCount( 0, wp_get_sites( array( 'network_id' => 3, 'public' => 1 ) ) );
    1176                 $this->assertCount( 3, wp_get_sites( array( 'network_id' => 3, 'public' => 0 ) ) );
    1177         }
    1178 
    1179         /**
    1180          * @ticket 14511
    1181          */
    1182         function test_wp_get_sites_limit_offset() {
    1183                 // Create 4 more sites (in addition to the default one)
    1184                 $this->factory->blog->create_many( 4, array( 'meta' => array( 'public' => 1 ) ) );
    1185 
    1186                 // Expect all 5 sites when no limit/offset is specified
    1187                 $this->assertCount( 5, wp_get_sites() );
    1188 
    1189                 // Expect first 2 sites when using limit
    1190                 $this->assertCount( 2, wp_get_sites( array( 'limit' => 2 ) ) );
    1191 
    1192                 // Expect only the last 3 sites when using offset of 2 (limit will default to 100)
    1193                 $this->assertCount( 3, wp_get_sites( array( 'offset' => 2 ) ) );
    1194 
    1195                 // Expect only the last 1 site when using offset of 4 and limit of 2
    1196                 $this->assertCount( 1, wp_get_sites( array( 'limit' => 2, 'offset' => 4 ) ) );
    1197 
    1198                 // Expect 0 sites when using an offset larger than the number of sites
    1199                 $this->assertCount( 0, wp_get_sites( array( 'offset' => 20 ) ) );
    1200         }
    1201 
    1202         /**
    1203          * @ticket 27003
    1204          */
    1205         function test_get_network_by_path() {
    1206                 global $wpdb;
    1207 
    1208                 $ids = array(
    1209                         'wordpress.org/'         => array( 'domain' => 'wordpress.org', 'path' => '/' ),
    1210                         'wordpress.org/one/'     => array( 'domain' => 'wordpress.org', 'path' => '/one/' ),
    1211                         'wordpress.net/'         => array( 'domain' => 'wordpress.net', 'path' => '/' ),
    1212                         'www.wordpress.net/'     => array( 'domain' => 'www.wordpress.net', 'path' => '/' ),
    1213                         'www.wordpress.net/two/' => array( 'domain' => 'www.wordpress.net', 'path' => '/two/' ),
    1214                         'wordpress.net/three/'   => array( 'domain' => 'wordpress.net', 'path' => '/three/' ),
    1215                 );
    1216 
    1217                 foreach ( $ids as &$id ) {
    1218                         $id = $this->factory->network->create( $id );
    1219                 }
    1220                 unset( $id );
    1221 
    1222                 $this->assertEquals( $ids['www.wordpress.net/'],
    1223                         get_network_by_path( 'www.wordpress.net', '/notapath/' )->id );
    1224 
    1225                 $this->assertEquals( $ids['www.wordpress.net/two/'],
    1226                         get_network_by_path( 'www.wordpress.net', '/two/' )->id );
    1227 
    1228                 // This should find /one/ despite the www.
    1229                 $this->assertEquals( $ids['wordpress.org/one/'],
    1230                         get_network_by_path( 'www.wordpress.org', '/one/' )->id );
    1231 
    1232                 // This should not find /one/ because the domains don't match.
    1233                 $this->assertEquals( $ids['wordpress.org/'],
    1234                         get_network_by_path( 'site1.wordpress.org', '/one/' )->id );
    1235 
    1236                 $this->assertEquals( $ids['wordpress.net/three/'],
    1237                         get_network_by_path( 'wordpress.net', '/three/' )->id );
    1238 
    1239                 $this->assertEquals( $ids['wordpress.net/'],
    1240                         get_network_by_path( 'wordpress.net', '/notapath/' )->id );
    1241 
    1242                 $this->assertEquals( $ids['wordpress.net/'],
    1243                         get_network_by_path( 'site1.wordpress.net', '/notapath/' )->id );
    1244 
    1245                 $this->assertEquals( $ids['wordpress.net/'],
    1246                         get_network_by_path( 'site1.wordpress.net', '/three/' )->id );
    1247         }
    1248 
    1249         /**
    1250          * @ticket 27003
    1251          * @ticket 27927
    1252          */
    1253         function test_get_site_by_path() {
    1254                 $ids = array(
    1255                         'wordpress.org/'              => array( 'domain' => 'wordpress.org',      'path' => '/' ),
    1256                         'wordpress.org/foo/'          => array( 'domain' => 'wordpress.org',      'path' => '/foo/' ),
    1257                         'wordpress.org/foo/bar/'      => array( 'domain' => 'wordpress.org',      'path' => '/foo/bar/' ),
    1258                         'make.wordpress.org/'         => array( 'domain' => 'make.wordpress.org', 'path' => '/' ),
    1259                         'make.wordpress.org/foo/'     => array( 'domain' => 'make.wordpress.org', 'path' => '/foo/' ),
    1260                         'www.w.org/'                  => array( 'domain' => 'www.w.org',          'path' => '/' ),
    1261                         'www.w.org/foo/'              => array( 'domain' => 'www.w.org',          'path' => '/foo/' ),
    1262                         'www.w.org/foo/bar/'          => array( 'domain' => 'www.w.org',          'path' => '/foo/bar/' ),
    1263                 );
    1264 
    1265                 foreach ( $ids as &$id ) {
    1266                         $id = $this->factory->blog->create( $id );
    1267                 }
    1268                 unset( $id );
    1269 
    1270                 $this->assertEquals( $ids['wordpress.org/'],
    1271                         get_site_by_path( 'wordpress.org', '/notapath/' )->blog_id );
    1272 
    1273                 $this->assertEquals( $ids['wordpress.org/'],
    1274                         get_site_by_path( 'www.wordpress.org', '/notapath/' )->blog_id );
    1275 
    1276                 $this->assertEquals( $ids['wordpress.org/foo/bar/'],
    1277                         get_site_by_path( 'wordpress.org', '/foo/bar/baz/' )->blog_id );
    1278 
    1279                 $this->assertEquals( $ids['wordpress.org/foo/bar/'],
    1280                         get_site_by_path( 'www.wordpress.org', '/foo/bar/baz/' )->blog_id );
    1281 
    1282                 $this->assertEquals( $ids['wordpress.org/foo/bar/'],
    1283                         get_site_by_path( 'wordpress.org', '/foo/bar/baz/', 3 )->blog_id );
    1284 
    1285                 $this->assertEquals( $ids['wordpress.org/foo/bar/'],
    1286                         get_site_by_path( 'www.wordpress.org', '/foo/bar/baz/', 3 )->blog_id );
    1287 
    1288                 $this->assertEquals( $ids['wordpress.org/foo/bar/'],
    1289                         get_site_by_path( 'wordpress.org', '/foo/bar/baz/', 2 )->blog_id );
    1290 
    1291                 $this->assertEquals( $ids['wordpress.org/foo/bar/'],
    1292                         get_site_by_path( 'www.wordpress.org', '/foo/bar/baz/', 2 )->blog_id );
    1293 
    1294                 $this->assertEquals( $ids['wordpress.org/foo/'],
    1295                         get_site_by_path( 'wordpress.org', '/foo/bar/baz/', 1 )->blog_id );
    1296 
    1297                 $this->assertEquals( $ids['wordpress.org/foo/'],
    1298                         get_site_by_path( 'www.wordpress.org', '/foo/bar/baz/', 1 )->blog_id );
    1299 
    1300                 $this->assertEquals( $ids['wordpress.org/'],
    1301                         get_site_by_path( 'wordpress.org', '/', 0 )->blog_id );
    1302 
    1303                 $this->assertEquals( $ids['wordpress.org/'],
    1304                         get_site_by_path( 'www.wordpress.org', '/', 0 )->blog_id );
    1305 
    1306                 $this->assertEquals( $ids['make.wordpress.org/foo/'],
    1307                         get_site_by_path( 'make.wordpress.org', '/foo/bar/baz/qux/', 4 )->blog_id );
    1308 
    1309                 $this->assertEquals( $ids['make.wordpress.org/foo/'],
    1310                         get_site_by_path( 'www.make.wordpress.org', '/foo/bar/baz/qux/', 4 )->blog_id );
    1311 
    1312                 $this->assertEquals( $ids['www.w.org/'],
    1313                         get_site_by_path( 'www.w.org', '/', 0 )->blog_id );
    1314 
    1315                 $this->assertEquals( $ids['www.w.org/'],
    1316                         get_site_by_path( 'www.w.org', '/notapath/' )->blog_id );
    1317 
    1318                 $this->assertEquals( $ids['www.w.org/foo/bar/'],
    1319                         get_site_by_path( 'www.w.org', '/foo/bar/baz/' )->blog_id );
    1320 
    1321                 $this->assertEquals( $ids['www.w.org/foo/'],
    1322                         get_site_by_path( 'www.w.org', '/foo/bar/baz/', 1 )->blog_id );
    1323 
    1324                 // A site installed with www will not be found by the root domain.
    1325                 $this->assertFalse( get_site_by_path( 'w.org', '/' ) );
    1326                 $this->assertFalse( get_site_by_path( 'w.org', '/notapath/' ) );
    1327                 $this->assertFalse( get_site_by_path( 'w.org', '/foo/bar/baz/' ) );
    1328                 $this->assertFalse( get_site_by_path( 'w.org', '/foo/bar/baz/', 1 ) );
    1329 
    1330                 // A site will not be found by its root domain when an invalid subdomain is requested.
    1331                 $this->assertFalse( get_site_by_path( 'invalid.wordpress.org', '/' ) );
    1332                 $this->assertFalse( get_site_by_path( 'invalid.wordpress.org', '/foo/bar/' ) );
    1333         }
    1334 
    1335         /**
    1336          * @ticket 20601
    1337          */
    1338         function test_user_member_of_blog() {
    1339                 global $wp_rewrite;
    1340 
    1341                 $this->factory->blog->create();
    1342                 $user_id = $this->factory->user->create();
    1343                 $this->factory->blog->create( array( 'user_id' => $user_id ) );
    1344 
    1345                 $blogs = get_blogs_of_user( $user_id );
    1346                 $this->assertCount( 2, $blogs );
    1347                 $first = reset( $blogs )->userblog_id;
    1348                 remove_user_from_blog( $user_id, $first );
    1349 
    1350                 $blogs = get_blogs_of_user( $user_id );
    1351                 $second = reset( $blogs )->userblog_id;
    1352                 $this->assertCount( 1, $blogs );
    1353 
    1354                 switch_to_blog( $first );
    1355                 $wp_rewrite->init();
    1356 
    1357                 $this->go_to( get_author_posts_url( $user_id ) );
    1358                 $this->assertQueryTrue( 'is_404' );
    1359 
    1360                 switch_to_blog( $second );
    1361                 $wp_rewrite->init();
    1362 
    1363                 $this->go_to( get_author_posts_url( $user_id ) );
    1364                 $this->assertQueryTrue( 'is_author', 'is_archive' );
    1365 
    1366                 add_user_to_blog( $first, $user_id, 'administrator' );
    1367                 $blogs = get_blogs_of_user( $user_id );
    1368                 $this->assertCount( 2, $blogs );
    1369 
    1370                 switch_to_blog( $first );
    1371                 $wp_rewrite->init();
    1372 
    1373                 $this->go_to( get_author_posts_url( $user_id ) );
    1374                 $this->assertQueryTrue( 'is_author', 'is_archive' );
    1375         }
    1376 
    1377         /**
    1378          * @ticket 27205
    1379          */
    1380         function test_granting_super_admins() {
    1381                 if ( isset( $GLOBALS['super_admins'] ) ) {
    1382                         $old_global = $GLOBALS['super_admins'];
    1383                         unset( $GLOBALS['super_admins'] );
    1384                 }
    1385 
    1386                 $user_id = $this->factory->user->create();
    1387 
    1388                 $this->assertFalse( is_super_admin( $user_id ) );
    1389                 $this->assertFalse( revoke_super_admin( $user_id ) );
    1390                 $this->assertTrue( grant_super_admin( $user_id ) );
    1391                 $this->assertTrue( is_super_admin( $user_id ) );
    1392                 $this->assertFalse( grant_super_admin( $user_id ) );
    1393                 $this->assertTrue( revoke_super_admin( $user_id ) );
    1394 
    1395                 // None of these operations should set the $super_admins global.
    1396                 $this->assertFalse( isset( $GLOBALS['super_admins'] ) );
    1397 
    1398                 // Try with two users.
    1399                 $second_user = $this->factory->user->create();
    1400                 $this->assertTrue( grant_super_admin( $user_id ) );
    1401                 $this->assertTrue( grant_super_admin( $second_user ) );
    1402                 $this->assertTrue( is_super_admin( $second_user ) );
    1403                 $this->assertTrue( is_super_admin( $user_id ) );
    1404                 $this->assertTrue( revoke_super_admin( $user_id ) );
    1405                 $this->assertTrue( revoke_super_admin( $second_user ) );
    1406 
    1407                 if ( isset( $old_global ) ) {
    1408                         $GLOBALS['super_admins'] = $old_global;
    1409                 }
    1410         }
    1411 
    1412         /**
    1413          * @ticket 27952
    1414          */
    1415         function test_posts_count() {
    1416                 $this->factory->post->create();
    1417                 $post2 = $this->factory->post->create();
    1418                 $this->assertEquals( 2, get_blog_details()->post_count );
    1419 
    1420                 wp_delete_post( $post2 );
    1421                 $this->assertEquals( 1, get_blog_details()->post_count );
    1422         }
    1423 
    1424         /**
    1425          * @ticket 26410
    1426          */
    1427         function test_blog_details_cache_invalidation() {
    1428                 update_option( 'blogname', 'foo' );
    1429                 $details = get_blog_details( get_current_blog_id() );
    1430                 $this->assertEquals( 'foo', $details->blogname );
    1431 
    1432                 update_option( 'blogname', 'bar' );
    1433                 $details = get_blog_details( get_current_blog_id() );
    1434                 $this->assertEquals( 'bar', $details->blogname );
    1435         }
    1436 
    1437         /**
    1438          * @ticket 29845
    1439          */
    1440         function test_get_blog_details() {
    1441                 $network_ids = array(
    1442                         'wordpress.org/'         => array( 'domain' => 'wordpress.org', 'path' => '/' ),
    1443                         'make.wordpress.org/'    => array( 'domain' => 'make.wordpress.org', 'path' => '/' ),
    1444                 );
    1445 
    1446                 foreach ( $network_ids as &$id ) {
    1447                         $id = $this->factory->network->create( $id );
    1448                 }
    1449                 unset( $id );
    1450 
    1451                 $ids = array(
    1452                         'wordpress.org/'              => array( 'domain' => 'wordpress.org',      'path' => '/',         'title' => 'Test 1', 'site_id' => $network_ids['wordpress.org/'] ),
    1453                         'wordpress.org/foo/'          => array( 'domain' => 'wordpress.org',      'path' => '/foo/',     'title' => 'Test 2', 'site_id' => $network_ids['wordpress.org/'] ),
    1454                         'wordpress.org/foo/bar/'      => array( 'domain' => 'wordpress.org',      'path' => '/foo/bar/', 'title' => 'Test 3', 'site_id' => $network_ids['wordpress.org/'] ),
    1455                         'make.wordpress.org/'         => array( 'domain' => 'make.wordpress.org', 'path' => '/',         'title' => 'Test 4', 'site_id' => $network_ids['make.wordpress.org/'] ),
    1456                         'make.wordpress.org/foo/'     => array( 'domain' => 'make.wordpress.org', 'path' => '/foo/',     'title' => 'Test 5', 'site_id' => $network_ids['make.wordpress.org/'] ),
    1457                 );
    1458 
    1459                 foreach ( $ids as &$id ) {
    1460                         $id = $this->factory->blog->create( $id );
    1461                 }
    1462                 unset( $id );
    1463 
    1464                 // Retrieve site details by passing only a blog ID.
    1465                 $site = get_blog_details( $ids['wordpress.org/'] );
    1466                 $this->assertEquals( $ids['wordpress.org/'], $site->blog_id );
    1467                 $this->assertEquals( 'Test 1', $site->blogname );
    1468 
    1469                 $site = get_blog_details( $ids['wordpress.org/foo/'] );
    1470                 $this->assertEquals( $ids['wordpress.org/foo/'], $site->blog_id );
    1471                 $this->assertEquals( 'Test 2', $site->blogname );
    1472 
    1473                 $site = get_blog_details( 999 );
    1474                 $this->assertFalse( $site );
    1475 
    1476                 // Retrieve site details by passing an array containing blog_id.
    1477                 $site = get_blog_details( array( 'blog_id' => $ids['wordpress.org/foo/bar/'] ) );
    1478                 $this->assertEquals( $ids['wordpress.org/foo/bar/'], $site->blog_id );
    1479                 $this->assertEquals( 'Test 3', $site->blogname );
    1480 
    1481                 $site = get_blog_details( array( 'blog_id' => $ids['make.wordpress.org/'] ) );
    1482                 $this->assertEquals( $ids['make.wordpress.org/'], $site->blog_id );
    1483                 $this->assertEquals( 'Test 4', $site->blogname );
    1484 
    1485                 $site = get_blog_details( array( 'blog_id' => 999 ) );
    1486                 $this->assertFalse( $site );
    1487 
    1488                 // Retrieve site details by passing an array containing domain and path.
    1489                 $site = get_blog_details( array( 'domain' => 'wordpress.org', 'path' => '/' ) );
    1490                 $this->assertEquals( $ids['wordpress.org/'], $site->blog_id );
    1491                 $this->assertEquals( 'Test 1', $site->blogname );
    1492 
    1493                 $site = get_blog_details( array( 'domain' => 'wordpress.org', 'path' => '/foo/' ) );
    1494                 $this->assertEquals( $ids['wordpress.org/foo/'], $site->blog_id );
    1495                 $this->assertEquals( 'Test 2', $site->blogname );
    1496 
    1497                 $site = get_blog_details( array( 'domain' => 'wordpress.org', 'path' => '/foo/bar/' ) );
    1498                 $this->assertEquals( $ids['wordpress.org/foo/bar/'], $site->blog_id );
    1499                 $this->assertEquals( 'Test 3', $site->blogname );
    1500 
    1501                 $site = get_blog_details( array( 'domain' => 'make.wordpress.org', 'path' => '/' ) );
    1502                 $this->assertEquals( $ids['make.wordpress.org/'], $site->blog_id );
    1503                 $this->assertEquals( 'Test 4', $site->blogname );
    1504 
    1505                 $site = get_blog_details( array( 'domain' => 'make.wordpress.org', 'path' => '/foo/' ) );
    1506                 $this->assertEquals( $ids['make.wordpress.org/foo/'], $site->blog_id );
    1507                 $this->assertEquals( 'Test 5', $site->blogname );
    1508 
    1509                 $site = get_blog_details( array( 'domain' => 'wordpress.org', 'path' => '/zxy/' ) );
    1510                 $this->assertFalse( $site );
    1511         }
    1512 
    1513         /**
    1514          * @ticket 27884
    1515          */
    1516         function test_multisite_bootstrap() {
    1517                 global $current_blog;
    1518 
    1519                 $network_ids = array(
    1520                         'wordpress.org/'         => array( 'domain' => 'wordpress.org', 'path' => '/' ),
    1521                         'make.wordpress.org/'    => array( 'domain' => 'make.wordpress.org', 'path' => '/' ),
    1522                 );
    1523 
    1524                 foreach ( $network_ids as &$id ) {
    1525                         $id = $this->factory->network->create( $id );
    1526                 }
    1527                 unset( $id );
    1528 
    1529                 $ids = array(
    1530                         'wordpress.org/'              => array( 'domain' => 'wordpress.org',      'path' => '/',         'site_id' => $network_ids['wordpress.org/'] ),
    1531                         'wordpress.org/foo/'          => array( 'domain' => 'wordpress.org',      'path' => '/foo/',     'site_id' => $network_ids['wordpress.org/'] ),
    1532                         'wordpress.org/foo/bar/'      => array( 'domain' => 'wordpress.org',      'path' => '/foo/bar/', 'site_id' => $network_ids['wordpress.org/'] ),
    1533                         'make.wordpress.org/'         => array( 'domain' => 'make.wordpress.org', 'path' => '/',         'site_id' => $network_ids['make.wordpress.org/'] ),
    1534                         'make.wordpress.org/foo/'     => array( 'domain' => 'make.wordpress.org', 'path' => '/foo/',     'site_id' => $network_ids['make.wordpress.org/'] ),
    1535                 );
    1536 
    1537                 foreach ( $ids as &$id ) {
    1538                         $id = $this->factory->blog->create( $id );
    1539                 }
    1540                 unset( $id );
    1541 
    1542                 $this->_setup_host_request( 'wordpress.org', '/' );
    1543                 $this->assertEquals( $ids['wordpress.org/'], $current_blog->blog_id );
    1544                 $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
    1545 
    1546                 $this->_setup_host_request( 'wordpress.org', '/2014/04/23/hello-world/' );
    1547                 $this->assertEquals( $ids['wordpress.org/'], $current_blog->blog_id );
    1548                 $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
    1549 
    1550                 $this->_setup_host_request( 'wordpress.org', '/sample-page/' );
    1551                 $this->assertEquals( $ids['wordpress.org/'], $current_blog->blog_id );
    1552                 $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
    1553 
    1554                 $this->_setup_host_request( 'wordpress.org', '/?p=1' );
    1555                 $this->assertEquals( $ids['wordpress.org/'], $current_blog->blog_id );
    1556                 $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
    1557 
    1558                 $this->_setup_host_request( 'wordpress.org', '/wp-admin/' );
    1559                 $this->assertEquals( $ids['wordpress.org/'], $current_blog->blog_id );
    1560                 $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
    1561 
    1562                 $this->_setup_host_request( 'wordpress.org', '/foo/' );
    1563                 $this->assertEquals( $ids['wordpress.org/foo/'], $current_blog->blog_id );
    1564                 $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
    1565 
    1566                 $this->_setup_host_request( 'wordpress.org', '/FOO/' );
    1567                 $this->assertEquals( $ids['wordpress.org/foo/'], $current_blog->blog_id );
    1568                 $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
    1569 
    1570                 $this->_setup_host_request( 'wordpress.org', '/foo/2014/04/23/hello-world/' );
    1571                 $this->assertEquals( $ids['wordpress.org/foo/'], $current_blog->blog_id );
    1572                 $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
    1573 
    1574                 $this->_setup_host_request( 'wordpress.org', '/foo/sample-page/' );
    1575                 $this->assertEquals( $ids['wordpress.org/foo/'], $current_blog->blog_id );
    1576                 $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
    1577 
    1578                 $this->_setup_host_request( 'wordpress.org', '/foo/?p=1' );
    1579                 $this->assertEquals( $ids['wordpress.org/foo/'], $current_blog->blog_id );
    1580                 $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
    1581 
    1582                 $this->_setup_host_request( 'wordpress.org', '/foo/wp-admin/' );
    1583                 $this->assertEquals( $ids['wordpress.org/foo/'], $current_blog->blog_id );
    1584                 $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
    1585 
    1586                 // @todo not currently passing.
    1587                 //$this->_setup_host_request( 'wordpress.org', '/foo/bar/' );
    1588                 //$this->assertEquals( $ids['wordpress.org/foo/bar/'], $current_blog->blog_id );
    1589                 //$this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
    1590 
    1591                 $this->_setup_host_request( 'make.wordpress.org', '/' );
    1592                 $this->assertEquals( $ids['make.wordpress.org/'], $current_blog->blog_id );
    1593                 $this->assertEquals( $network_ids['make.wordpress.org/'], $current_blog->site_id );
    1594 
    1595                 $this->_setup_host_request( 'make.wordpress.org', '/foo/' );
    1596                 $this->assertEquals( $ids['make.wordpress.org/foo/'], $current_blog->blog_id );
    1597                 $this->assertEquals( $network_ids['make.wordpress.org/'], $current_blog->site_id );
    1598 
    1599                 // Request the original tests domain and path to unpollute the stack.
    1600                 $this->_setup_host_request( WP_TESTS_DOMAIN, '/' );
    1601         }
    1602 
    1603         /**
    1604          * Reset various globals required for a 'clean' multisite boot.
    1605          *
    1606          * The $wpdb and $table_prefix globals are required for ms-settings.php to
    1607          * load properly.
    1608          *
    1609          * @param string $domain HTTP_HOST of the bootstrap request.
    1610          * @param string $path   REQUEST_URI of the boot strap request.
    1611          */
    1612         function _setup_host_request( $domain, $path ) {
    1613                 global $current_site, $current_blog, $table_prefix, $wpdb;
    1614 
    1615                 $table_prefix = WP_TESTS_TABLE_PREFIX;
    1616                 $current_site = $current_blog = null;
    1617                 $_SERVER['HTTP_HOST'] = $domain;
    1618                 $_SERVER['REQUEST_URI'] = $path;
    1619 
    1620                 include ABSPATH . '/wp-includes/ms-settings.php';
    1621         }
    1622 }
    1623 
    1624 endif;
  • tests/phpunit/tests/multisite/bootstrap.php

     
     1<?php
     2
     3if ( is_multisite() ) :
     4
     5/**
     6 * Tests specific to the bootstrap process of Multisite.
     7 *
     8 * @group ms-bootstrap
     9 * @group multisite
     10 */
     11class Tests_Multisite_Bootstrap extends WP_UnitTestCase {
     12        protected $suppress = false;
     13
     14        function setUp() {
     15                global $wpdb;
     16                parent::setUp();
     17                $this->suppress = $wpdb->suppress_errors();
     18
     19                $_SERVER[ 'REMOTE_ADDR' ] = '';
     20        }
     21
     22        function tearDown() {
     23                global $wpdb;
     24                parent::tearDown();
     25                $wpdb->suppress_errors( $this->suppress );
     26        }
     27
     28
     29        /**
     30         * @ticket 27003
     31         */
     32        function test_get_network_by_path() {
     33                global $wpdb;
     34
     35                $ids = array(
     36                        'wordpress.org/'         => array( 'domain' => 'wordpress.org', 'path' => '/' ),
     37                        'wordpress.org/one/'     => array( 'domain' => 'wordpress.org', 'path' => '/one/' ),
     38                        'wordpress.net/'         => array( 'domain' => 'wordpress.net', 'path' => '/' ),
     39                        'www.wordpress.net/'     => array( 'domain' => 'www.wordpress.net', 'path' => '/' ),
     40                        'www.wordpress.net/two/' => array( 'domain' => 'www.wordpress.net', 'path' => '/two/' ),
     41                        'wordpress.net/three/'   => array( 'domain' => 'wordpress.net', 'path' => '/three/' ),
     42                );
     43
     44                foreach ( $ids as &$id ) {
     45                        $id = $this->factory->network->create( $id );
     46                }
     47                unset( $id );
     48
     49                $this->assertEquals( $ids['www.wordpress.net/'],
     50                        get_network_by_path( 'www.wordpress.net', '/notapath/' )->id );
     51
     52                $this->assertEquals( $ids['www.wordpress.net/two/'],
     53                        get_network_by_path( 'www.wordpress.net', '/two/' )->id );
     54
     55                // This should find /one/ despite the www.
     56                $this->assertEquals( $ids['wordpress.org/one/'],
     57                        get_network_by_path( 'www.wordpress.org', '/one/' )->id );
     58
     59                // This should not find /one/ because the domains don't match.
     60                $this->assertEquals( $ids['wordpress.org/'],
     61                        get_network_by_path( 'site1.wordpress.org', '/one/' )->id );
     62
     63                $this->assertEquals( $ids['wordpress.net/three/'],
     64                        get_network_by_path( 'wordpress.net', '/three/' )->id );
     65
     66                $this->assertEquals( $ids['wordpress.net/'],
     67                        get_network_by_path( 'wordpress.net', '/notapath/' )->id );
     68
     69                $this->assertEquals( $ids['wordpress.net/'],
     70                        get_network_by_path( 'site1.wordpress.net', '/notapath/' )->id );
     71
     72                $this->assertEquals( $ids['wordpress.net/'],
     73                        get_network_by_path( 'site1.wordpress.net', '/three/' )->id );
     74        }
     75
     76        /**
     77         * @ticket 27003
     78         * @ticket 27927
     79         */
     80        function test_get_site_by_path() {
     81                $ids = array(
     82                        'wordpress.org/'              => array( 'domain' => 'wordpress.org',      'path' => '/' ),
     83                        'wordpress.org/foo/'          => array( 'domain' => 'wordpress.org',      'path' => '/foo/' ),
     84                        'wordpress.org/foo/bar/'      => array( 'domain' => 'wordpress.org',      'path' => '/foo/bar/' ),
     85                        'make.wordpress.org/'         => array( 'domain' => 'make.wordpress.org', 'path' => '/' ),
     86                        'make.wordpress.org/foo/'     => array( 'domain' => 'make.wordpress.org', 'path' => '/foo/' ),
     87                        'www.w.org/'                  => array( 'domain' => 'www.w.org',          'path' => '/' ),
     88                        'www.w.org/foo/'              => array( 'domain' => 'www.w.org',          'path' => '/foo/' ),
     89                        'www.w.org/foo/bar/'          => array( 'domain' => 'www.w.org',          'path' => '/foo/bar/' ),
     90                );
     91
     92                foreach ( $ids as &$id ) {
     93                        $id = $this->factory->blog->create( $id );
     94                }
     95                unset( $id );
     96
     97                $this->assertEquals( $ids['wordpress.org/'],
     98                        get_site_by_path( 'wordpress.org', '/notapath/' )->blog_id );
     99
     100                $this->assertEquals( $ids['wordpress.org/'],
     101                        get_site_by_path( 'www.wordpress.org', '/notapath/' )->blog_id );
     102
     103                $this->assertEquals( $ids['wordpress.org/foo/bar/'],
     104                        get_site_by_path( 'wordpress.org', '/foo/bar/baz/' )->blog_id );
     105
     106                $this->assertEquals( $ids['wordpress.org/foo/bar/'],
     107                        get_site_by_path( 'www.wordpress.org', '/foo/bar/baz/' )->blog_id );
     108
     109                $this->assertEquals( $ids['wordpress.org/foo/bar/'],
     110                        get_site_by_path( 'wordpress.org', '/foo/bar/baz/', 3 )->blog_id );
     111
     112                $this->assertEquals( $ids['wordpress.org/foo/bar/'],
     113                        get_site_by_path( 'www.wordpress.org', '/foo/bar/baz/', 3 )->blog_id );
     114
     115                $this->assertEquals( $ids['wordpress.org/foo/bar/'],
     116                        get_site_by_path( 'wordpress.org', '/foo/bar/baz/', 2 )->blog_id );
     117
     118                $this->assertEquals( $ids['wordpress.org/foo/bar/'],
     119                        get_site_by_path( 'www.wordpress.org', '/foo/bar/baz/', 2 )->blog_id );
     120
     121                $this->assertEquals( $ids['wordpress.org/foo/'],
     122                        get_site_by_path( 'wordpress.org', '/foo/bar/baz/', 1 )->blog_id );
     123
     124                $this->assertEquals( $ids['wordpress.org/foo/'],
     125                        get_site_by_path( 'www.wordpress.org', '/foo/bar/baz/', 1 )->blog_id );
     126
     127                $this->assertEquals( $ids['wordpress.org/'],
     128                        get_site_by_path( 'wordpress.org', '/', 0 )->blog_id );
     129
     130                $this->assertEquals( $ids['wordpress.org/'],
     131                        get_site_by_path( 'www.wordpress.org', '/', 0 )->blog_id );
     132
     133                $this->assertEquals( $ids['make.wordpress.org/foo/'],
     134                        get_site_by_path( 'make.wordpress.org', '/foo/bar/baz/qux/', 4 )->blog_id );
     135
     136                $this->assertEquals( $ids['make.wordpress.org/foo/'],
     137                        get_site_by_path( 'www.make.wordpress.org', '/foo/bar/baz/qux/', 4 )->blog_id );
     138
     139                $this->assertEquals( $ids['www.w.org/'],
     140                        get_site_by_path( 'www.w.org', '/', 0 )->blog_id );
     141
     142                $this->assertEquals( $ids['www.w.org/'],
     143                        get_site_by_path( 'www.w.org', '/notapath/' )->blog_id );
     144
     145                $this->assertEquals( $ids['www.w.org/foo/bar/'],
     146                        get_site_by_path( 'www.w.org', '/foo/bar/baz/' )->blog_id );
     147
     148                $this->assertEquals( $ids['www.w.org/foo/'],
     149                        get_site_by_path( 'www.w.org', '/foo/bar/baz/', 1 )->blog_id );
     150
     151                // A site installed with www will not be found by the root domain.
     152                $this->assertFalse( get_site_by_path( 'w.org', '/' ) );
     153                $this->assertFalse( get_site_by_path( 'w.org', '/notapath/' ) );
     154                $this->assertFalse( get_site_by_path( 'w.org', '/foo/bar/baz/' ) );
     155                $this->assertFalse( get_site_by_path( 'w.org', '/foo/bar/baz/', 1 ) );
     156
     157                // A site will not be found by its root domain when an invalid subdomain is requested.
     158                $this->assertFalse( get_site_by_path( 'invalid.wordpress.org', '/' ) );
     159                $this->assertFalse( get_site_by_path( 'invalid.wordpress.org', '/foo/bar/' ) );
     160        }
     161
     162        /**
     163         * @ticket 27884
     164         */
     165        function test_multisite_bootstrap() {
     166                global $current_blog;
     167
     168                $network_ids = array(
     169                        'wordpress.org/'         => array( 'domain' => 'wordpress.org', 'path' => '/' ),
     170                        'make.wordpress.org/'    => array( 'domain' => 'make.wordpress.org', 'path' => '/' ),
     171                );
     172
     173                foreach ( $network_ids as &$id ) {
     174                        $id = $this->factory->network->create( $id );
     175                }
     176                unset( $id );
     177
     178                $ids = array(
     179                        'wordpress.org/'              => array( 'domain' => 'wordpress.org',      'path' => '/',         'site_id' => $network_ids['wordpress.org/'] ),
     180                        'wordpress.org/foo/'          => array( 'domain' => 'wordpress.org',      'path' => '/foo/',     'site_id' => $network_ids['wordpress.org/'] ),
     181                        'wordpress.org/foo/bar/'      => array( 'domain' => 'wordpress.org',      'path' => '/foo/bar/', 'site_id' => $network_ids['wordpress.org/'] ),
     182                        'make.wordpress.org/'         => array( 'domain' => 'make.wordpress.org', 'path' => '/',         'site_id' => $network_ids['make.wordpress.org/'] ),
     183                        'make.wordpress.org/foo/'     => array( 'domain' => 'make.wordpress.org', 'path' => '/foo/',     'site_id' => $network_ids['make.wordpress.org/'] ),
     184                );
     185
     186                foreach ( $ids as &$id ) {
     187                        $id = $this->factory->blog->create( $id );
     188                }
     189                unset( $id );
     190
     191                $this->_setup_host_request( 'wordpress.org', '/' );
     192                $this->assertEquals( $ids['wordpress.org/'], $current_blog->blog_id );
     193                $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
     194
     195                $this->_setup_host_request( 'wordpress.org', '/2014/04/23/hello-world/' );
     196                $this->assertEquals( $ids['wordpress.org/'], $current_blog->blog_id );
     197                $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
     198
     199                $this->_setup_host_request( 'wordpress.org', '/sample-page/' );
     200                $this->assertEquals( $ids['wordpress.org/'], $current_blog->blog_id );
     201                $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
     202
     203                $this->_setup_host_request( 'wordpress.org', '/?p=1' );
     204                $this->assertEquals( $ids['wordpress.org/'], $current_blog->blog_id );
     205                $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
     206
     207                $this->_setup_host_request( 'wordpress.org', '/wp-admin/' );
     208                $this->assertEquals( $ids['wordpress.org/'], $current_blog->blog_id );
     209                $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
     210
     211                $this->_setup_host_request( 'wordpress.org', '/foo/' );
     212                $this->assertEquals( $ids['wordpress.org/foo/'], $current_blog->blog_id );
     213                $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
     214
     215                $this->_setup_host_request( 'wordpress.org', '/FOO/' );
     216                $this->assertEquals( $ids['wordpress.org/foo/'], $current_blog->blog_id );
     217                $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
     218
     219                $this->_setup_host_request( 'wordpress.org', '/foo/2014/04/23/hello-world/' );
     220                $this->assertEquals( $ids['wordpress.org/foo/'], $current_blog->blog_id );
     221                $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
     222
     223                $this->_setup_host_request( 'wordpress.org', '/foo/sample-page/' );
     224                $this->assertEquals( $ids['wordpress.org/foo/'], $current_blog->blog_id );
     225                $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
     226
     227                $this->_setup_host_request( 'wordpress.org', '/foo/?p=1' );
     228                $this->assertEquals( $ids['wordpress.org/foo/'], $current_blog->blog_id );
     229                $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
     230
     231                $this->_setup_host_request( 'wordpress.org', '/foo/wp-admin/' );
     232                $this->assertEquals( $ids['wordpress.org/foo/'], $current_blog->blog_id );
     233                $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
     234
     235                // @todo not currently passing.
     236                //$this->_setup_host_request( 'wordpress.org', '/foo/bar/' );
     237                //$this->assertEquals( $ids['wordpress.org/foo/bar/'], $current_blog->blog_id );
     238                //$this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
     239
     240                $this->_setup_host_request( 'make.wordpress.org', '/' );
     241                $this->assertEquals( $ids['make.wordpress.org/'], $current_blog->blog_id );
     242                $this->assertEquals( $network_ids['make.wordpress.org/'], $current_blog->site_id );
     243
     244                $this->_setup_host_request( 'make.wordpress.org', '/foo/' );
     245                $this->assertEquals( $ids['make.wordpress.org/foo/'], $current_blog->blog_id );
     246                $this->assertEquals( $network_ids['make.wordpress.org/'], $current_blog->site_id );
     247
     248                // Request the original tests domain and path to unpollute the stack.
     249                $this->_setup_host_request( WP_TESTS_DOMAIN, '/' );
     250        }
     251
     252        /**
     253         * Reset various globals required for a 'clean' multisite boot.
     254         *
     255         * The $wpdb and $table_prefix globals are required for ms-settings.php to
     256         * load properly.
     257         *
     258         * @param string $domain HTTP_HOST of the bootstrap request.
     259         * @param string $path   REQUEST_URI of the boot strap request.
     260         */
     261        function _setup_host_request( $domain, $path ) {
     262                global $current_site, $current_blog, $table_prefix, $wpdb;
     263
     264                $table_prefix = WP_TESTS_TABLE_PREFIX;
     265                $current_site = $current_blog = null;
     266                $_SERVER['HTTP_HOST'] = $domain;
     267                $_SERVER['REQUEST_URI'] = $path;
     268
     269                include ABSPATH . '/wp-includes/ms-settings.php';
     270        }
     271}
     272
     273endif;
     274 No newline at end of file
  • tests/phpunit/tests/multisite/network.php

    Property changes on: tests/phpunit/tests/multisite/bootstrap.php
    ___________________________________________________________________
    Added: svn:executable
    ## -0,0 +1 ##
    +*
    \ No newline at end of property
     
     1<?php
     2
     3if ( is_multisite() ) :
     4
     5/**
     6 * Tests specific to networks in multisite.
     7 *
     8 * @group ms-network
     9 * @group multisite
     10 */
     11class Tests_Multisite_Network extends WP_UnitTestCase {
     12        protected $plugin_hook_count = 0;
     13        protected $suppress = false;
     14
     15        function setUp() {
     16                global $wpdb;
     17                parent::setUp();
     18                $this->suppress = $wpdb->suppress_errors();
     19
     20                $_SERVER[ 'REMOTE_ADDR' ] = '';
     21        }
     22
     23        function tearDown() {
     24                global $wpdb;
     25                parent::tearDown();
     26                $wpdb->suppress_errors( $this->suppress );
     27        }
     28
     29        /**
     30         * @ticket 22917
     31         */
     32        function test_enable_live_network_site_counts_filter() {
     33                $site_count_start = get_blog_count();
     34                // false for large networks by default
     35                add_filter( 'enable_live_network_counts', '__return_false' );
     36                $this->factory->blog->create_many( 4 );
     37
     38                // count only updated when cron runs, so unchanged
     39                $this->assertEquals( $site_count_start, (int) get_blog_count() );
     40
     41                add_filter( 'enable_live_network_counts', '__return_true' );
     42                $site_ids = $this->factory->blog->create_many( 4 );
     43
     44                $this->assertEquals( $site_count_start + 9, (int) get_blog_count() );
     45
     46                //clean up
     47                remove_filter( 'enable_live_network_counts', '__return_false' );
     48                remove_filter( 'enable_live_network_counts', '__return_true' );
     49                foreach ( $site_ids as $site_id ) {
     50                        wpmu_delete_blog( $site_id, true );
     51                }
     52        }
     53        /**
     54         * @ticket 22917
     55         */
     56        function test_enable_live_network_user_counts_filter() {
     57                // false for large networks by default
     58                add_filter( 'enable_live_network_counts', '__return_false' );
     59
     60                // Refresh the cache
     61                wp_update_network_counts();
     62                $start_count = get_user_count();
     63
     64                wpmu_create_user( 'user', 'pass', 'email' );
     65
     66                // No change, cache not refreshed
     67                $count = get_user_count();
     68
     69                $this->assertEquals( $start_count, $count );
     70
     71                wp_update_network_counts();
     72                $start_count = get_user_count();
     73
     74                add_filter( 'enable_live_network_counts', '__return_true' );
     75
     76                wpmu_create_user( 'user2', 'pass2', 'email2' );
     77
     78                $count = get_user_count();
     79                $this->assertEquals( $start_count + 1, $count );
     80
     81                remove_filter( 'enable_live_network_counts', '__return_false' );
     82                remove_filter( 'enable_live_network_counts', '__return_true' );
     83        }
     84
     85        function test_active_network_plugins() {
     86                $path = "hello.php";
     87
     88                // local activate, should be invisible for the network
     89                activate_plugin($path); // $network_wide = false
     90                $active_plugins = wp_get_active_network_plugins();
     91                $this->assertEquals( Array(), $active_plugins );
     92
     93                add_action( 'deactivated_plugin', array( $this, '_helper_deactivate_hook' ) );
     94
     95                // activate the plugin sitewide
     96                activate_plugin($path, '', $network_wide = true);
     97                $active_plugins = wp_get_active_network_plugins();
     98                $this->assertEquals( Array(WP_PLUGIN_DIR . '/hello.php'), $active_plugins );
     99
     100                //deactivate the plugin
     101                deactivate_plugins($path);
     102                $active_plugins = wp_get_active_network_plugins();
     103                $this->assertEquals( Array(), $active_plugins );
     104
     105                $this->assertEquals( 1, $this->plugin_hook_count ); // testing actions and silent mode
     106
     107                activate_plugin($path, '', $network_wide = true);
     108                deactivate_plugins($path, true); // silent
     109
     110                $this->assertEquals( 1, $this->plugin_hook_count ); // testing actions and silent mode
     111        }
     112
     113        /**
     114         * @ticket 28651
     115         */
     116        function test_duplicate_network_active_plugin() {
     117                $path = "hello.php";
     118                $mock = new MockAction();
     119                add_action( 'activate_' . $path, array ( $mock, 'action' ) );
     120
     121                // should activate on the first try
     122                activate_plugin( $path, '', true );
     123                $active_plugins = wp_get_active_network_plugins();
     124                $this->assertCount( 1, $active_plugins );
     125                $this->assertEquals( 1, $mock->get_call_count() );
     126
     127                // should do nothing on the second try
     128                activate_plugin( $path, '', true );
     129                $active_plugins = wp_get_active_network_plugins();
     130                $this->assertCount( 1, $active_plugins );
     131                $this->assertEquals( 1, $mock->get_call_count() );
     132
     133                remove_action( 'activate_' . $path, array ( $mock, 'action' ) );
     134        }
     135
     136        function _helper_deactivate_hook() {
     137                $this->plugin_hook_count++;
     138        }
     139
     140        function test_get_user_count() {
     141                // Refresh the cache
     142                wp_update_network_counts();
     143                $start_count = get_user_count();
     144
     145                // Only false for large networks as of 3.7
     146                add_filter( 'enable_live_network_counts', '__return_false' );
     147                $this->factory->user->create( array( 'role' => 'administrator' ) );
     148
     149                $count = get_user_count(); // No change, cache not refreshed
     150                $this->assertEquals( $start_count, $count );
     151
     152                wp_update_network_counts(); // Magic happens here
     153
     154                $count = get_user_count();
     155                $this->assertEquals( $start_count + 1, $count );
     156                remove_filter( 'enable_live_network_counts', '__return_false' );
     157        }
     158
     159        function test_wp_schedule_update_network_counts() {
     160                $this->assertFalse(wp_next_scheduled('update_network_counts'));
     161
     162                // We can't use wp_schedule_update_network_counts() because WP_INSTALLING is set
     163                wp_schedule_event(time(), 'twicedaily', 'update_network_counts');
     164
     165                $this->assertInternalType('int', wp_next_scheduled('update_network_counts'));
     166        }
     167
     168        /**
     169         * @expectedDeprecated get_dashboard_blog
     170         */
     171        function test_get_dashboard_blog() {
     172                // if there is no dashboard blog set, current blog is used
     173                $dashboard_blog = get_dashboard_blog();
     174                $this->assertEquals( 1, $dashboard_blog->blog_id );
     175
     176                $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
     177                $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id ) );
     178                $this->assertInternalType( 'int', $blog_id );
     179
     180                // set the dashboard blog to another one
     181                update_site_option( 'dashboard_blog', $blog_id );
     182                $dashboard_blog = get_dashboard_blog();
     183                $this->assertEquals( $blog_id, $dashboard_blog->blog_id );
     184        }
     185}
     186
     187endif;
     188 No newline at end of file
  • tests/phpunit/tests/multisite/site.php

     
     1<?php
     2
     3if ( is_multisite() ) :
     4
     5/**
     6 * Tests specific to sites in multisite.
     7 *
     8 * @group ms-site
     9 * @group multisite
     10 */
     11class Tests_Multisite_Site extends WP_UnitTestCase {
     12        protected $suppress = false;
     13
     14        function setUp() {
     15                global $wpdb;
     16                parent::setUp();
     17                $this->suppress = $wpdb->suppress_errors();
     18
     19                $_SERVER[ 'REMOTE_ADDR' ] = '';
     20        }
     21
     22        function tearDown() {
     23                global $wpdb;
     24                parent::tearDown();
     25                $wpdb->suppress_errors( $this->suppress );
     26        }
     27
     28        function test_switch_restore_blog() {
     29                global $_wp_switched_stack, $wpdb;
     30
     31                $this->assertEquals( array(), $_wp_switched_stack );
     32                $this->assertFalse( ms_is_switched() );
     33                $current_blog_id = get_current_blog_id();
     34                $this->assertInternalType( 'integer', $current_blog_id );
     35
     36                wp_cache_set( 'switch-test', $current_blog_id, 'switch-test' );
     37                $this->assertEquals( $current_blog_id, wp_cache_get( 'switch-test', 'switch-test' ) );
     38
     39                $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
     40                $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id, 'path' => '/test_blogpath', 'title' => 'Test Title' ) );
     41
     42                $cap_key = wp_get_current_user()->cap_key;
     43                switch_to_blog( $blog_id );
     44                $this->assertNotEquals( $cap_key, wp_get_current_user()->cap_key );
     45                $this->assertEquals( array( $current_blog_id ), $_wp_switched_stack );
     46                $this->assertTrue( ms_is_switched() );
     47                $this->assertEquals( $blog_id, $wpdb->blogid );
     48                $this->assertFalse( wp_cache_get( 'switch-test', 'switch-test' ) );
     49                wp_cache_set( 'switch-test', $blog_id, 'switch-test' );
     50                $this->assertEquals( $blog_id, wp_cache_get( 'switch-test', 'switch-test' ) );
     51
     52                switch_to_blog( $blog_id );
     53                $this->assertEquals( array( $current_blog_id, $blog_id ), $_wp_switched_stack );
     54                $this->assertTrue( ms_is_switched() );
     55                $this->assertEquals( $blog_id, $wpdb->blogid );
     56                $this->assertEquals( $blog_id, wp_cache_get( 'switch-test', 'switch-test' ) );
     57
     58                restore_current_blog();
     59                $this->assertEquals( array( $current_blog_id ), $_wp_switched_stack );
     60                $this->assertTrue( ms_is_switched() );
     61                $this->assertEquals( $blog_id, $wpdb->blogid );
     62                $this->assertEquals( $blog_id, wp_cache_get( 'switch-test', 'switch-test' ) );
     63
     64                restore_current_blog();
     65                $this->assertEquals( $cap_key, wp_get_current_user()->cap_key );
     66                $this->assertEquals( $current_blog_id, get_current_blog_id() );
     67                $this->assertEquals( array(), $_wp_switched_stack );
     68                $this->assertFalse( ms_is_switched() );
     69                $this->assertEquals( $current_blog_id, wp_cache_get( 'switch-test', 'switch-test' ) );
     70
     71                $this->assertFalse( restore_current_blog() );
     72        }
     73
     74        function test_create_and_delete_blog() {
     75                global $wpdb;
     76
     77                $blog_ids = $this->factory->blog->create_many( 4 );
     78                foreach ( $blog_ids as $blog_id ) {
     79                        $this->assertInternalType( 'int', $blog_id );
     80                        $prefix = $wpdb->get_blog_prefix( $blog_id );
     81
     82                        // $get_all = false
     83                        $details = get_blog_details( $blog_id, false );
     84                        $this->assertEquals( $details, wp_cache_get( $blog_id . 'short', 'blog-details' ) );
     85
     86                        // get_id_from_blogname(), see #20950
     87                        $this->assertEquals( $blog_id, get_id_from_blogname( $details->path ) );
     88                        $this->assertEquals( $blog_id, wp_cache_get( 'get_id_from_blogname_' . trim( $details->path, '/' ), 'blog-details' ) );
     89
     90                        // get_blog_id_from_url()
     91                        $this->assertEquals( $blog_id, get_blog_id_from_url( $details->domain, $details->path ) );
     92                        $key = md5( $details->domain . $details->path );
     93                        $this->assertEquals( $blog_id, wp_cache_get( $key, 'blog-id-cache' ) );
     94
     95                        // These are empty until get_blog_details() is called with $get_all = true
     96                        $this->assertEquals( false, wp_cache_get( $blog_id, 'blog-details' ) );
     97                        $key = md5( $details->domain . $details->path );
     98                        $this->assertEquals( false, wp_cache_get( $key, 'blog-lookup' ) );
     99
     100                        // $get_all = true should propulate the full blog-details cache and the blog slug lookup cache
     101                        $details = get_blog_details( $blog_id, true );
     102                        $this->assertEquals( $details, wp_cache_get( $blog_id, 'blog-details' ) );
     103                        $this->assertEquals( $details, wp_cache_get( $key, 'blog-lookup' ) );
     104
     105                        foreach ( $wpdb->tables( 'blog', false ) as $table ) {
     106                                $suppress = $wpdb->suppress_errors();
     107                                $table_fields = $wpdb->get_results( "DESCRIBE $prefix$table;" );
     108                                $wpdb->suppress_errors( $suppress );
     109                                $this->assertNotEmpty( $table_fields );
     110                                $result = $wpdb->get_results( "SELECT * FROM $prefix$table LIMIT 1" );
     111                                if ( 'commentmeta' == $table || 'links' == $table )
     112                                        $this->assertEmpty( $result );
     113                                else
     114                                        $this->assertNotEmpty( $result );
     115                        }
     116                }
     117
     118                // update the blog count cache to use get_blog_count()
     119                wp_update_network_counts();
     120                $this->assertEquals( 4 + 1, (int) get_blog_count() );
     121
     122                $drop_tables = false;
     123                // delete all blogs
     124                foreach ( $blog_ids as $blog_id ) {
     125                        // drop tables for every second blog
     126                        $drop_tables = ! $drop_tables;
     127                        $details = get_blog_details( $blog_id, false );
     128
     129                        wpmu_delete_blog( $blog_id, $drop_tables );
     130
     131                        $this->assertEquals( false, wp_cache_get( 'get_id_from_blogname_' . trim( $details->path, '/' ), 'blog-details' ) );
     132                        $this->assertEquals( false, wp_cache_get( $blog_id, 'blog-details' ) );
     133                        $this->assertEquals( false, wp_cache_get( $blog_id . 'short', 'blog-details' ) );
     134                        $key = md5( $details->domain . $details->path );
     135                        $this->assertEquals( false, wp_cache_get( $key, 'blog-lookup' ) );
     136                        $this->assertEquals( false, wp_cache_get( $key, 'blog-id-cache' ) );
     137
     138                        $prefix = $wpdb->get_blog_prefix( $blog_id );
     139                        foreach ( $wpdb->tables( 'blog', false ) as $table ) {
     140                                $suppress = $wpdb->suppress_errors();
     141                                $table_fields = $wpdb->get_results( "DESCRIBE $prefix$table;" );
     142                                $wpdb->suppress_errors( $suppress );
     143                                if ( $drop_tables )
     144                                        $this->assertEmpty( $table_fields );
     145                                else
     146                                        $this->assertNotEmpty( $table_fields, $prefix . $table );
     147                        }
     148                }
     149
     150                // update the blog count cache to use get_blog_count()
     151                wp_update_network_counts();
     152                $this->assertEquals( 1, get_blog_count() );
     153        }
     154
     155        function test_wpmu_update_blogs_date() {
     156                global $wpdb;
     157
     158                wpmu_update_blogs_date();
     159
     160                // compare the update time with the current time, allow delta < 2
     161                $blog = get_blog_details( $wpdb->blogid );
     162                $current_time = time();
     163                $time_difference = $current_time - strtotime( $blog->last_updated );
     164                $this->assertLessThan( 2, $time_difference );
     165        }
     166
     167        function test_getters(){
     168                global $current_site;
     169
     170                $blog_id = get_current_blog_id();
     171                $blog = get_blog_details( $blog_id );
     172                $this->assertEquals( $blog_id, $blog->blog_id );
     173                $this->assertEquals( $current_site->domain, $blog->domain );
     174                $this->assertEquals( '/', $blog->path );
     175
     176                // Test defaulting to current blog
     177                $this->assertEquals( $blog, get_blog_details() );
     178
     179                $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
     180                $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id, 'path' => '/test_blogname', 'title' => 'Test Title' ) );
     181                $this->assertInternalType( 'int', $blog_id );
     182
     183                $this->assertEquals( 'http://' . $current_site->domain . $current_site->path . 'test_blogname/', get_blogaddress_by_name('test_blogname') );
     184
     185                $this->assertEquals( $blog_id, get_id_from_blogname('test_blogname') );
     186        }
     187
     188        function test_update_blog_details() {
     189                global $test_action_counter;
     190
     191                $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
     192                $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id, 'path' => '/test_blogpath', 'title' => 'Test Title' ) );
     193                $this->assertInternalType( 'int', $blog_id );
     194
     195                $result = update_blog_details( $blog_id, array('domain' => 'example.com', 'path' => 'my_path/') );
     196                $this->assertTrue( $result );
     197
     198                $blog = get_blog_details( $blog_id );
     199                $this->assertEquals( 'example.com', $blog->domain );
     200                $this->assertEquals( 'my_path/', $blog->path );
     201                $this->assertEquals( '0', $blog->spam );
     202
     203                $result = update_blog_details( $blog_id, array('domain' => 'example2.com','spam' => 1) );
     204                $this->assertTrue( $result );
     205                $blog = get_blog_details( $blog_id );
     206                $this->assertEquals( 'example2.com', $blog->domain );
     207                $this->assertEquals( 'my_path/', $blog->path );
     208                $this->assertEquals( '1', $blog->spam );
     209
     210                $result = update_blog_details( $blog_id );
     211                $this->assertFalse( $result );
     212                $blog = get_blog_details( $blog_id );
     213                $this->assertEquals( 'example2.com', $blog->domain );
     214                $this->assertEquals( 'my_path/', $blog->path );
     215                $this->assertEquals( '1', $blog->spam );
     216
     217                $test_action_counter = 0;
     218
     219                add_action( 'make_ham_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     220                $result = update_blog_details( $blog_id, array( 'spam' => 0 ) );
     221                $this->assertTrue( $result );
     222                $blog = get_blog_details( $blog_id );
     223                $this->assertEquals( '0', $blog->spam );
     224                $this->assertEquals( 1, $test_action_counter );
     225
     226                // Same again
     227                $result = update_blog_details( $blog_id, array( 'spam' => 0 ) );
     228                $this->assertTrue( $result );
     229                $blog = get_blog_details( $blog_id );
     230                $this->assertEquals( '0', $blog->spam );
     231                $this->assertEquals( 1, $test_action_counter );
     232                remove_action( 'make_ham_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     233
     234                add_action( 'make_spam_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     235                $result = update_blog_details( $blog_id, array( 'spam' => 1 ) );
     236                $this->assertTrue( $result );
     237                $blog = get_blog_details( $blog_id );
     238                $this->assertEquals( '1', $blog->spam );
     239                $this->assertEquals( 2, $test_action_counter );
     240
     241                // Same again
     242                $result = update_blog_details( $blog_id, array( 'spam' => 1 ) );
     243                $this->assertTrue( $result );
     244                $blog = get_blog_details( $blog_id );
     245                $this->assertEquals( '1', $blog->spam );
     246                $this->assertEquals( 2, $test_action_counter );
     247                remove_action( 'make_spam_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     248
     249                add_action( 'archive_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     250                $result = update_blog_details( $blog_id, array( 'archived' => 1 ) );
     251                $this->assertTrue( $result );
     252                $blog = get_blog_details( $blog_id );
     253                $this->assertEquals( '1', $blog->archived );
     254                $this->assertEquals( 3, $test_action_counter );
     255
     256                // Same again
     257                $result = update_blog_details( $blog_id, array( 'archived' => 1 ) );
     258                $this->assertTrue( $result );
     259                $blog = get_blog_details( $blog_id );
     260                $this->assertEquals( '1', $blog->archived );
     261                $this->assertEquals( 3, $test_action_counter );
     262                remove_action( 'archive_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     263
     264                add_action( 'unarchive_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     265                $result = update_blog_details( $blog_id, array( 'archived' => 0 ) );
     266                $this->assertTrue( $result );
     267                $blog = get_blog_details( $blog_id );
     268                $this->assertEquals( '0', $blog->archived );
     269                $this->assertEquals( 4, $test_action_counter );
     270
     271                // Same again
     272                $result = update_blog_details( $blog_id, array( 'archived' => 0 ) );
     273                $this->assertTrue( $result );
     274                $blog = get_blog_details( $blog_id );
     275                $this->assertEquals( '0', $blog->archived );
     276                $this->assertEquals( 4, $test_action_counter );
     277                remove_action( 'unarchive_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     278
     279                add_action( 'make_delete_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     280                $result = update_blog_details( $blog_id, array( 'deleted' => 1 ) );
     281                $this->assertTrue( $result );
     282                $blog = get_blog_details( $blog_id );
     283                $this->assertEquals( '1', $blog->deleted );
     284                $this->assertEquals( 5, $test_action_counter );
     285
     286                // Same again
     287                $result = update_blog_details( $blog_id, array( 'deleted' => 1 ) );
     288                $this->assertTrue( $result );
     289                $blog = get_blog_details( $blog_id );
     290                $this->assertEquals( '1', $blog->deleted );
     291                $this->assertEquals( 5, $test_action_counter );
     292                remove_action( 'make_delete_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     293
     294                add_action( 'make_undelete_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     295                $result = update_blog_details( $blog_id, array( 'deleted' => 0 ) );
     296                $this->assertTrue( $result );
     297                $blog = get_blog_details( $blog_id );
     298                $this->assertEquals( '0', $blog->deleted );
     299                $this->assertEquals( 6, $test_action_counter );
     300
     301                // Same again
     302                $result = update_blog_details( $blog_id, array( 'deleted' => 0 ) );
     303                $this->assertTrue( $result );
     304                $blog = get_blog_details( $blog_id );
     305                $this->assertEquals( '0', $blog->deleted );
     306                $this->assertEquals( 6, $test_action_counter );
     307                remove_action( 'make_undelete_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     308
     309                add_action( 'mature_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     310                $result = update_blog_details( $blog_id, array( 'mature' => 1 ) );
     311                $this->assertTrue( $result );
     312                $blog = get_blog_details( $blog_id );
     313                $this->assertEquals( '1', $blog->mature );
     314                $this->assertEquals( 7, $test_action_counter );
     315
     316                // Same again
     317                $result = update_blog_details( $blog_id, array( 'mature' => 1 ) );
     318                $this->assertTrue( $result );
     319                $blog = get_blog_details( $blog_id );
     320                $this->assertEquals( '1', $blog->mature );
     321                $this->assertEquals( 7, $test_action_counter );
     322                remove_action( 'mature_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     323
     324                add_action( 'unmature_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     325                $result = update_blog_details( $blog_id, array( 'mature' => 0 ) );
     326                $this->assertTrue( $result );
     327                $blog = get_blog_details( $blog_id );
     328                $this->assertEquals( '0', $blog->mature );
     329                $this->assertEquals( 8, $test_action_counter );
     330
     331                // Same again
     332                $result = update_blog_details( $blog_id, array( 'mature' => 0 ) );
     333                $this->assertTrue( $result );
     334                $blog = get_blog_details( $blog_id );
     335                $this->assertEquals( '0', $blog->mature );
     336                $this->assertEquals( 8, $test_action_counter );
     337                remove_action( 'unmature_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     338        }
     339
     340        function _action_counter_cb( $blog_id ) {
     341                global $test_action_counter;
     342                $test_action_counter++;
     343        }
     344
     345        /**
     346         * Test fetching a blog that doesn't exist and again after it exists.
     347         *
     348         * @ticket 23405
     349         */
     350        function test_get_blog_details_blog_does_not_exist() {
     351                global $wpdb;
     352
     353                $blog_id = $wpdb->get_var( "SELECT MAX(blog_id) FROM $wpdb->blogs" );
     354
     355                // An idosyncrancy of the unit tests is that the max blog_id gets reset
     356                // to 1 in between test cases but picks up where it previously left off
     357                // on the next insert. If 1 is reported, burn a blog create to get
     358                // the max counter back in sync.
     359                if ( 1 == $blog_id ) {
     360                        $blog_id = $this->factory->blog->create();
     361                }
     362                $blog_id++;
     363
     364                $this->assertFalse( wp_cache_get( $blog_id, 'blog-details' ) );
     365                $this->assertFalse( get_blog_details( $blog_id ) );
     366                $this->assertEquals( -1, wp_cache_get( $blog_id, 'blog-details' ) );
     367                $this->assertFalse( get_blog_details( $blog_id ) );
     368                $this->assertEquals( -1, wp_cache_get( $blog_id, 'blog-details' ) );
     369
     370                $this->assertEquals( $blog_id, $this->factory->blog->create() );
     371                $this->assertFalse( wp_cache_get( $blog_id, 'blog-details' )  );
     372
     373                $blog = get_blog_details( $blog_id );
     374                $this->assertEquals( $blog_id, $blog->blog_id );
     375                $this->assertEquals( $blog, wp_cache_get( $blog_id, 'blog-details' ) );
     376
     377                wpmu_delete_blog( $blog_id );
     378                $this->assertFalse( wp_cache_get( $blog_id, 'blog-details' ) );
     379                $blog->deleted = '1';
     380                $this->assertEQuals( $blog, get_blog_details( $blog_id ) );
     381                $this->assertEquals( $blog, wp_cache_get( $blog_id, 'blog-details' ) );
     382
     383                wpmu_delete_blog( $blog_id, true );
     384                $this->assertFalse( get_blog_details( $blog_id ) );
     385                $this->assertEquals( -1, wp_cache_get( $blog_id, 'blog-details' ) );
     386        }
     387
     388        function test_update_blog_status() {
     389                global $test_action_counter;
     390
     391                $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
     392                $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id, 'path' => '/test_blogpath', 'title' => 'Test Title' ) );
     393                $this->assertInternalType( 'int', $blog_id );
     394
     395                $test_action_counter = 0;
     396                $count = 1;
     397
     398                add_action( 'make_ham_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     399                $result = update_blog_status( $blog_id, 'spam', 0 );
     400                $this->assertEquals( 0, $result );
     401                $blog = get_blog_details( $blog_id );
     402                $this->assertEquals( '0', $blog->spam );
     403                $this->assertEquals( $count, $test_action_counter );
     404
     405                // Same again
     406                $count++;
     407                $result = update_blog_status( $blog_id, 'spam', 0 );
     408                $this->assertEquals( 0, $result );
     409                $blog = get_blog_details( $blog_id );
     410                $this->assertEquals( '0', $blog->spam );
     411                $this->assertEquals( $count, $test_action_counter );
     412                remove_action( 'make_ham_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     413
     414                $count++;
     415                add_action( 'make_spam_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     416                $result = update_blog_status( $blog_id, 'spam', 1 );
     417                $this->assertEquals( 1, $result );
     418                $blog = get_blog_details( $blog_id );
     419                $this->assertEquals( '1', $blog->spam );
     420                $this->assertEquals( $count, $test_action_counter );
     421
     422                // Same again
     423                $count++;
     424                $result = update_blog_status( $blog_id, 'spam', 1 );
     425                $this->assertEquals( 1, $result );
     426                $blog = get_blog_details( $blog_id );
     427                $this->assertEquals( '1', $blog->spam );
     428                $this->assertEquals( $count, $test_action_counter );
     429                remove_action( 'make_spam_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     430
     431                add_action( 'archive_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     432                $count++;
     433                $result = update_blog_status( $blog_id, 'archived', 1 );
     434                $this->assertEquals( 1, $result );
     435                $blog = get_blog_details( $blog_id );
     436                $this->assertEquals( '1', $blog->archived );
     437                $this->assertEquals( $count, $test_action_counter );
     438
     439                // Same again
     440                $count++;
     441                $result = update_blog_status( $blog_id, 'archived', 1 );
     442                $this->assertEquals( 1, $result );
     443                $blog = get_blog_details( $blog_id );
     444                $this->assertEquals( '1', $blog->archived );
     445                $this->assertEquals( $count, $test_action_counter );
     446                remove_action( 'archive_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     447
     448                add_action( 'unarchive_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     449                $count++;
     450                $result = update_blog_status( $blog_id, 'archived', 0 );
     451                $this->assertEquals( 0, $result );
     452                $blog = get_blog_details( $blog_id );
     453                $this->assertEquals( '0', $blog->archived );
     454                $this->assertEquals( $count, $test_action_counter );
     455
     456                // Same again
     457                $result = update_blog_status( $blog_id, 'archived', 0 );
     458                $count++;
     459                $this->assertEquals( 0, $result );
     460                $blog = get_blog_details( $blog_id );
     461                $this->assertEquals( '0', $blog->archived );
     462                $this->assertEquals( $count, $test_action_counter );
     463                remove_action( 'unarchive_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     464
     465                add_action( 'make_delete_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     466                $count++;
     467                $result = update_blog_status( $blog_id, 'deleted', 1 );
     468                $this->assertEquals( 1, $result );
     469                $blog = get_blog_details( $blog_id );
     470                $this->assertEquals( '1', $blog->deleted );
     471                $this->assertEquals( $count, $test_action_counter );
     472
     473                // Same again
     474                $count++;
     475                $result = update_blog_status( $blog_id, 'deleted', 1 );
     476                $this->assertEquals( 1, $result );
     477                $blog = get_blog_details( $blog_id );
     478                $this->assertEquals( '1', $blog->deleted );
     479                $this->assertEquals( $count, $test_action_counter );
     480                remove_action( 'make_delete_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     481
     482                add_action( 'make_undelete_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     483                $count++;
     484                $result = update_blog_status( $blog_id, 'deleted', 0 );
     485                $this->assertEquals( 0, $result );
     486                $blog = get_blog_details( $blog_id );
     487                $this->assertEquals( '0', $blog->deleted );
     488                $this->assertEquals( $count, $test_action_counter );
     489
     490                // Same again
     491                $count++;
     492                $result = update_blog_status( $blog_id, 'deleted', 0 );
     493                $this->assertEquals( 0, $result );
     494                $blog = get_blog_details( $blog_id );
     495                $this->assertEquals( '0', $blog->deleted );
     496                $this->assertEquals( $count, $test_action_counter );
     497                remove_action( 'make_undelete_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     498
     499                add_action( 'mature_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     500                $count++;
     501                $result = update_blog_status( $blog_id, 'mature', 1 );
     502                $this->assertEquals( 1, $result );
     503                $blog = get_blog_details( $blog_id );
     504                $this->assertEquals( '1', $blog->mature );
     505                $this->assertEquals( $count, $test_action_counter );
     506
     507                // Same again
     508                $count++;
     509                $result = update_blog_status( $blog_id, 'mature', 1 );
     510                $this->assertEquals( 1, $result );
     511                $blog = get_blog_details( $blog_id );
     512                $this->assertEquals( '1', $blog->mature );
     513                $this->assertEquals( $count, $test_action_counter );
     514                remove_action( 'mature_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     515
     516                add_action( 'unmature_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     517                $count++;
     518                $result = update_blog_status( $blog_id, 'mature', 0 );
     519                $this->assertEquals( 0, $result );
     520                $blog = get_blog_details( $blog_id );
     521                $this->assertEquals( '0', $blog->mature );
     522                $this->assertEquals( $count, $test_action_counter );
     523
     524                // Same again
     525                $count++;
     526                $result = update_blog_status( $blog_id, 'mature', 0 );
     527                $this->assertEquals( 0, $result );
     528                $blog = get_blog_details( $blog_id );
     529                $this->assertEquals( '0', $blog->mature );
     530                $this->assertEquals( $count, $test_action_counter );
     531                remove_action( 'unmature_blog', array( $this, '_action_counter_cb' ), 10, 1 );
     532
     533                add_action( 'update_blog_public', array( $this, '_action_counter_cb' ), 10, 1 );
     534                $count++;
     535                $result = update_blog_status( $blog_id, 'public', 0 );
     536                $this->assertEquals( 0, $result );
     537                $blog = get_blog_details( $blog_id );
     538                $this->assertEquals( '0', $blog->public );
     539                $this->assertEquals( $count, $test_action_counter );
     540
     541                // Same again
     542                $count++;
     543                $result = update_blog_status( $blog_id, 'public', 0 );
     544                $this->assertEquals( 0, $result );
     545                $blog = get_blog_details( $blog_id );
     546                $this->assertEquals( '0', $blog->public );
     547                $this->assertEquals( $count, $test_action_counter );
     548                remove_action( 'update_blog_public', array( $this, '_action_counter_cb' ), 10, 1 );
     549
     550                add_action( 'update_blog_public', array( $this, '_action_counter_cb' ), 10, 1 );
     551                $count++;
     552                $result = update_blog_status( $blog_id, 'public', 1 );
     553                $this->assertEquals( 1, $result );
     554                $blog = get_blog_details( $blog_id );
     555                $this->assertEquals( '1', $blog->public );
     556                $this->assertEquals( $count, $test_action_counter );
     557
     558                // Same again
     559                $count++;
     560                $result = update_blog_status( $blog_id, 'public', 1 );
     561                $this->assertEquals( 1, $result );
     562                $blog = get_blog_details( $blog_id );
     563                $this->assertEquals( '1', $blog->public );
     564                $this->assertEquals( $count, $test_action_counter );
     565                remove_action( 'update_blog_public', array( $this, '_action_counter_cb' ), 10, 1 );
     566
     567                // Updating a dummy field returns the value passed. Go fig.
     568                $result = update_blog_status( $blog_id, 'doesnotexist', 1 );
     569                $this->assertEquals( 1, $result );
     570        }
     571
     572        /**
     573         * @ticket 14511
     574         */
     575        function test_wp_get_sites() {
     576                $this->factory->blog->create_many( 2, array( 'site_id' => 2, 'meta' => array( 'public' => 1 ) ) );
     577                $this->factory->blog->create_many( 3, array( 'site_id' => 3, 'meta' => array( 'public' => 0 ) ) );
     578
     579                // Expect no sites when passed an invalid network_id
     580                $this->assertCount( 0, wp_get_sites( array( 'network_id' => 0 ) ) );
     581                $this->assertCount( 0, wp_get_sites( array( 'network_id' => 4 ) ) );
     582
     583                // Expect 1 site when no network_id is specified - defaults to current network.
     584                $this->assertCount( 1, wp_get_sites() );
     585                // Expect 6 sites when network_id = null.
     586                $this->assertCount( 6, wp_get_sites( array( 'network_id' => null ) ) );
     587
     588                // Expect 1 site with a network_id of 1, 2 for network_id 2, 3 for 3
     589                $this->assertCount( 1, wp_get_sites( array( 'network_id' => 1 ) ) );
     590                $this->assertCount( 2, wp_get_sites( array( 'network_id' => 2 ) ) );
     591                $this->assertCount( 3, wp_get_sites( array( 'network_id' => 3 ) ) );
     592
     593                // Expect 6 sites when public is null (across all networks)
     594                $this->assertCount( 6, wp_get_sites( array( 'public' => null, 'network_id' => null ) ) );
     595
     596                // Expect 3 sites when public is 1
     597                $this->assertCount( 3, wp_get_sites( array( 'public' => 1, 'network_id' => null ) ) );
     598
     599                // Expect 2 sites when public is 1 and network_id is 2
     600                $this->assertCount( 2, wp_get_sites( array( 'network_id' => 2, 'public' => 1 ) ) );
     601
     602                // Expect no sites when public is set to 0 and network_id is not 3
     603                $this->assertCount( 0, wp_get_sites( array( 'network_id' => 1, 'public' => 0 ) ) );
     604
     605                // Test public + network_id = 3
     606                $this->assertCount( 0, wp_get_sites( array( 'network_id' => 3, 'public' => 1 ) ) );
     607                $this->assertCount( 3, wp_get_sites( array( 'network_id' => 3, 'public' => 0 ) ) );
     608        }
     609
     610        /**
     611         * @ticket 14511
     612         */
     613        function test_wp_get_sites_limit_offset() {
     614                // Create 4 more sites (in addition to the default one)
     615                $this->factory->blog->create_many( 4, array( 'meta' => array( 'public' => 1 ) ) );
     616
     617                // Expect all 5 sites when no limit/offset is specified
     618                $this->assertCount( 5, wp_get_sites() );
     619
     620                // Expect first 2 sites when using limit
     621                $this->assertCount( 2, wp_get_sites( array( 'limit' => 2 ) ) );
     622
     623                // Expect only the last 3 sites when using offset of 2 (limit will default to 100)
     624                $this->assertCount( 3, wp_get_sites( array( 'offset' => 2 ) ) );
     625
     626                // Expect only the last 1 site when using offset of 4 and limit of 2
     627                $this->assertCount( 1, wp_get_sites( array( 'limit' => 2, 'offset' => 4 ) ) );
     628
     629                // Expect 0 sites when using an offset larger than the number of sites
     630                $this->assertCount( 0, wp_get_sites( array( 'offset' => 20 ) ) );
     631        }
     632
     633
     634        /**
     635         * @ticket 27952
     636         */
     637        function test_posts_count() {
     638                $this->factory->post->create();
     639                $post2 = $this->factory->post->create();
     640                $this->assertEquals( 2, get_blog_details()->post_count );
     641
     642                wp_delete_post( $post2 );
     643                $this->assertEquals( 1, get_blog_details()->post_count );
     644        }
     645
     646        /**
     647         * @ticket 26410
     648         */
     649        function test_blog_details_cache_invalidation() {
     650                update_option( 'blogname', 'foo' );
     651                $details = get_blog_details( get_current_blog_id() );
     652                $this->assertEquals( 'foo', $details->blogname );
     653
     654                update_option( 'blogname', 'bar' );
     655                $details = get_blog_details( get_current_blog_id() );
     656                $this->assertEquals( 'bar', $details->blogname );
     657        }
     658
     659        /**
     660         * @ticket 29845
     661         */
     662        function test_get_blog_details() {
     663                $network_ids = array(
     664                        'wordpress.org/'         => array( 'domain' => 'wordpress.org', 'path' => '/' ),
     665                        'make.wordpress.org/'    => array( 'domain' => 'make.wordpress.org', 'path' => '/' ),
     666                );
     667
     668                foreach ( $network_ids as &$id ) {
     669                        $id = $this->factory->network->create( $id );
     670                }
     671                unset( $id );
     672
     673                $ids = array(
     674                        'wordpress.org/'              => array( 'domain' => 'wordpress.org',      'path' => '/',         'title' => 'Test 1', 'site_id' => $network_ids['wordpress.org/'] ),
     675                        'wordpress.org/foo/'          => array( 'domain' => 'wordpress.org',      'path' => '/foo/',     'title' => 'Test 2', 'site_id' => $network_ids['wordpress.org/'] ),
     676                        'wordpress.org/foo/bar/'      => array( 'domain' => 'wordpress.org',      'path' => '/foo/bar/', 'title' => 'Test 3', 'site_id' => $network_ids['wordpress.org/'] ),
     677                        'make.wordpress.org/'         => array( 'domain' => 'make.wordpress.org', 'path' => '/',         'title' => 'Test 4', 'site_id' => $network_ids['make.wordpress.org/'] ),
     678                        'make.wordpress.org/foo/'     => array( 'domain' => 'make.wordpress.org', 'path' => '/foo/',     'title' => 'Test 5', 'site_id' => $network_ids['make.wordpress.org/'] ),
     679                );
     680
     681                foreach ( $ids as &$id ) {
     682                        $id = $this->factory->blog->create( $id );
     683                }
     684                unset( $id );
     685
     686                // Retrieve site details by passing only a blog ID.
     687                $site = get_blog_details( $ids['wordpress.org/'] );
     688                $this->assertEquals( $ids['wordpress.org/'], $site->blog_id );
     689                $this->assertEquals( 'Test 1', $site->blogname );
     690
     691                $site = get_blog_details( $ids['wordpress.org/foo/'] );
     692                $this->assertEquals( $ids['wordpress.org/foo/'], $site->blog_id );
     693                $this->assertEquals( 'Test 2', $site->blogname );
     694
     695                $site = get_blog_details( 999 );
     696                $this->assertFalse( $site );
     697
     698                // Retrieve site details by passing an array containing blog_id.
     699                $site = get_blog_details( array( 'blog_id' => $ids['wordpress.org/foo/bar/'] ) );
     700                $this->assertEquals( $ids['wordpress.org/foo/bar/'], $site->blog_id );
     701                $this->assertEquals( 'Test 3', $site->blogname );
     702
     703                $site = get_blog_details( array( 'blog_id' => $ids['make.wordpress.org/'] ) );
     704                $this->assertEquals( $ids['make.wordpress.org/'], $site->blog_id );
     705                $this->assertEquals( 'Test 4', $site->blogname );
     706
     707                $site = get_blog_details( array( 'blog_id' => 999 ) );
     708                $this->assertFalse( $site );
     709
     710                // Retrieve site details by passing an array containing domain and path.
     711                $site = get_blog_details( array( 'domain' => 'wordpress.org', 'path' => '/' ) );
     712                $this->assertEquals( $ids['wordpress.org/'], $site->blog_id );
     713                $this->assertEquals( 'Test 1', $site->blogname );
     714
     715                $site = get_blog_details( array( 'domain' => 'wordpress.org', 'path' => '/foo/' ) );
     716                $this->assertEquals( $ids['wordpress.org/foo/'], $site->blog_id );
     717                $this->assertEquals( 'Test 2', $site->blogname );
     718
     719                $site = get_blog_details( array( 'domain' => 'wordpress.org', 'path' => '/foo/bar/' ) );
     720                $this->assertEquals( $ids['wordpress.org/foo/bar/'], $site->blog_id );
     721                $this->assertEquals( 'Test 3', $site->blogname );
     722
     723                $site = get_blog_details( array( 'domain' => 'make.wordpress.org', 'path' => '/' ) );
     724                $this->assertEquals( $ids['make.wordpress.org/'], $site->blog_id );
     725                $this->assertEquals( 'Test 4', $site->blogname );
     726
     727                $site = get_blog_details( array( 'domain' => 'make.wordpress.org', 'path' => '/foo/' ) );
     728                $this->assertEquals( $ids['make.wordpress.org/foo/'], $site->blog_id );
     729                $this->assertEquals( 'Test 5', $site->blogname );
     730
     731                $site = get_blog_details( array( 'domain' => 'wordpress.org', 'path' => '/zxy/' ) );
     732                $this->assertFalse( $site );
     733        }
     734
     735        function test_get_blog_id_from_url() {
     736                $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
     737                $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id, 'path' => '/testdomainexists', 'title' => 'Test Title' ) );
     738
     739                $details = get_blog_details( $blog_id, false );
     740
     741                $this->assertEquals( $blog_id, get_blog_id_from_url( $details->domain, $details->path ) );
     742                $key = md5( $details->domain . $details->path );
     743                $this->assertEquals( $blog_id, wp_cache_get( $key, 'blog-id-cache' ) );
     744
     745                $this->assertEquals( 0, get_blog_id_from_url( $details->domain, 'foo' ) );
     746
     747                wpmu_delete_blog( $blog_id );
     748                $this->assertEquals( $blog_id, get_blog_id_from_url( $details->domain, $details->path ) );
     749                wpmu_delete_blog( $blog_id, true );
     750
     751                $this->assertEquals( false, wp_cache_get( $key, 'blog-id-cache' ) );
     752                $this->assertEquals( 0, get_blog_id_from_url( $details->domain, $details->path ) );
     753        }
     754
     755        function test_is_main_site() {
     756                $this->assertTrue( is_main_site() );
     757                $this->assertTrue( is_main_site( get_current_blog_id() ) );
     758
     759                $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
     760                $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id ) );
     761
     762                switch_to_blog( $blog_id  );
     763                $this->assertFalse( is_main_site( $blog_id ) );
     764                $this->assertFalse( is_main_site( get_current_blog_id() ) );
     765                $this->assertFalse( is_main_site() );
     766
     767                restore_current_blog();
     768        }
     769
     770        function test_switch_upload_dir() {
     771                $this->assertTrue( is_main_site() );
     772
     773                $site = get_current_site();
     774
     775                $info = wp_upload_dir();
     776                $this->assertEquals( 'http://' . $site->domain . '/wp-content/uploads/' . gmstrftime('%Y/%m'), $info['url'] );
     777                $this->assertEquals( ABSPATH . 'wp-content/uploads/' . gmstrftime('%Y/%m'), $info['path'] );
     778                $this->assertEquals( gmstrftime('/%Y/%m'), $info['subdir'] );
     779                $this->assertEquals( '', $info['error'] );
     780
     781                $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
     782                $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id ) );
     783
     784                switch_to_blog( $blog_id );
     785                $info = wp_upload_dir();
     786                $this->assertEquals( 'http://' . $site->domain . '/wp-content/uploads/sites/' . get_current_blog_id() . '/' . gmstrftime('%Y/%m'), $info['url'] );
     787                $this->assertEquals( ABSPATH . 'wp-content/uploads/sites/' . get_current_blog_id() . '/' . gmstrftime('%Y/%m'), $info['path'] );
     788                $this->assertEquals( gmstrftime('/%Y/%m'), $info['subdir'] );
     789                $this->assertEquals( '', $info['error'] );
     790                restore_current_blog();
     791
     792                $info = wp_upload_dir();
     793                $this->assertEquals( 'http://' . $site->domain . '/wp-content/uploads/' . gmstrftime('%Y/%m'), $info['url'] );
     794                $this->assertEquals( ABSPATH . 'wp-content/uploads/' . gmstrftime('%Y/%m'), $info['path'] );
     795                $this->assertEquals( gmstrftime('/%Y/%m'), $info['subdir'] );
     796                $this->assertEquals( '', $info['error'] );
     797
     798                update_site_option( 'ms_files_rewriting', 1 );
     799                ms_upload_constants();
     800
     801                $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
     802                $blog_id2 = $this->factory->blog->create( array( 'user_id' => $user_id ) );
     803                $info = wp_upload_dir();
     804                $this->assertEquals( 'http://' . $site->domain . '/wp-content/uploads/' . gmstrftime('%Y/%m'), $info['url'] );
     805                $this->assertEquals( ABSPATH . 'wp-content/uploads/' . gmstrftime('%Y/%m'), $info['path'] );
     806                $this->assertEquals( gmstrftime('/%Y/%m'), $info['subdir'] );
     807                $this->assertEquals( '', $info['error'] );
     808
     809                switch_to_blog( $blog_id2 );
     810                $info2 = wp_upload_dir();
     811                $this->assertNotEquals( $info, $info2 );
     812                $this->assertEquals( get_option( 'siteurl' )  . '/wp-content/blogs.dir/' . get_current_blog_id() . '/files/' . gmstrftime('%Y/%m'), $info2['url'] );
     813                $this->assertEquals( ABSPATH . 'wp-content/blogs.dir/' . get_current_blog_id() . '/files/' . gmstrftime('%Y/%m'), $info2['path'] );
     814                $this->assertEquals( gmstrftime('/%Y/%m'), $info2['subdir'] );
     815                $this->assertEquals( '', $info2['error'] );
     816                restore_current_blog();
     817                update_site_option( 'ms_files_rewriting', 0 );
     818        }
     819
     820        /**
     821         * @ticket 18119
     822         */
     823        function test_upload_is_user_over_quota() {
     824                $default_space_allowed = 100;
     825                $echo = false;
     826
     827                $this->assertFalse( upload_is_user_over_quota( $echo ) );
     828                $this->assertTrue( is_upload_space_available() );
     829
     830                update_site_option('upload_space_check_disabled', true);
     831                $this->assertFalse( upload_is_user_over_quota( $echo ) );
     832                $this->assertTrue( is_upload_space_available() );
     833
     834                update_site_option( 'blog_upload_space', 0 );
     835                $this->assertFalse( upload_is_user_over_quota( $echo ) );
     836                $this->assertEquals( $default_space_allowed, get_space_allowed() );
     837                $this->assertTrue( is_upload_space_available() );
     838
     839                update_site_option('upload_space_check_disabled', false);
     840                $this->assertFalse( upload_is_user_over_quota( $echo ) );
     841                $this->assertTrue( is_upload_space_available() );
     842
     843                if ( defined( 'BLOGSUPLOADDIR' ) && ! file_exists( BLOGSUPLOADDIR ) )
     844                        $this->markTestSkipped( 'This test is broken when blogs.dir does not exist. ');
     845
     846                /*
     847                This is broken when blogs.dir does not exist, as get_upload_space_available()
     848                simply returns the value of blog_upload_space (converted to bytes), which would
     849                be negative but still not false. When blogs.dir does exist, < 0 is returned as 0.
     850                */
     851
     852                update_site_option( 'blog_upload_space', -1 );
     853                $this->assertTrue( upload_is_user_over_quota( $echo ) );
     854                $this->assertEquals( -1, get_space_allowed() );
     855                $this->assertFalse( is_upload_space_available() );
     856
     857                update_option( 'blog_upload_space', 0 );
     858                $this->assertFalse( upload_is_user_over_quota( $echo ) );
     859                $this->assertEquals( $default_space_allowed, get_space_allowed() );
     860                $this->assertTrue( is_upload_space_available() );
     861
     862                update_option( 'blog_upload_space', -1 );
     863                $this->assertTrue( upload_is_user_over_quota( $echo ) );
     864                $this->assertEquals( -1, get_space_allowed() );
     865                $this->assertFalse( is_upload_space_available() );
     866        }
     867
     868        function test_get_blog_post() {
     869                $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
     870                $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id, 'path' => '/test_blogpath', 'title' => 'Test Title' ) );
     871                $current_blog_id = get_current_blog_id();
     872
     873                $post_id = $this->factory->post->create();
     874                $this->assertInstanceOf( 'WP_Post', get_post( $post_id ) );
     875                switch_to_blog( $blog_id );
     876                $this->assertNull( get_post( $post_id ) );
     877                $post = get_blog_post( $current_blog_id, $post_id );
     878                $this->assertInstanceOf( 'WP_Post', $post );
     879                $this->assertEquals( $post_id, $post->ID );
     880                restore_current_blog();
     881
     882                wp_update_post( array( 'ID' => $post_id, 'post_title' => 'A Different Title' ) );
     883                switch_to_blog( $blog_id );
     884                $post = get_blog_post( $current_blog_id, $post_id );
     885                // Make sure cache is good
     886                $this->assertEquals( 'A Different Title', $post->post_title );
     887
     888                $post_id2 = $this->factory->post->create();
     889                // Test get_blog_post() with currently active blog ID.
     890                $post = get_blog_post( $blog_id, $post_id2 );
     891                $this->assertInstanceOf( 'WP_Post', $post );
     892                $this->assertEquals( $post_id2, $post->ID );
     893                restore_current_blog();
     894        }
     895
     896        function _domain_exists_cb( $exists, $domain, $path, $site_id ) {
     897                if ( 'foo' == $domain && 'bar/' == $path )
     898                        return 1234;
     899                else
     900                        return null;
     901        }
     902
     903        function test_domain_exists() {
     904                $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
     905                $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id, 'path' => '/testdomainexists', 'title' => 'Test Title' ) );
     906
     907                $details = get_blog_details( $blog_id, false );
     908
     909                $this->assertEquals( $blog_id, domain_exists( $details->domain, $details->path ) );
     910                $this->assertEquals( $blog_id, domain_exists( $details->domain, $details->path, $details->site_id ) );
     911                $this->assertEquals( null, domain_exists( $details->domain, $details->path, 999 ) );
     912                $this->assertEquals( null, domain_exists( 'foo', 'bar' ) );
     913
     914                add_filter( 'domain_exists', array( $this, '_domain_exists_cb' ), 10, 4 );
     915                $this->assertEquals( 1234, domain_exists( 'foo', 'bar' ) );
     916                $this->assertEquals( null, domain_exists( 'foo', 'baz' ) );
     917                $this->assertEquals( null, domain_exists( 'bar', 'foo' ) );
     918
     919                // Make sure the same result is returned with or without a trailing slash
     920                $this->assertEquals( domain_exists( 'foo', 'bar' ), domain_exists( 'foo', 'bar/' ) );
     921
     922                remove_filter( 'domain_exists', array( $this, '_domain_exists_cb' ), 10, 4 );
     923                $this->assertEquals( null, domain_exists( 'foo', 'bar' ) );
     924
     925                wpmu_delete_blog( $blog_id );
     926                $this->assertEquals( $blog_id, domain_exists( $details->domain, $details->path ) );
     927                wpmu_delete_blog( $blog_id, true );
     928                $this->assertEquals( null, domain_exists( $details->domain, $details->path ) );
     929        }
     930}
     931
     932endif;
     933 No newline at end of file
  • tests/phpunit/tests/multisite.php

     
    77 *
    88 * @group multisite
    99 */
    10 class Tests_MS extends WP_UnitTestCase {
    11         protected $plugin_hook_count = 0;
     10class Tests_Multisite extends WP_UnitTestCase {
    1211        protected $suppress = false;
    1312
    1413        function setUp() {
     
    2524                $wpdb->suppress_errors( $this->suppress );
    2625        }
    2726
    28         function test_remove_user_from_blog() {
    29                 $user1 = $this->factory->user->create_and_get();
    30                 $user2 = $this->factory->user->create_and_get();
    31 
    32                 $post_id = $this->factory->post->create( array( 'post_author' => $user1->ID ) );
    33 
    34                 remove_user_from_blog( $user1->ID, 1, $user2->ID );
    35 
    36                 $post = get_post( $post_id );
    37 
    38                 $this->assertNotEquals( $user1->ID, $post->post_author );
    39                 $this->assertEquals( $user2->ID, $post->post_author );
    40         }
    41 
    42         /**
    43          * @ticket 22917
    44          */
    45         function test_enable_live_network_site_counts_filter() {
    46                 $site_count_start = get_blog_count();
    47                 // false for large networks by default
    48                 add_filter( 'enable_live_network_counts', '__return_false' );
    49                 $this->factory->blog->create_many( 4 );
    50 
    51                 // count only updated when cron runs, so unchanged
    52                 $this->assertEquals( $site_count_start, (int) get_blog_count() );
    53 
    54                 add_filter( 'enable_live_network_counts', '__return_true' );
    55                 $site_ids = $this->factory->blog->create_many( 4 );
    56 
    57                 $this->assertEquals( $site_count_start + 9, (int) get_blog_count() );
    58 
    59                 //clean up
    60                 remove_filter( 'enable_live_network_counts', '__return_false' );
    61                 remove_filter( 'enable_live_network_counts', '__return_true' );
    62                 foreach ( $site_ids as $site_id ) {
    63                         wpmu_delete_blog( $site_id, true );
    64                 }
    65         }
    66 
    67         /**
    68          * @ticket 22917
    69          */
    70         function test_enable_live_network_user_counts_filter() {
    71                 // false for large networks by default
    72                 add_filter( 'enable_live_network_counts', '__return_false' );
    73 
    74                 // Refresh the cache
    75                 wp_update_network_counts();
    76                 $start_count = get_user_count();
    77 
    78                 wpmu_create_user( 'user', 'pass', 'email' );
    79 
    80                 // No change, cache not refreshed
    81                 $count = get_user_count();
    82 
    83                 $this->assertEquals( $start_count, $count );
    84 
    85                 wp_update_network_counts();
    86                 $start_count = get_user_count();
    87 
    88                 add_filter( 'enable_live_network_counts', '__return_true' );
    89 
    90                 wpmu_create_user( 'user2', 'pass2', 'email2' );
    91 
    92                 $count = get_user_count();
    93                 $this->assertEquals( $start_count + 1, $count );
    94 
    95                 remove_filter( 'enable_live_network_counts', '__return_false' );
    96                 remove_filter( 'enable_live_network_counts', '__return_true' );
    97         }
    98 
    99         function test_create_and_delete_blog() {
    100                 global $wpdb;
    101 
    102                 $blog_ids = $this->factory->blog->create_many( 4 );
    103                 foreach ( $blog_ids as $blog_id ) {
    104                         $this->assertInternalType( 'int', $blog_id );
    105                         $prefix = $wpdb->get_blog_prefix( $blog_id );
    106 
    107                         // $get_all = false
    108                         $details = get_blog_details( $blog_id, false );
    109                         $this->assertEquals( $details, wp_cache_get( $blog_id . 'short', 'blog-details' ) );
    110 
    111                         // get_id_from_blogname(), see #20950
    112                         $this->assertEquals( $blog_id, get_id_from_blogname( $details->path ) );
    113                         $this->assertEquals( $blog_id, wp_cache_get( 'get_id_from_blogname_' . trim( $details->path, '/' ), 'blog-details' ) );
    114 
    115                         // get_blog_id_from_url()
    116                         $this->assertEquals( $blog_id, get_blog_id_from_url( $details->domain, $details->path ) );
    117                         $key = md5( $details->domain . $details->path );
    118                         $this->assertEquals( $blog_id, wp_cache_get( $key, 'blog-id-cache' ) );
    119 
    120                         // These are empty until get_blog_details() is called with $get_all = true
    121                         $this->assertEquals( false, wp_cache_get( $blog_id, 'blog-details' ) );
    122                         $key = md5( $details->domain . $details->path );
    123                         $this->assertEquals( false, wp_cache_get( $key, 'blog-lookup' ) );
    124 
    125                         // $get_all = true should propulate the full blog-details cache and the blog slug lookup cache
    126                         $details = get_blog_details( $blog_id, true );
    127                         $this->assertEquals( $details, wp_cache_get( $blog_id, 'blog-details' ) );
    128                         $this->assertEquals( $details, wp_cache_get( $key, 'blog-lookup' ) );
    129 
    130                         foreach ( $wpdb->tables( 'blog', false ) as $table ) {
    131                                 $suppress = $wpdb->suppress_errors();
    132                                 $table_fields = $wpdb->get_results( "DESCRIBE $prefix$table;" );
    133                                 $wpdb->suppress_errors( $suppress );
    134                                 $this->assertNotEmpty( $table_fields );
    135                                 $result = $wpdb->get_results( "SELECT * FROM $prefix$table LIMIT 1" );
    136                                 if ( 'commentmeta' == $table || 'links' == $table )
    137                                         $this->assertEmpty( $result );
    138                                 else
    139                                         $this->assertNotEmpty( $result );
    140                         }
    141                 }
    142 
    143                 // update the blog count cache to use get_blog_count()
    144                 wp_update_network_counts();
    145                 $this->assertEquals( 4 + 1, (int) get_blog_count() );
    146 
    147                 $drop_tables = false;
    148                 // delete all blogs
    149                 foreach ( $blog_ids as $blog_id ) {
    150                         // drop tables for every second blog
    151                         $drop_tables = ! $drop_tables;
    152                         $details = get_blog_details( $blog_id, false );
    153 
    154                         wpmu_delete_blog( $blog_id, $drop_tables );
    155 
    156                         $this->assertEquals( false, wp_cache_get( 'get_id_from_blogname_' . trim( $details->path, '/' ), 'blog-details' ) );
    157                         $this->assertEquals( false, wp_cache_get( $blog_id, 'blog-details' ) );
    158                         $this->assertEquals( false, wp_cache_get( $blog_id . 'short', 'blog-details' ) );
    159                         $key = md5( $details->domain . $details->path );
    160                         $this->assertEquals( false, wp_cache_get( $key, 'blog-lookup' ) );
    161                         $this->assertEquals( false, wp_cache_get( $key, 'blog-id-cache' ) );
    162 
    163                         $prefix = $wpdb->get_blog_prefix( $blog_id );
    164                         foreach ( $wpdb->tables( 'blog', false ) as $table ) {
    165                                 $suppress = $wpdb->suppress_errors();
    166                                 $table_fields = $wpdb->get_results( "DESCRIBE $prefix$table;" );
    167                                 $wpdb->suppress_errors( $suppress );
    168                                 if ( $drop_tables )
    169                                         $this->assertEmpty( $table_fields );
    170                                 else
    171                                         $this->assertNotEmpty( $table_fields, $prefix . $table );
    172                         }
    173                 }
    174 
    175                 // update the blog count cache to use get_blog_count()
    176                 wp_update_network_counts();
    177                 $this->assertEquals( 1, get_blog_count() );
    178         }
    179 
    180         function test_get_blogs_of_user() {
    181                 // Logged out users don't have blogs.
    182                 $this->assertEquals( array(), get_blogs_of_user( 0 ) );
    183 
    184                 $user1_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    185                 $blog_ids = $this->factory->blog->create_many( 10, array( 'user_id' => $user1_id ) );
    186 
    187                 foreach ( $blog_ids as $blog_id )
    188                         $this->assertInternalType( 'int', $blog_id );
    189 
    190                 $blogs_of_user = array_keys( get_blogs_of_user( $user1_id, false ) );
    191                 sort( $blogs_of_user );
    192                 $this->assertEquals ( array_merge( array( 1 ), $blog_ids), $blogs_of_user );
    193 
    194                 $this->assertTrue( remove_user_from_blog( $user1_id, 1 ) );
    195 
    196                 $blogs_of_user = array_keys( get_blogs_of_user( $user1_id, false ) );
    197                 sort( $blogs_of_user );
    198                 $this->assertEquals ( $blog_ids, $blogs_of_user );
    199 
    200                 foreach ( get_blogs_of_user( $user1_id, false ) as $blog ) {
    201                         $this->assertTrue( isset( $blog->userblog_id ) );
    202                         $this->assertTrue( isset( $blog->blogname ) );
    203                         $this->assertTrue( isset( $blog->domain ) );
    204                         $this->assertTrue( isset( $blog->path ) );
    205                         $this->assertTrue( isset( $blog->site_id ) );
    206                         $this->assertTrue( isset( $blog->siteurl ) );
    207                         $this->assertTrue( isset( $blog->archived ) );
    208                         $this->assertTrue( isset( $blog->spam ) );
    209                         $this->assertTrue( isset( $blog->deleted ) );
    210                 }
    211 
    212                 // Non-existent users don't have blogs.
    213                 wpmu_delete_user( $user1_id );
    214                 $user = new WP_User( $user1_id );
    215                 $this->assertFalse( $user->exists(), 'WP_User->exists' );
    216                 $this->assertEquals( array(), get_blogs_of_user( $user1_id ) );
    217         }
    218 
    219         /**
    220          * @expectedDeprecated is_blog_user
    221          */
    222         function test_is_blog_user() {
    223                 global $wpdb;
    224 
    225                 $user1_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    226 
    227                 $old_current = get_current_user_id();
    228                 wp_set_current_user( $user1_id );
    229 
    230                 $this->assertTrue( is_blog_user() );
    231                 $this->assertTrue( is_blog_user( $wpdb->blogid ) );
    232 
    233                 $blog_ids = array();
    234 
    235                 $blog_ids = $this->factory->blog->create_many( 5 );
    236                 foreach ( $blog_ids as $blog_id ) {
    237                         $this->assertInternalType( 'int', $blog_id );
    238                         $this->assertTrue( is_blog_user( $blog_id ) );
    239                         $this->assertTrue( remove_user_from_blog( $user1_id, $blog_id ) );
    240                         $this->assertFalse( is_blog_user( $blog_id ) );
    241                 }
    242 
    243                 wp_set_current_user( $old_current );
    244         }
    245 
    246         function test_is_user_member_of_blog() {
    247                 global $wpdb;
    248 
    249                 $user1_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    250 
    251                 $old_current = get_current_user_id();
    252                 wp_set_current_user( $user1_id );
    253 
    254                 $this->assertTrue( is_user_member_of_blog() );
    255                 $this->assertTrue( is_user_member_of_blog( 0, 0 ) );
    256                 $this->assertTrue( is_user_member_of_blog( 0, $wpdb->blogid ) );
    257                 $this->assertTrue( is_user_member_of_blog( $user1_id ) );
    258                 $this->assertTrue( is_user_member_of_blog( $user1_id, $wpdb->blogid ) );
    259 
    260                 $blog_ids = $this->factory->blog->create_many( 5 );
    261                 foreach ( $blog_ids as $blog_id ) {
    262                         $this->assertInternalType( 'int', $blog_id );
    263                         $this->assertTrue( is_user_member_of_blog( $user1_id, $blog_id ) );
    264                         $this->assertTrue( remove_user_from_blog( $user1_id, $blog_id ) );
    265                         $this->assertFalse( is_user_member_of_blog( $user1_id, $blog_id ) );
    266                 }
    267 
    268                 wpmu_delete_user( $user1_id );
    269                 $user = new WP_User( $user1_id );
    270                 $this->assertFalse( $user->exists(), 'WP_User->exists' );
    271                 $this->assertFalse( is_user_member_of_blog( $user1_id ), 'is_user_member_of_blog' );
    272 
    273                 wp_set_current_user( $old_current );
    274         }
    275 
    276         function test_active_network_plugins() {
    277                 $path = "hello.php";
    278 
    279                 // local activate, should be invisible for the network
    280                 activate_plugin($path); // $network_wide = false
    281                 $active_plugins = wp_get_active_network_plugins();
    282                 $this->assertEquals( Array(), $active_plugins );
    283 
    284                 add_action( 'deactivated_plugin', array( $this, '_helper_deactivate_hook' ) );
    285 
    286                 // activate the plugin sitewide
    287                 activate_plugin($path, '', $network_wide = true);
    288                 $active_plugins = wp_get_active_network_plugins();
    289                 $this->assertEquals( Array(WP_PLUGIN_DIR . '/hello.php'), $active_plugins );
    290 
    291                 //deactivate the plugin
    292                 deactivate_plugins($path);
    293                 $active_plugins = wp_get_active_network_plugins();
    294                 $this->assertEquals( Array(), $active_plugins );
    295 
    296                 $this->assertEquals( 1, $this->plugin_hook_count ); // testing actions and silent mode
    297 
    298                 activate_plugin($path, '', $network_wide = true);
    299                 deactivate_plugins($path, true); // silent
    300 
    301                 $this->assertEquals( 1, $this->plugin_hook_count ); // testing actions and silent mode
    302         }
    303 
    304         /**
    305          * @ticket 28651
    306          */
    307         function test_duplicate_network_active_plugin() {
    308                 $path = "hello.php";
    309                 $mock = new MockAction();
    310                 add_action( 'activate_' . $path, array ( $mock, 'action' ) );
    311 
    312                 // should activate on the first try
    313                 activate_plugin( $path, '', true );
    314                 $active_plugins = wp_get_active_network_plugins();
    315                 $this->assertCount( 1, $active_plugins );
    316                 $this->assertEquals( 1, $mock->get_call_count() );
    317 
    318                 // should do nothing on the second try
    319                 activate_plugin( $path, '', true );
    320                 $active_plugins = wp_get_active_network_plugins();
    321                 $this->assertCount( 1, $active_plugins );
    322                 $this->assertEquals( 1, $mock->get_call_count() );
    323 
    324                 remove_action( 'activate_' . $path, array ( $mock, 'action' ) );
    325         }
    326 
    327         function _helper_deactivate_hook() {
    328                 $this->plugin_hook_count++;
    329         }
    330 
    331         function test_get_user_count() {
    332                 // Refresh the cache
    333                 wp_update_network_counts();
    334                 $start_count = get_user_count();
    335 
    336                 // Only false for large networks as of 3.7
    337                 add_filter( 'enable_live_network_counts', '__return_false' );
    338                 $this->factory->user->create( array( 'role' => 'administrator' ) );
    339 
    340                 $count = get_user_count(); // No change, cache not refreshed
    341                 $this->assertEquals( $start_count, $count );
    342 
    343                 wp_update_network_counts(); // Magic happens here
    344 
    345                 $count = get_user_count();
    346                 $this->assertEquals( $start_count + 1, $count );
    347                 remove_filter( 'enable_live_network_counts', '__return_false' );
    348         }
    349 
    350         function test_wp_schedule_update_network_counts() {
    351                 $this->assertFalse(wp_next_scheduled('update_network_counts'));
    352 
    353                 // We can't use wp_schedule_update_network_counts() because WP_INSTALLING is set
    354                 wp_schedule_event(time(), 'twicedaily', 'update_network_counts');
    355 
    356                 $this->assertInternalType('int', wp_next_scheduled('update_network_counts'));
    357         }
    358 
    359         function test_users_can_register_signup_filter() {
    360 
    361                 $registration = get_site_option('registration');
    362                 $this->assertFalse( users_can_register_signup_filter() );
    363 
    364                 update_site_option('registration', 'all');
    365                 $this->assertTrue( users_can_register_signup_filter() );
    366 
    367                 update_site_option('registration', 'user');
    368                 $this->assertTrue( users_can_register_signup_filter() );
    369 
    370                 update_site_option('registration', 'none');
    371                 $this->assertFalse( users_can_register_signup_filter() );
    372         }
    373 
    374         /**
    375          * @expectedDeprecated get_dashboard_blog
    376          */
    377         function test_get_dashboard_blog() {
    378                 // if there is no dashboard blog set, current blog is used
    379                 $dashboard_blog = get_dashboard_blog();
    380                 $this->assertEquals( 1, $dashboard_blog->blog_id );
    381 
    382                 $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    383                 $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id ) );
    384                 $this->assertInternalType( 'int', $blog_id );
    385 
    386                 // set the dashboard blog to another one
    387                 update_site_option( 'dashboard_blog', $blog_id );
    388                 $dashboard_blog = get_dashboard_blog();
    389                 $this->assertEquals( $blog_id, $dashboard_blog->blog_id );
    390         }
    391 
    39227        function test_wpmu_log_new_registrations() {
    39328                global $wpdb;
    39429
     
    40338        }
    40439
    40540        /**
    406          * @ticket 18119
    407          */
    408         function test_upload_is_user_over_quota() {
    409                 $default_space_allowed = 100;
    410                 $echo = false;
    411 
    412                 $this->assertFalse( upload_is_user_over_quota( $echo ) );
    413                 $this->assertTrue( is_upload_space_available() );
    414 
    415                 update_site_option('upload_space_check_disabled', true);
    416                 $this->assertFalse( upload_is_user_over_quota( $echo ) );
    417                 $this->assertTrue( is_upload_space_available() );
    418 
    419                 update_site_option( 'blog_upload_space', 0 );
    420                 $this->assertFalse( upload_is_user_over_quota( $echo ) );
    421                 $this->assertEquals( $default_space_allowed, get_space_allowed() );
    422                 $this->assertTrue( is_upload_space_available() );
    423 
    424                 update_site_option('upload_space_check_disabled', false);
    425                 $this->assertFalse( upload_is_user_over_quota( $echo ) );
    426                 $this->assertTrue( is_upload_space_available() );
    427 
    428                 if ( defined( 'BLOGSUPLOADDIR' ) && ! file_exists( BLOGSUPLOADDIR ) )
    429                         $this->markTestSkipped( 'This test is broken when blogs.dir does not exist. ');
    430 
    431                 /*
    432                 This is broken when blogs.dir does not exist, as get_upload_space_available()
    433                 simply returns the value of blog_upload_space (converted to bytes), which would
    434                 be negative but still not false. When blogs.dir does exist, < 0 is returned as 0.
    435                 */
    436 
    437                 update_site_option( 'blog_upload_space', -1 );
    438                 $this->assertTrue( upload_is_user_over_quota( $echo ) );
    439                 $this->assertEquals( -1, get_space_allowed() );
    440                 $this->assertFalse( is_upload_space_available() );
    441 
    442                 update_option( 'blog_upload_space', 0 );
    443                 $this->assertFalse( upload_is_user_over_quota( $echo ) );
    444                 $this->assertEquals( $default_space_allowed, get_space_allowed() );
    445                 $this->assertTrue( is_upload_space_available() );
    446 
    447                 update_option( 'blog_upload_space', -1 );
    448                 $this->assertTrue( upload_is_user_over_quota( $echo ) );
    449                 $this->assertEquals( -1, get_space_allowed() );
    450                 $this->assertFalse( is_upload_space_available() );
    451         }
    452 
    453         function test_wpmu_update_blogs_date() {
    454                 global $wpdb;
    455 
    456                 wpmu_update_blogs_date();
    457 
    458                 // compare the update time with the current time, allow delta < 2
    459                 $blog = get_blog_details( $wpdb->blogid );
    460                 $current_time = time();
    461                 $time_difference = $current_time - strtotime( $blog->last_updated );
    462                 $this->assertLessThan( 2, $time_difference );
    463         }
    464 
    465         function test_getters(){
    466                 global $current_site;
    467 
    468                 $blog_id = get_current_blog_id();
    469                 $blog = get_blog_details( $blog_id );
    470                 $this->assertEquals( $blog_id, $blog->blog_id );
    471                 $this->assertEquals( $current_site->domain, $blog->domain );
    472                 $this->assertEquals( '/', $blog->path );
    473 
    474                 // Test defaulting to current blog
    475                 $this->assertEquals( $blog, get_blog_details() );
    476 
    477                 $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    478                 $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id, 'path' => '/test_blogname', 'title' => 'Test Title' ) );
    479                 $this->assertInternalType( 'int', $blog_id );
    480 
    481                 $this->assertEquals( 'http://' . $current_site->domain . $current_site->path . 'test_blogname/', get_blogaddress_by_name('test_blogname') );
    482 
    483                 $this->assertEquals( $blog_id, get_id_from_blogname('test_blogname') );
    484         }
    485 
    486         function _action_counter_cb( $blog_id ) {
    487                 global $test_action_counter;
    488                 $test_action_counter++;
    489         }
    490 
    491         function test_update_blog_details() {
    492                 global $test_action_counter;
    493 
    494                 $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    495                 $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id, 'path' => '/test_blogpath', 'title' => 'Test Title' ) );
    496                 $this->assertInternalType( 'int', $blog_id );
    497 
    498                 $result = update_blog_details( $blog_id, array('domain' => 'example.com', 'path' => 'my_path/') );
    499                 $this->assertTrue( $result );
    500 
    501                 $blog = get_blog_details( $blog_id );
    502                 $this->assertEquals( 'example.com', $blog->domain );
    503                 $this->assertEquals( 'my_path/', $blog->path );
    504                 $this->assertEquals( '0', $blog->spam );
    505 
    506                 $result = update_blog_details( $blog_id, array('domain' => 'example2.com','spam' => 1) );
    507                 $this->assertTrue( $result );
    508                 $blog = get_blog_details( $blog_id );
    509                 $this->assertEquals( 'example2.com', $blog->domain );
    510                 $this->assertEquals( 'my_path/', $blog->path );
    511                 $this->assertEquals( '1', $blog->spam );
    512 
    513                 $result = update_blog_details( $blog_id );
    514                 $this->assertFalse( $result );
    515                 $blog = get_blog_details( $blog_id );
    516                 $this->assertEquals( 'example2.com', $blog->domain );
    517                 $this->assertEquals( 'my_path/', $blog->path );
    518                 $this->assertEquals( '1', $blog->spam );
    519 
    520                 $test_action_counter = 0;
    521 
    522                 add_action( 'make_ham_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    523                 $result = update_blog_details( $blog_id, array( 'spam' => 0 ) );
    524                 $this->assertTrue( $result );
    525                 $blog = get_blog_details( $blog_id );
    526                 $this->assertEquals( '0', $blog->spam );
    527                 $this->assertEquals( 1, $test_action_counter );
    528 
    529                 // Same again
    530                 $result = update_blog_details( $blog_id, array( 'spam' => 0 ) );
    531                 $this->assertTrue( $result );
    532                 $blog = get_blog_details( $blog_id );
    533                 $this->assertEquals( '0', $blog->spam );
    534                 $this->assertEquals( 1, $test_action_counter );
    535                 remove_action( 'make_ham_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    536 
    537                 add_action( 'make_spam_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    538                 $result = update_blog_details( $blog_id, array( 'spam' => 1 ) );
    539                 $this->assertTrue( $result );
    540                 $blog = get_blog_details( $blog_id );
    541                 $this->assertEquals( '1', $blog->spam );
    542                 $this->assertEquals( 2, $test_action_counter );
    543 
    544                 // Same again
    545                 $result = update_blog_details( $blog_id, array( 'spam' => 1 ) );
    546                 $this->assertTrue( $result );
    547                 $blog = get_blog_details( $blog_id );
    548                 $this->assertEquals( '1', $blog->spam );
    549                 $this->assertEquals( 2, $test_action_counter );
    550                 remove_action( 'make_spam_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    551 
    552                 add_action( 'archive_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    553                 $result = update_blog_details( $blog_id, array( 'archived' => 1 ) );
    554                 $this->assertTrue( $result );
    555                 $blog = get_blog_details( $blog_id );
    556                 $this->assertEquals( '1', $blog->archived );
    557                 $this->assertEquals( 3, $test_action_counter );
    558 
    559                 // Same again
    560                 $result = update_blog_details( $blog_id, array( 'archived' => 1 ) );
    561                 $this->assertTrue( $result );
    562                 $blog = get_blog_details( $blog_id );
    563                 $this->assertEquals( '1', $blog->archived );
    564                 $this->assertEquals( 3, $test_action_counter );
    565                 remove_action( 'archive_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    566 
    567                 add_action( 'unarchive_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    568                 $result = update_blog_details( $blog_id, array( 'archived' => 0 ) );
    569                 $this->assertTrue( $result );
    570                 $blog = get_blog_details( $blog_id );
    571                 $this->assertEquals( '0', $blog->archived );
    572                 $this->assertEquals( 4, $test_action_counter );
    573 
    574                 // Same again
    575                 $result = update_blog_details( $blog_id, array( 'archived' => 0 ) );
    576                 $this->assertTrue( $result );
    577                 $blog = get_blog_details( $blog_id );
    578                 $this->assertEquals( '0', $blog->archived );
    579                 $this->assertEquals( 4, $test_action_counter );
    580                 remove_action( 'unarchive_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    581 
    582                 add_action( 'make_delete_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    583                 $result = update_blog_details( $blog_id, array( 'deleted' => 1 ) );
    584                 $this->assertTrue( $result );
    585                 $blog = get_blog_details( $blog_id );
    586                 $this->assertEquals( '1', $blog->deleted );
    587                 $this->assertEquals( 5, $test_action_counter );
    588 
    589                 // Same again
    590                 $result = update_blog_details( $blog_id, array( 'deleted' => 1 ) );
    591                 $this->assertTrue( $result );
    592                 $blog = get_blog_details( $blog_id );
    593                 $this->assertEquals( '1', $blog->deleted );
    594                 $this->assertEquals( 5, $test_action_counter );
    595                 remove_action( 'make_delete_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    596 
    597                 add_action( 'make_undelete_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    598                 $result = update_blog_details( $blog_id, array( 'deleted' => 0 ) );
    599                 $this->assertTrue( $result );
    600                 $blog = get_blog_details( $blog_id );
    601                 $this->assertEquals( '0', $blog->deleted );
    602                 $this->assertEquals( 6, $test_action_counter );
    603 
    604                 // Same again
    605                 $result = update_blog_details( $blog_id, array( 'deleted' => 0 ) );
    606                 $this->assertTrue( $result );
    607                 $blog = get_blog_details( $blog_id );
    608                 $this->assertEquals( '0', $blog->deleted );
    609                 $this->assertEquals( 6, $test_action_counter );
    610                 remove_action( 'make_undelete_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    611 
    612                 add_action( 'mature_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    613                 $result = update_blog_details( $blog_id, array( 'mature' => 1 ) );
    614                 $this->assertTrue( $result );
    615                 $blog = get_blog_details( $blog_id );
    616                 $this->assertEquals( '1', $blog->mature );
    617                 $this->assertEquals( 7, $test_action_counter );
    618 
    619                 // Same again
    620                 $result = update_blog_details( $blog_id, array( 'mature' => 1 ) );
    621                 $this->assertTrue( $result );
    622                 $blog = get_blog_details( $blog_id );
    623                 $this->assertEquals( '1', $blog->mature );
    624                 $this->assertEquals( 7, $test_action_counter );
    625                 remove_action( 'mature_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    626 
    627                 add_action( 'unmature_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    628                 $result = update_blog_details( $blog_id, array( 'mature' => 0 ) );
    629                 $this->assertTrue( $result );
    630                 $blog = get_blog_details( $blog_id );
    631                 $this->assertEquals( '0', $blog->mature );
    632                 $this->assertEquals( 8, $test_action_counter );
    633 
    634                 // Same again
    635                 $result = update_blog_details( $blog_id, array( 'mature' => 0 ) );
    636                 $this->assertTrue( $result );
    637                 $blog = get_blog_details( $blog_id );
    638                 $this->assertEquals( '0', $blog->mature );
    639                 $this->assertEquals( 8, $test_action_counter );
    640                 remove_action( 'unmature_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    641         }
    642 
    643         /**
    644          * Test fetching a blog that doesn't exist and again after it exists.
    645          *
    646          * @ticket 23405
    647          */
    648         function test_get_blog_details_blog_does_not_exist() {
    649                 global $wpdb;
    650 
    651                 $blog_id = $wpdb->get_var( "SELECT MAX(blog_id) FROM $wpdb->blogs" );
    652 
    653                 // An idosyncrancy of the unit tests is that the max blog_id gets reset
    654                 // to 1 in between test cases but picks up where it previously left off
    655                 // on the next insert. If 1 is reported, burn a blog create to get
    656                 // the max counter back in sync.
    657                 if ( 1 == $blog_id ) {
    658                         $blog_id = $this->factory->blog->create();
    659                 }
    660                 $blog_id++;
    661 
    662                 $this->assertFalse( wp_cache_get( $blog_id, 'blog-details' ) );
    663                 $this->assertFalse( get_blog_details( $blog_id ) );
    664                 $this->assertEquals( -1, wp_cache_get( $blog_id, 'blog-details' ) );
    665                 $this->assertFalse( get_blog_details( $blog_id ) );
    666                 $this->assertEquals( -1, wp_cache_get( $blog_id, 'blog-details' ) );
    667 
    668                 $this->assertEquals( $blog_id, $this->factory->blog->create() );
    669                 $this->assertFalse( wp_cache_get( $blog_id, 'blog-details' )  );
    670 
    671                 $blog = get_blog_details( $blog_id );
    672                 $this->assertEquals( $blog_id, $blog->blog_id );
    673                 $this->assertEquals( $blog, wp_cache_get( $blog_id, 'blog-details' ) );
    674 
    675                 wpmu_delete_blog( $blog_id );
    676                 $this->assertFalse( wp_cache_get( $blog_id, 'blog-details' ) );
    677                 $blog->deleted = '1';
    678                 $this->assertEQuals( $blog, get_blog_details( $blog_id ) );
    679                 $this->assertEquals( $blog, wp_cache_get( $blog_id, 'blog-details' ) );
    680 
    681                 wpmu_delete_blog( $blog_id, true );
    682                 $this->assertFalse( get_blog_details( $blog_id ) );
    683                 $this->assertEquals( -1, wp_cache_get( $blog_id, 'blog-details' ) );
    684         }
    685 
    686         function test_update_blog_status() {
    687                 global $test_action_counter;
    688 
    689                 $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    690                 $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id, 'path' => '/test_blogpath', 'title' => 'Test Title' ) );
    691                 $this->assertInternalType( 'int', $blog_id );
    692 
    693                 $test_action_counter = 0;
    694                 $count = 1;
    695 
    696                 add_action( 'make_ham_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    697                 $result = update_blog_status( $blog_id, 'spam', 0 );
    698                 $this->assertEquals( 0, $result );
    699                 $blog = get_blog_details( $blog_id );
    700                 $this->assertEquals( '0', $blog->spam );
    701                 $this->assertEquals( $count, $test_action_counter );
    702 
    703                 // Same again
    704                 $count++;
    705                 $result = update_blog_status( $blog_id, 'spam', 0 );
    706                 $this->assertEquals( 0, $result );
    707                 $blog = get_blog_details( $blog_id );
    708                 $this->assertEquals( '0', $blog->spam );
    709                 $this->assertEquals( $count, $test_action_counter );
    710                 remove_action( 'make_ham_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    711 
    712                 $count++;
    713                 add_action( 'make_spam_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    714                 $result = update_blog_status( $blog_id, 'spam', 1 );
    715                 $this->assertEquals( 1, $result );
    716                 $blog = get_blog_details( $blog_id );
    717                 $this->assertEquals( '1', $blog->spam );
    718                 $this->assertEquals( $count, $test_action_counter );
    719 
    720                 // Same again
    721                 $count++;
    722                 $result = update_blog_status( $blog_id, 'spam', 1 );
    723                 $this->assertEquals( 1, $result );
    724                 $blog = get_blog_details( $blog_id );
    725                 $this->assertEquals( '1', $blog->spam );
    726                 $this->assertEquals( $count, $test_action_counter );
    727                 remove_action( 'make_spam_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    728 
    729                 add_action( 'archive_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    730                 $count++;
    731                 $result = update_blog_status( $blog_id, 'archived', 1 );
    732                 $this->assertEquals( 1, $result );
    733                 $blog = get_blog_details( $blog_id );
    734                 $this->assertEquals( '1', $blog->archived );
    735                 $this->assertEquals( $count, $test_action_counter );
    736 
    737                 // Same again
    738                 $count++;
    739                 $result = update_blog_status( $blog_id, 'archived', 1 );
    740                 $this->assertEquals( 1, $result );
    741                 $blog = get_blog_details( $blog_id );
    742                 $this->assertEquals( '1', $blog->archived );
    743                 $this->assertEquals( $count, $test_action_counter );
    744                 remove_action( 'archive_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    745 
    746                 add_action( 'unarchive_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    747                 $count++;
    748                 $result = update_blog_status( $blog_id, 'archived', 0 );
    749                 $this->assertEquals( 0, $result );
    750                 $blog = get_blog_details( $blog_id );
    751                 $this->assertEquals( '0', $blog->archived );
    752                 $this->assertEquals( $count, $test_action_counter );
    753 
    754                 // Same again
    755                 $result = update_blog_status( $blog_id, 'archived', 0 );
    756                 $count++;
    757                 $this->assertEquals( 0, $result );
    758                 $blog = get_blog_details( $blog_id );
    759                 $this->assertEquals( '0', $blog->archived );
    760                 $this->assertEquals( $count, $test_action_counter );
    761                 remove_action( 'unarchive_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    762 
    763                 add_action( 'make_delete_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    764                 $count++;
    765                 $result = update_blog_status( $blog_id, 'deleted', 1 );
    766                 $this->assertEquals( 1, $result );
    767                 $blog = get_blog_details( $blog_id );
    768                 $this->assertEquals( '1', $blog->deleted );
    769                 $this->assertEquals( $count, $test_action_counter );
    770 
    771                 // Same again
    772                 $count++;
    773                 $result = update_blog_status( $blog_id, 'deleted', 1 );
    774                 $this->assertEquals( 1, $result );
    775                 $blog = get_blog_details( $blog_id );
    776                 $this->assertEquals( '1', $blog->deleted );
    777                 $this->assertEquals( $count, $test_action_counter );
    778                 remove_action( 'make_delete_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    779 
    780                 add_action( 'make_undelete_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    781                 $count++;
    782                 $result = update_blog_status( $blog_id, 'deleted', 0 );
    783                 $this->assertEquals( 0, $result );
    784                 $blog = get_blog_details( $blog_id );
    785                 $this->assertEquals( '0', $blog->deleted );
    786                 $this->assertEquals( $count, $test_action_counter );
    787 
    788                 // Same again
    789                 $count++;
    790                 $result = update_blog_status( $blog_id, 'deleted', 0 );
    791                 $this->assertEquals( 0, $result );
    792                 $blog = get_blog_details( $blog_id );
    793                 $this->assertEquals( '0', $blog->deleted );
    794                 $this->assertEquals( $count, $test_action_counter );
    795                 remove_action( 'make_undelete_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    796 
    797                 add_action( 'mature_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    798                 $count++;
    799                 $result = update_blog_status( $blog_id, 'mature', 1 );
    800                 $this->assertEquals( 1, $result );
    801                 $blog = get_blog_details( $blog_id );
    802                 $this->assertEquals( '1', $blog->mature );
    803                 $this->assertEquals( $count, $test_action_counter );
    804 
    805                 // Same again
    806                 $count++;
    807                 $result = update_blog_status( $blog_id, 'mature', 1 );
    808                 $this->assertEquals( 1, $result );
    809                 $blog = get_blog_details( $blog_id );
    810                 $this->assertEquals( '1', $blog->mature );
    811                 $this->assertEquals( $count, $test_action_counter );
    812                 remove_action( 'mature_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    813 
    814                 add_action( 'unmature_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    815                 $count++;
    816                 $result = update_blog_status( $blog_id, 'mature', 0 );
    817                 $this->assertEquals( 0, $result );
    818                 $blog = get_blog_details( $blog_id );
    819                 $this->assertEquals( '0', $blog->mature );
    820                 $this->assertEquals( $count, $test_action_counter );
    821 
    822                 // Same again
    823                 $count++;
    824                 $result = update_blog_status( $blog_id, 'mature', 0 );
    825                 $this->assertEquals( 0, $result );
    826                 $blog = get_blog_details( $blog_id );
    827                 $this->assertEquals( '0', $blog->mature );
    828                 $this->assertEquals( $count, $test_action_counter );
    829                 remove_action( 'unmature_blog', array( $this, '_action_counter_cb' ), 10, 1 );
    830 
    831                 add_action( 'update_blog_public', array( $this, '_action_counter_cb' ), 10, 1 );
    832                 $count++;
    833                 $result = update_blog_status( $blog_id, 'public', 0 );
    834                 $this->assertEquals( 0, $result );
    835                 $blog = get_blog_details( $blog_id );
    836                 $this->assertEquals( '0', $blog->public );
    837                 $this->assertEquals( $count, $test_action_counter );
    838 
    839                 // Same again
    840                 $count++;
    841                 $result = update_blog_status( $blog_id, 'public', 0 );
    842                 $this->assertEquals( 0, $result );
    843                 $blog = get_blog_details( $blog_id );
    844                 $this->assertEquals( '0', $blog->public );
    845                 $this->assertEquals( $count, $test_action_counter );
    846                 remove_action( 'update_blog_public', array( $this, '_action_counter_cb' ), 10, 1 );
    847 
    848                 add_action( 'update_blog_public', array( $this, '_action_counter_cb' ), 10, 1 );
    849                 $count++;
    850                 $result = update_blog_status( $blog_id, 'public', 1 );
    851                 $this->assertEquals( 1, $result );
    852                 $blog = get_blog_details( $blog_id );
    853                 $this->assertEquals( '1', $blog->public );
    854                 $this->assertEquals( $count, $test_action_counter );
    855 
    856                 // Same again
    857                 $count++;
    858                 $result = update_blog_status( $blog_id, 'public', 1 );
    859                 $this->assertEquals( 1, $result );
    860                 $blog = get_blog_details( $blog_id );
    861                 $this->assertEquals( '1', $blog->public );
    862                 $this->assertEquals( $count, $test_action_counter );
    863                 remove_action( 'update_blog_public', array( $this, '_action_counter_cb' ), 10, 1 );
    864 
    865                 // Updating a dummy field returns the value passed. Go fig.
    866                 $result = update_blog_status( $blog_id, 'doesnotexist', 1 );
    867                 $this->assertEquals( 1, $result );
    868         }
    869 
    870         function test_switch_restore_blog() {
    871                 global $_wp_switched_stack, $wpdb;
    872 
    873                 $this->assertEquals( array(), $_wp_switched_stack );
    874                 $this->assertFalse( ms_is_switched() );
    875                 $current_blog_id = get_current_blog_id();
    876                 $this->assertInternalType( 'integer', $current_blog_id );
    877 
    878                 wp_cache_set( 'switch-test', $current_blog_id, 'switch-test' );
    879                 $this->assertEquals( $current_blog_id, wp_cache_get( 'switch-test', 'switch-test' ) );
    880 
    881                 $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    882                 $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id, 'path' => '/test_blogpath', 'title' => 'Test Title' ) );
    883 
    884                 $cap_key = wp_get_current_user()->cap_key;
    885                 switch_to_blog( $blog_id );
    886                 $this->assertNotEquals( $cap_key, wp_get_current_user()->cap_key );
    887                 $this->assertEquals( array( $current_blog_id ), $_wp_switched_stack );
    888                 $this->assertTrue( ms_is_switched() );
    889                 $this->assertEquals( $blog_id, $wpdb->blogid );
    890                 $this->assertFalse( wp_cache_get( 'switch-test', 'switch-test' ) );
    891                 wp_cache_set( 'switch-test', $blog_id, 'switch-test' );
    892                 $this->assertEquals( $blog_id, wp_cache_get( 'switch-test', 'switch-test' ) );
    893 
    894                 switch_to_blog( $blog_id );
    895                 $this->assertEquals( array( $current_blog_id, $blog_id ), $_wp_switched_stack );
    896                 $this->assertTrue( ms_is_switched() );
    897                 $this->assertEquals( $blog_id, $wpdb->blogid );
    898                 $this->assertEquals( $blog_id, wp_cache_get( 'switch-test', 'switch-test' ) );
    899 
    900                 restore_current_blog();
    901                 $this->assertEquals( array( $current_blog_id ), $_wp_switched_stack );
    902                 $this->assertTrue( ms_is_switched() );
    903                 $this->assertEquals( $blog_id, $wpdb->blogid );
    904                 $this->assertEquals( $blog_id, wp_cache_get( 'switch-test', 'switch-test' ) );
    905 
    906                 restore_current_blog();
    907                 $this->assertEquals( $cap_key, wp_get_current_user()->cap_key );
    908                 $this->assertEquals( $current_blog_id, get_current_blog_id() );
    909                 $this->assertEquals( array(), $_wp_switched_stack );
    910                 $this->assertFalse( ms_is_switched() );
    911                 $this->assertEquals( $current_blog_id, wp_cache_get( 'switch-test', 'switch-test' ) );
    912 
    913                 $this->assertFalse( restore_current_blog() );
    914         }
    915 
    916         function test_get_blog_post() {
    917                 $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    918                 $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id, 'path' => '/test_blogpath', 'title' => 'Test Title' ) );
    919                 $current_blog_id = get_current_blog_id();
    920 
    921                 $post_id = $this->factory->post->create();
    922                 $this->assertInstanceOf( 'WP_Post', get_post( $post_id ) );
    923                 switch_to_blog( $blog_id );
    924                 $this->assertNull( get_post( $post_id ) );
    925                 $post = get_blog_post( $current_blog_id, $post_id );
    926                 $this->assertInstanceOf( 'WP_Post', $post );
    927                 $this->assertEquals( $post_id, $post->ID );
    928                 restore_current_blog();
    929 
    930                 wp_update_post( array( 'ID' => $post_id, 'post_title' => 'A Different Title' ) );
    931                 switch_to_blog( $blog_id );
    932                 $post = get_blog_post( $current_blog_id, $post_id );
    933                 // Make sure cache is good
    934                 $this->assertEquals( 'A Different Title', $post->post_title );
    935 
    936                 $post_id2 = $this->factory->post->create();
    937                 // Test get_blog_post() with currently active blog ID.
    938                 $post = get_blog_post( $blog_id, $post_id2 );
    939                 $this->assertInstanceOf( 'WP_Post', $post );
    940                 $this->assertEquals( $post_id2, $post->ID );
    941                 restore_current_blog();
    942         }
    943 
    944         /**
    94541         * @ticket 21570
    94642         */
    94743        function test_aggressiveness_of_is_email_address_unsafe() {
     
    97167                }
    97268
    97369        }
    974         /**
    975          * @ticket 21552
    976          * @ticket 23418
    977          */
    978         function test_sanitize_ms_options() {
    979                 update_site_option( 'illegal_names', array( '', 'Woo', '' ) );
    980                 update_site_option( 'limited_email_domains', array(  'woo', '', 'boo.com', 'foo.net.biz..'  ) );
    981                 update_site_option( 'banned_email_domains', array(  'woo', '', 'boo.com', 'foo.net.biz..'  ) );
    982 
    983                 $this->assertEquals( array( 'Woo' ), get_site_option( 'illegal_names' ) );
    984                 $this->assertEquals( array( 'woo', 'boo.com' ), get_site_option( 'limited_email_domains' ) );
    985                 $this->assertEquals( array( 'woo', 'boo.com' ), get_site_option( 'banned_email_domains' ) );
    986 
    987                 update_site_option( 'illegal_names', 'foo bar' );
    988                 update_site_option( 'limited_email_domains', "foo\nbar" );
    989                 update_site_option( 'banned_email_domains', "foo\nbar" );
    990 
    991                 $this->assertEquals( array( 'foo', 'bar' ), get_site_option( 'illegal_names' ) );
    992                 $this->assertEquals( array( 'foo', 'bar' ), get_site_option( 'limited_email_domains' ) );
    993                 $this->assertEquals( array( 'foo', 'bar' ), get_site_option( 'banned_email_domains' ) );
    994 
    995                 foreach ( array( 'illegal_names', 'limited_email_domains', 'banned_email_domains' ) as $option ) {
    996                         update_site_option( $option, array() );
    997                         $this->assertSame( '', get_site_option( $option ) );
    998                 }
    999         }
    1000 
    1001         function _domain_exists_cb( $exists, $domain, $path, $site_id ) {
    1002                 if ( 'foo' == $domain && 'bar/' == $path )
    1003                         return 1234;
    1004                 else
    1005                         return null;
    1006         }
    1007 
    1008         function test_domain_exists() {
    1009                 $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    1010                 $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id, 'path' => '/testdomainexists', 'title' => 'Test Title' ) );
    1011 
    1012                 $details = get_blog_details( $blog_id, false );
    1013 
    1014                 $this->assertEquals( $blog_id, domain_exists( $details->domain, $details->path ) );
    1015                 $this->assertEquals( $blog_id, domain_exists( $details->domain, $details->path, $details->site_id ) );
    1016                 $this->assertEquals( null, domain_exists( $details->domain, $details->path, 999 ) );
    1017                 $this->assertEquals( null, domain_exists( 'foo', 'bar' ) );
    1018 
    1019                 add_filter( 'domain_exists', array( $this, '_domain_exists_cb' ), 10, 4 );
    1020                 $this->assertEquals( 1234, domain_exists( 'foo', 'bar' ) );
    1021                 $this->assertEquals( null, domain_exists( 'foo', 'baz' ) );
    1022                 $this->assertEquals( null, domain_exists( 'bar', 'foo' ) );
    1023 
    1024                 // Make sure the same result is returned with or without a trailing slash
    1025                 $this->assertEquals( domain_exists( 'foo', 'bar' ), domain_exists( 'foo', 'bar/' ) );
    1026 
    1027                 remove_filter( 'domain_exists', array( $this, '_domain_exists_cb' ), 10, 4 );
    1028                 $this->assertEquals( null, domain_exists( 'foo', 'bar' ) );
    1029 
    1030                 wpmu_delete_blog( $blog_id );
    1031                 $this->assertEquals( $blog_id, domain_exists( $details->domain, $details->path ) );
    1032                 wpmu_delete_blog( $blog_id, true );
    1033                 $this->assertEquals( null, domain_exists( $details->domain, $details->path ) );
    1034         }
    1035 
    1036         function test_get_blog_id_from_url() {
    1037                 $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    1038                 $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id, 'path' => '/testdomainexists', 'title' => 'Test Title' ) );
    1039 
    1040                 $details = get_blog_details( $blog_id, false );
    1041 
    1042                 $this->assertEquals( $blog_id, get_blog_id_from_url( $details->domain, $details->path ) );
    1043                 $key = md5( $details->domain . $details->path );
    1044                 $this->assertEquals( $blog_id, wp_cache_get( $key, 'blog-id-cache' ) );
    1045 
    1046                 $this->assertEquals( 0, get_blog_id_from_url( $details->domain, 'foo' ) );
    1047 
    1048                 wpmu_delete_blog( $blog_id );
    1049                 $this->assertEquals( $blog_id, get_blog_id_from_url( $details->domain, $details->path ) );
    1050                 wpmu_delete_blog( $blog_id, true );
    1051 
    1052                 $this->assertEquals( false, wp_cache_get( $key, 'blog-id-cache' ) );
    1053                 $this->assertEquals( 0, get_blog_id_from_url( $details->domain, $details->path ) );
    1054         }
    1055 
    1056         function test_is_main_site() {
    1057                 $this->assertTrue( is_main_site() );
    1058                 $this->assertTrue( is_main_site( get_current_blog_id() ) );
    1059 
    1060                 $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    1061                 $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id ) );
    1062 
    1063                 switch_to_blog( $blog_id  );
    1064                 $this->assertFalse( is_main_site( $blog_id ) );
    1065                 $this->assertFalse( is_main_site( get_current_blog_id() ) );
    1066                 $this->assertFalse( is_main_site() );
    1067 
    1068                 restore_current_blog();
    1069         }
    1070 
    1071         function test_switch_upload_dir() {
    1072                 $this->assertTrue( is_main_site() );
    1073 
    1074                 $site = get_current_site();
    1075 
    1076                 $info = wp_upload_dir();
    1077                 $this->assertEquals( 'http://' . $site->domain . '/wp-content/uploads/' . gmstrftime('%Y/%m'), $info['url'] );
    1078                 $this->assertEquals( ABSPATH . 'wp-content/uploads/' . gmstrftime('%Y/%m'), $info['path'] );
    1079                 $this->assertEquals( gmstrftime('/%Y/%m'), $info['subdir'] );
    1080                 $this->assertEquals( '', $info['error'] );
    1081 
    1082                 $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    1083                 $blog_id = $this->factory->blog->create( array( 'user_id' => $user_id ) );
    1084 
    1085                 switch_to_blog( $blog_id );
    1086                 $info = wp_upload_dir();
    1087                 $this->assertEquals( 'http://' . $site->domain . '/wp-content/uploads/sites/' . get_current_blog_id() . '/' . gmstrftime('%Y/%m'), $info['url'] );
    1088                 $this->assertEquals( ABSPATH . 'wp-content/uploads/sites/' . get_current_blog_id() . '/' . gmstrftime('%Y/%m'), $info['path'] );
    1089                 $this->assertEquals( gmstrftime('/%Y/%m'), $info['subdir'] );
    1090                 $this->assertEquals( '', $info['error'] );
    1091                 restore_current_blog();
    1092 
    1093                 $info = wp_upload_dir();
    1094                 $this->assertEquals( 'http://' . $site->domain . '/wp-content/uploads/' . gmstrftime('%Y/%m'), $info['url'] );
    1095                 $this->assertEquals( ABSPATH . 'wp-content/uploads/' . gmstrftime('%Y/%m'), $info['path'] );
    1096                 $this->assertEquals( gmstrftime('/%Y/%m'), $info['subdir'] );
    1097                 $this->assertEquals( '', $info['error'] );
    1098 
    1099                 update_site_option( 'ms_files_rewriting', 1 );
    1100                 ms_upload_constants();
    1101 
    1102                 $user_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
    1103                 $blog_id2 = $this->factory->blog->create( array( 'user_id' => $user_id ) );
    1104                 $info = wp_upload_dir();
    1105                 $this->assertEquals( 'http://' . $site->domain . '/wp-content/uploads/' . gmstrftime('%Y/%m'), $info['url'] );
    1106                 $this->assertEquals( ABSPATH . 'wp-content/uploads/' . gmstrftime('%Y/%m'), $info['path'] );
    1107                 $this->assertEquals( gmstrftime('/%Y/%m'), $info['subdir'] );
    1108                 $this->assertEquals( '', $info['error'] );
    1109 
    1110                 switch_to_blog( $blog_id2 );
    1111                 $info2 = wp_upload_dir();
    1112                 $this->assertNotEquals( $info, $info2 );
    1113                 $this->assertEquals( get_option( 'siteurl' )  . '/wp-content/blogs.dir/' . get_current_blog_id() . '/files/' . gmstrftime('%Y/%m'), $info2['url'] );
    1114                 $this->assertEquals( ABSPATH . 'wp-content/blogs.dir/' . get_current_blog_id() . '/files/' . gmstrftime('%Y/%m'), $info2['path'] );
    1115                 $this->assertEquals( gmstrftime('/%Y/%m'), $info2['subdir'] );
    1116                 $this->assertEquals( '', $info2['error'] );
    1117                 restore_current_blog();
    1118                 update_site_option( 'ms_files_rewriting', 0 );
    1119         }
    1120 
    1121         /**
    1122          * @ticket 23192
    1123          */
    1124         function test_is_user_spammy() {
    1125                 $user_id = $this->factory->user->create( array(
    1126                         'role' => 'author',
    1127                         'user_login' => 'testuser1',
    1128                 ) );
    1129 
    1130                 $spam_username = (string) $user_id;
    1131                 $spam_user_id = $this->factory->user->create( array(
    1132                         'role' => 'author',
    1133                         'user_login' => $spam_username,
    1134                 ) );
    1135                 update_user_status( $spam_user_id, 'spam', '1' );
    1136 
    1137                 $this->assertTrue( is_user_spammy( $spam_username ) );
    1138                 $this->assertFalse( is_user_spammy( 'testuser1' ) );
    1139         }
    1140 
    1141         /**
    1142          * @ticket 14511
    1143          */
    1144         function test_wp_get_sites() {
    1145                 $this->factory->blog->create_many( 2, array( 'site_id' => 2, 'meta' => array( 'public' => 1 ) ) );
    1146                 $this->factory->blog->create_many( 3, array( 'site_id' => 3, 'meta' => array( 'public' => 0 ) ) );
    1147 
    1148                 // Expect no sites when passed an invalid network_id
    1149                 $this->assertCount( 0, wp_get_sites( array( 'network_id' => 0 ) ) );
    1150                 $this->assertCount( 0, wp_get_sites( array( 'network_id' => 4 ) ) );
    1151 
    1152                 // Expect 1 site when no network_id is specified - defaults to current network.
    1153                 $this->assertCount( 1, wp_get_sites() );
    1154                 // Expect 6 sites when network_id = null.
    1155                 $this->assertCount( 6, wp_get_sites( array( 'network_id' => null ) ) );
    1156 
    1157                 // Expect 1 site with a network_id of 1, 2 for network_id 2, 3 for 3
    1158                 $this->assertCount( 1, wp_get_sites( array( 'network_id' => 1 ) ) );
    1159                 $this->assertCount( 2, wp_get_sites( array( 'network_id' => 2 ) ) );
    1160                 $this->assertCount( 3, wp_get_sites( array( 'network_id' => 3 ) ) );
    1161 
    1162                 // Expect 6 sites when public is null (across all networks)
    1163                 $this->assertCount( 6, wp_get_sites( array( 'public' => null, 'network_id' => null ) ) );
    1164 
    1165                 // Expect 3 sites when public is 1
    1166                 $this->assertCount( 3, wp_get_sites( array( 'public' => 1, 'network_id' => null ) ) );
    1167 
    1168                 // Expect 2 sites when public is 1 and network_id is 2
    1169                 $this->assertCount( 2, wp_get_sites( array( 'network_id' => 2, 'public' => 1 ) ) );
    1170 
    1171                 // Expect no sites when public is set to 0 and network_id is not 3
    1172                 $this->assertCount( 0, wp_get_sites( array( 'network_id' => 1, 'public' => 0 ) ) );
    1173 
    1174                 // Test public + network_id = 3
    1175                 $this->assertCount( 0, wp_get_sites( array( 'network_id' => 3, 'public' => 1 ) ) );
    1176                 $this->assertCount( 3, wp_get_sites( array( 'network_id' => 3, 'public' => 0 ) ) );
    1177         }
    1178 
    1179         /**
    1180          * @ticket 14511
    1181          */
    1182         function test_wp_get_sites_limit_offset() {
    1183                 // Create 4 more sites (in addition to the default one)
    1184                 $this->factory->blog->create_many( 4, array( 'meta' => array( 'public' => 1 ) ) );
    1185 
    1186                 // Expect all 5 sites when no limit/offset is specified
    1187                 $this->assertCount( 5, wp_get_sites() );
    1188 
    1189                 // Expect first 2 sites when using limit
    1190                 $this->assertCount( 2, wp_get_sites( array( 'limit' => 2 ) ) );
    1191 
    1192                 // Expect only the last 3 sites when using offset of 2 (limit will default to 100)
    1193                 $this->assertCount( 3, wp_get_sites( array( 'offset' => 2 ) ) );
    1194 
    1195                 // Expect only the last 1 site when using offset of 4 and limit of 2
    1196                 $this->assertCount( 1, wp_get_sites( array( 'limit' => 2, 'offset' => 4 ) ) );
    1197 
    1198                 // Expect 0 sites when using an offset larger than the number of sites
    1199                 $this->assertCount( 0, wp_get_sites( array( 'offset' => 20 ) ) );
    1200         }
    1201 
    1202         /**
    1203          * @ticket 27003
    1204          */
    1205         function test_get_network_by_path() {
    1206                 global $wpdb;
    1207 
    1208                 $ids = array(
    1209                         'wordpress.org/'         => array( 'domain' => 'wordpress.org', 'path' => '/' ),
    1210                         'wordpress.org/one/'     => array( 'domain' => 'wordpress.org', 'path' => '/one/' ),
    1211                         'wordpress.net/'         => array( 'domain' => 'wordpress.net', 'path' => '/' ),
    1212                         'www.wordpress.net/'     => array( 'domain' => 'www.wordpress.net', 'path' => '/' ),
    1213                         'www.wordpress.net/two/' => array( 'domain' => 'www.wordpress.net', 'path' => '/two/' ),
    1214                         'wordpress.net/three/'   => array( 'domain' => 'wordpress.net', 'path' => '/three/' ),
    1215                 );
    1216 
    1217                 foreach ( $ids as &$id ) {
    1218                         $id = $this->factory->network->create( $id );
    1219                 }
    1220                 unset( $id );
    1221 
    1222                 $this->assertEquals( $ids['www.wordpress.net/'],
    1223                         get_network_by_path( 'www.wordpress.net', '/notapath/' )->id );
    1224 
    1225                 $this->assertEquals( $ids['www.wordpress.net/two/'],
    1226                         get_network_by_path( 'www.wordpress.net', '/two/' )->id );
    1227 
    1228                 // This should find /one/ despite the www.
    1229                 $this->assertEquals( $ids['wordpress.org/one/'],
    1230                         get_network_by_path( 'www.wordpress.org', '/one/' )->id );
    1231 
    1232                 // This should not find /one/ because the domains don't match.
    1233                 $this->assertEquals( $ids['wordpress.org/'],
    1234                         get_network_by_path( 'site1.wordpress.org', '/one/' )->id );
    1235 
    1236                 $this->assertEquals( $ids['wordpress.net/three/'],
    1237                         get_network_by_path( 'wordpress.net', '/three/' )->id );
    1238 
    1239                 $this->assertEquals( $ids['wordpress.net/'],
    1240                         get_network_by_path( 'wordpress.net', '/notapath/' )->id );
    1241 
    1242                 $this->assertEquals( $ids['wordpress.net/'],
    1243                         get_network_by_path( 'site1.wordpress.net', '/notapath/' )->id );
    1244 
    1245                 $this->assertEquals( $ids['wordpress.net/'],
    1246                         get_network_by_path( 'site1.wordpress.net', '/three/' )->id );
    1247         }
    1248 
    1249         /**
    1250          * @ticket 27003
    1251          * @ticket 27927
    1252          */
    1253         function test_get_site_by_path() {
    1254                 $ids = array(
    1255                         'wordpress.org/'              => array( 'domain' => 'wordpress.org',      'path' => '/' ),
    1256                         'wordpress.org/foo/'          => array( 'domain' => 'wordpress.org',      'path' => '/foo/' ),
    1257                         'wordpress.org/foo/bar/'      => array( 'domain' => 'wordpress.org',      'path' => '/foo/bar/' ),
    1258                         'make.wordpress.org/'         => array( 'domain' => 'make.wordpress.org', 'path' => '/' ),
    1259                         'make.wordpress.org/foo/'     => array( 'domain' => 'make.wordpress.org', 'path' => '/foo/' ),
    1260                         'www.w.org/'                  => array( 'domain' => 'www.w.org',          'path' => '/' ),
    1261                         'www.w.org/foo/'              => array( 'domain' => 'www.w.org',          'path' => '/foo/' ),
    1262                         'www.w.org/foo/bar/'          => array( 'domain' => 'www.w.org',          'path' => '/foo/bar/' ),
    1263                 );
    1264 
    1265                 foreach ( $ids as &$id ) {
    1266                         $id = $this->factory->blog->create( $id );
    1267                 }
    1268                 unset( $id );
    1269 
    1270                 $this->assertEquals( $ids['wordpress.org/'],
    1271                         get_site_by_path( 'wordpress.org', '/notapath/' )->blog_id );
    1272 
    1273                 $this->assertEquals( $ids['wordpress.org/'],
    1274                         get_site_by_path( 'www.wordpress.org', '/notapath/' )->blog_id );
    1275 
    1276                 $this->assertEquals( $ids['wordpress.org/foo/bar/'],
    1277                         get_site_by_path( 'wordpress.org', '/foo/bar/baz/' )->blog_id );
    1278 
    1279                 $this->assertEquals( $ids['wordpress.org/foo/bar/'],
    1280                         get_site_by_path( 'www.wordpress.org', '/foo/bar/baz/' )->blog_id );
    1281 
    1282                 $this->assertEquals( $ids['wordpress.org/foo/bar/'],
    1283                         get_site_by_path( 'wordpress.org', '/foo/bar/baz/', 3 )->blog_id );
    1284 
    1285                 $this->assertEquals( $ids['wordpress.org/foo/bar/'],
    1286                         get_site_by_path( 'www.wordpress.org', '/foo/bar/baz/', 3 )->blog_id );
    1287 
    1288                 $this->assertEquals( $ids['wordpress.org/foo/bar/'],
    1289                         get_site_by_path( 'wordpress.org', '/foo/bar/baz/', 2 )->blog_id );
    1290 
    1291                 $this->assertEquals( $ids['wordpress.org/foo/bar/'],
    1292                         get_site_by_path( 'www.wordpress.org', '/foo/bar/baz/', 2 )->blog_id );
    1293 
    1294                 $this->assertEquals( $ids['wordpress.org/foo/'],
    1295                         get_site_by_path( 'wordpress.org', '/foo/bar/baz/', 1 )->blog_id );
    1296 
    1297                 $this->assertEquals( $ids['wordpress.org/foo/'],
    1298                         get_site_by_path( 'www.wordpress.org', '/foo/bar/baz/', 1 )->blog_id );
    1299 
    1300                 $this->assertEquals( $ids['wordpress.org/'],
    1301                         get_site_by_path( 'wordpress.org', '/', 0 )->blog_id );
    1302 
    1303                 $this->assertEquals( $ids['wordpress.org/'],
    1304                         get_site_by_path( 'www.wordpress.org', '/', 0 )->blog_id );
    1305 
    1306                 $this->assertEquals( $ids['make.wordpress.org/foo/'],
    1307                         get_site_by_path( 'make.wordpress.org', '/foo/bar/baz/qux/', 4 )->blog_id );
    1308 
    1309                 $this->assertEquals( $ids['make.wordpress.org/foo/'],
    1310                         get_site_by_path( 'www.make.wordpress.org', '/foo/bar/baz/qux/', 4 )->blog_id );
    1311 
    1312                 $this->assertEquals( $ids['www.w.org/'],
    1313                         get_site_by_path( 'www.w.org', '/', 0 )->blog_id );
    1314 
    1315                 $this->assertEquals( $ids['www.w.org/'],
    1316                         get_site_by_path( 'www.w.org', '/notapath/' )->blog_id );
    1317 
    1318                 $this->assertEquals( $ids['www.w.org/foo/bar/'],
    1319                         get_site_by_path( 'www.w.org', '/foo/bar/baz/' )->blog_id );
    1320 
    1321                 $this->assertEquals( $ids['www.w.org/foo/'],
    1322                         get_site_by_path( 'www.w.org', '/foo/bar/baz/', 1 )->blog_id );
    1323 
    1324                 // A site installed with www will not be found by the root domain.
    1325                 $this->assertFalse( get_site_by_path( 'w.org', '/' ) );
    1326                 $this->assertFalse( get_site_by_path( 'w.org', '/notapath/' ) );
    1327                 $this->assertFalse( get_site_by_path( 'w.org', '/foo/bar/baz/' ) );
    1328                 $this->assertFalse( get_site_by_path( 'w.org', '/foo/bar/baz/', 1 ) );
    1329 
    1330                 // A site will not be found by its root domain when an invalid subdomain is requested.
    1331                 $this->assertFalse( get_site_by_path( 'invalid.wordpress.org', '/' ) );
    1332                 $this->assertFalse( get_site_by_path( 'invalid.wordpress.org', '/foo/bar/' ) );
    1333         }
    1334 
    1335         /**
    1336          * @ticket 20601
    1337          */
    1338         function test_user_member_of_blog() {
    1339                 global $wp_rewrite;
    1340 
    1341                 $this->factory->blog->create();
    1342                 $user_id = $this->factory->user->create();
    1343                 $this->factory->blog->create( array( 'user_id' => $user_id ) );
    1344 
    1345                 $blogs = get_blogs_of_user( $user_id );
    1346                 $this->assertCount( 2, $blogs );
    1347                 $first = reset( $blogs )->userblog_id;
    1348                 remove_user_from_blog( $user_id, $first );
    1349 
    1350                 $blogs = get_blogs_of_user( $user_id );
    1351                 $second = reset( $blogs )->userblog_id;
    1352                 $this->assertCount( 1, $blogs );
    1353 
    1354                 switch_to_blog( $first );
    1355                 $wp_rewrite->init();
    1356 
    1357                 $this->go_to( get_author_posts_url( $user_id ) );
    1358                 $this->assertQueryTrue( 'is_404' );
    1359 
    1360                 switch_to_blog( $second );
    1361                 $wp_rewrite->init();
    1362 
    1363                 $this->go_to( get_author_posts_url( $user_id ) );
    1364                 $this->assertQueryTrue( 'is_author', 'is_archive' );
    1365 
    1366                 add_user_to_blog( $first, $user_id, 'administrator' );
    1367                 $blogs = get_blogs_of_user( $user_id );
    1368                 $this->assertCount( 2, $blogs );
    1369 
    1370                 switch_to_blog( $first );
    1371                 $wp_rewrite->init();
    1372 
    1373                 $this->go_to( get_author_posts_url( $user_id ) );
    1374                 $this->assertQueryTrue( 'is_author', 'is_archive' );
    1375         }
    1376 
    1377         /**
    1378          * @ticket 27205
    1379          */
    1380         function test_granting_super_admins() {
    1381                 if ( isset( $GLOBALS['super_admins'] ) ) {
    1382                         $old_global = $GLOBALS['super_admins'];
    1383                         unset( $GLOBALS['super_admins'] );
    1384                 }
    1385 
    1386                 $user_id = $this->factory->user->create();
    1387 
    1388                 $this->assertFalse( is_super_admin( $user_id ) );
    1389                 $this->assertFalse( revoke_super_admin( $user_id ) );
    1390                 $this->assertTrue( grant_super_admin( $user_id ) );
    1391                 $this->assertTrue( is_super_admin( $user_id ) );
    1392                 $this->assertFalse( grant_super_admin( $user_id ) );
    1393                 $this->assertTrue( revoke_super_admin( $user_id ) );
    1394 
    1395                 // None of these operations should set the $super_admins global.
    1396                 $this->assertFalse( isset( $GLOBALS['super_admins'] ) );
    1397 
    1398                 // Try with two users.
    1399                 $second_user = $this->factory->user->create();
    1400                 $this->assertTrue( grant_super_admin( $user_id ) );
    1401                 $this->assertTrue( grant_super_admin( $second_user ) );
    1402                 $this->assertTrue( is_super_admin( $second_user ) );
    1403                 $this->assertTrue( is_super_admin( $user_id ) );
    1404                 $this->assertTrue( revoke_super_admin( $user_id ) );
    1405                 $this->assertTrue( revoke_super_admin( $second_user ) );
    1406 
    1407                 if ( isset( $old_global ) ) {
    1408                         $GLOBALS['super_admins'] = $old_global;
    1409                 }
    1410         }
    1411 
    1412         /**
    1413          * @ticket 27952
    1414          */
    1415         function test_posts_count() {
    1416                 $this->factory->post->create();
    1417                 $post2 = $this->factory->post->create();
    1418                 $this->assertEquals( 2, get_blog_details()->post_count );
    1419 
    1420                 wp_delete_post( $post2 );
    1421                 $this->assertEquals( 1, get_blog_details()->post_count );
    1422         }
    1423 
    1424         /**
    1425          * @ticket 26410
    1426          */
    1427         function test_blog_details_cache_invalidation() {
    1428                 update_option( 'blogname', 'foo' );
    1429                 $details = get_blog_details( get_current_blog_id() );
    1430                 $this->assertEquals( 'foo', $details->blogname );
    1431 
    1432                 update_option( 'blogname', 'bar' );
    1433                 $details = get_blog_details( get_current_blog_id() );
    1434                 $this->assertEquals( 'bar', $details->blogname );
    1435         }
    1436 
    1437         /**
    1438          * @ticket 29845
    1439          */
    1440         function test_get_blog_details() {
    1441                 $network_ids = array(
    1442                         'wordpress.org/'         => array( 'domain' => 'wordpress.org', 'path' => '/' ),
    1443                         'make.wordpress.org/'    => array( 'domain' => 'make.wordpress.org', 'path' => '/' ),
    1444                 );
    1445 
    1446                 foreach ( $network_ids as &$id ) {
    1447                         $id = $this->factory->network->create( $id );
    1448                 }
    1449                 unset( $id );
    1450 
    1451                 $ids = array(
    1452                         'wordpress.org/'              => array( 'domain' => 'wordpress.org',      'path' => '/',         'title' => 'Test 1', 'site_id' => $network_ids['wordpress.org/'] ),
    1453                         'wordpress.org/foo/'          => array( 'domain' => 'wordpress.org',      'path' => '/foo/',     'title' => 'Test 2', 'site_id' => $network_ids['wordpress.org/'] ),
    1454                         'wordpress.org/foo/bar/'      => array( 'domain' => 'wordpress.org',      'path' => '/foo/bar/', 'title' => 'Test 3', 'site_id' => $network_ids['wordpress.org/'] ),
    1455                         'make.wordpress.org/'         => array( 'domain' => 'make.wordpress.org', 'path' => '/',         'title' => 'Test 4', 'site_id' => $network_ids['make.wordpress.org/'] ),
    1456                         'make.wordpress.org/foo/'     => array( 'domain' => 'make.wordpress.org', 'path' => '/foo/',     'title' => 'Test 5', 'site_id' => $network_ids['make.wordpress.org/'] ),
    1457                 );
    1458 
    1459                 foreach ( $ids as &$id ) {
    1460                         $id = $this->factory->blog->create( $id );
    1461                 }
    1462                 unset( $id );
    1463 
    1464                 // Retrieve site details by passing only a blog ID.
    1465                 $site = get_blog_details( $ids['wordpress.org/'] );
    1466                 $this->assertEquals( $ids['wordpress.org/'], $site->blog_id );
    1467                 $this->assertEquals( 'Test 1', $site->blogname );
    1468 
    1469                 $site = get_blog_details( $ids['wordpress.org/foo/'] );
    1470                 $this->assertEquals( $ids['wordpress.org/foo/'], $site->blog_id );
    1471                 $this->assertEquals( 'Test 2', $site->blogname );
    1472 
    1473                 $site = get_blog_details( 999 );
    1474                 $this->assertFalse( $site );
    1475 
    1476                 // Retrieve site details by passing an array containing blog_id.
    1477                 $site = get_blog_details( array( 'blog_id' => $ids['wordpress.org/foo/bar/'] ) );
    1478                 $this->assertEquals( $ids['wordpress.org/foo/bar/'], $site->blog_id );
    1479                 $this->assertEquals( 'Test 3', $site->blogname );
    1480 
    1481                 $site = get_blog_details( array( 'blog_id' => $ids['make.wordpress.org/'] ) );
    1482                 $this->assertEquals( $ids['make.wordpress.org/'], $site->blog_id );
    1483                 $this->assertEquals( 'Test 4', $site->blogname );
    1484 
    1485                 $site = get_blog_details( array( 'blog_id' => 999 ) );
    1486                 $this->assertFalse( $site );
    1487 
    1488                 // Retrieve site details by passing an array containing domain and path.
    1489                 $site = get_blog_details( array( 'domain' => 'wordpress.org', 'path' => '/' ) );
    1490                 $this->assertEquals( $ids['wordpress.org/'], $site->blog_id );
    1491                 $this->assertEquals( 'Test 1', $site->blogname );
    1492 
    1493                 $site = get_blog_details( array( 'domain' => 'wordpress.org', 'path' => '/foo/' ) );
    1494                 $this->assertEquals( $ids['wordpress.org/foo/'], $site->blog_id );
    1495                 $this->assertEquals( 'Test 2', $site->blogname );
    1496 
    1497                 $site = get_blog_details( array( 'domain' => 'wordpress.org', 'path' => '/foo/bar/' ) );
    1498                 $this->assertEquals( $ids['wordpress.org/foo/bar/'], $site->blog_id );
    1499                 $this->assertEquals( 'Test 3', $site->blogname );
    1500 
    1501                 $site = get_blog_details( array( 'domain' => 'make.wordpress.org', 'path' => '/' ) );
    1502                 $this->assertEquals( $ids['make.wordpress.org/'], $site->blog_id );
    1503                 $this->assertEquals( 'Test 4', $site->blogname );
    1504 
    1505                 $site = get_blog_details( array( 'domain' => 'make.wordpress.org', 'path' => '/foo/' ) );
    1506                 $this->assertEquals( $ids['make.wordpress.org/foo/'], $site->blog_id );
    1507                 $this->assertEquals( 'Test 5', $site->blogname );
    1508 
    1509                 $site = get_blog_details( array( 'domain' => 'wordpress.org', 'path' => '/zxy/' ) );
    1510                 $this->assertFalse( $site );
    1511         }
    1512 
    1513         /**
    1514          * @ticket 27884
    1515          */
    1516         function test_multisite_bootstrap() {
    1517                 global $current_blog;
    1518 
    1519                 $network_ids = array(
    1520                         'wordpress.org/'         => array( 'domain' => 'wordpress.org', 'path' => '/' ),
    1521                         'make.wordpress.org/'    => array( 'domain' => 'make.wordpress.org', 'path' => '/' ),
    1522                 );
    1523 
    1524                 foreach ( $network_ids as &$id ) {
    1525                         $id = $this->factory->network->create( $id );
    1526                 }
    1527                 unset( $id );
    1528 
    1529                 $ids = array(
    1530                         'wordpress.org/'              => array( 'domain' => 'wordpress.org',      'path' => '/',         'site_id' => $network_ids['wordpress.org/'] ),
    1531                         'wordpress.org/foo/'          => array( 'domain' => 'wordpress.org',      'path' => '/foo/',     'site_id' => $network_ids['wordpress.org/'] ),
    1532                         'wordpress.org/foo/bar/'      => array( 'domain' => 'wordpress.org',      'path' => '/foo/bar/', 'site_id' => $network_ids['wordpress.org/'] ),
    1533                         'make.wordpress.org/'         => array( 'domain' => 'make.wordpress.org', 'path' => '/',         'site_id' => $network_ids['make.wordpress.org/'] ),
    1534                         'make.wordpress.org/foo/'     => array( 'domain' => 'make.wordpress.org', 'path' => '/foo/',     'site_id' => $network_ids['make.wordpress.org/'] ),
    1535                 );
    1536 
    1537                 foreach ( $ids as &$id ) {
    1538                         $id = $this->factory->blog->create( $id );
    1539                 }
    1540                 unset( $id );
    1541 
    1542                 $this->_setup_host_request( 'wordpress.org', '/' );
    1543                 $this->assertEquals( $ids['wordpress.org/'], $current_blog->blog_id );
    1544                 $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
    1545 
    1546                 $this->_setup_host_request( 'wordpress.org', '/2014/04/23/hello-world/' );
    1547                 $this->assertEquals( $ids['wordpress.org/'], $current_blog->blog_id );
    1548                 $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
    1549 
    1550                 $this->_setup_host_request( 'wordpress.org', '/sample-page/' );
    1551                 $this->assertEquals( $ids['wordpress.org/'], $current_blog->blog_id );
    1552                 $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
    1553 
    1554                 $this->_setup_host_request( 'wordpress.org', '/?p=1' );
    1555                 $this->assertEquals( $ids['wordpress.org/'], $current_blog->blog_id );
    1556                 $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
    1557 
    1558                 $this->_setup_host_request( 'wordpress.org', '/wp-admin/' );
    1559                 $this->assertEquals( $ids['wordpress.org/'], $current_blog->blog_id );
    1560                 $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
    1561 
    1562                 $this->_setup_host_request( 'wordpress.org', '/foo/' );
    1563                 $this->assertEquals( $ids['wordpress.org/foo/'], $current_blog->blog_id );
    1564                 $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
    1565 
    1566                 $this->_setup_host_request( 'wordpress.org', '/FOO/' );
    1567                 $this->assertEquals( $ids['wordpress.org/foo/'], $current_blog->blog_id );
    1568                 $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
    1569 
    1570                 $this->_setup_host_request( 'wordpress.org', '/foo/2014/04/23/hello-world/' );
    1571                 $this->assertEquals( $ids['wordpress.org/foo/'], $current_blog->blog_id );
    1572                 $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
    1573 
    1574                 $this->_setup_host_request( 'wordpress.org', '/foo/sample-page/' );
    1575                 $this->assertEquals( $ids['wordpress.org/foo/'], $current_blog->blog_id );
    1576                 $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
    1577 
    1578                 $this->_setup_host_request( 'wordpress.org', '/foo/?p=1' );
    1579                 $this->assertEquals( $ids['wordpress.org/foo/'], $current_blog->blog_id );
    1580                 $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
    1581 
    1582                 $this->_setup_host_request( 'wordpress.org', '/foo/wp-admin/' );
    1583                 $this->assertEquals( $ids['wordpress.org/foo/'], $current_blog->blog_id );
    1584                 $this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
    1585 
    1586                 // @todo not currently passing.
    1587                 //$this->_setup_host_request( 'wordpress.org', '/foo/bar/' );
    1588                 //$this->assertEquals( $ids['wordpress.org/foo/bar/'], $current_blog->blog_id );
    1589                 //$this->assertEquals( $network_ids['wordpress.org/'], $current_blog->site_id );
    1590 
    1591                 $this->_setup_host_request( 'make.wordpress.org', '/' );
    1592                 $this->assertEquals( $ids['make.wordpress.org/'], $current_blog->blog_id );
    1593                 $this->assertEquals( $network_ids['make.wordpress.org/'], $current_blog->site_id );
    1594 
    1595                 $this->_setup_host_request( 'make.wordpress.org', '/foo/' );
    1596                 $this->assertEquals( $ids['make.wordpress.org/foo/'], $current_blog->blog_id );
    1597                 $this->assertEquals( $network_ids['make.wordpress.org/'], $current_blog->site_id );
    1598 
    1599                 // Request the original tests domain and path to unpollute the stack.
    1600                 $this->_setup_host_request( WP_TESTS_DOMAIN, '/' );
    1601         }
    1602 
    1603         /**
    1604          * Reset various globals required for a 'clean' multisite boot.
    1605          *
    1606          * The $wpdb and $table_prefix globals are required for ms-settings.php to
    1607          * load properly.
    1608          *
    1609          * @param string $domain HTTP_HOST of the bootstrap request.
    1610          * @param string $path   REQUEST_URI of the boot strap request.
    1611          */
    1612         function _setup_host_request( $domain, $path ) {
    1613                 global $current_site, $current_blog, $table_prefix, $wpdb;
    1614 
    1615                 $table_prefix = WP_TESTS_TABLE_PREFIX;
    1616                 $current_site = $current_blog = null;
    1617                 $_SERVER['HTTP_HOST'] = $domain;
    1618                 $_SERVER['REQUEST_URI'] = $path;
    1619 
    1620                 include ABSPATH . '/wp-includes/ms-settings.php';
    1621         }
    162270}
    162371
    162472endif;
  • tests/phpunit/tests/option/blogOption.php

     
    1 <?php
    2 
    3 if ( is_multisite() ) :
    4 /**
    5  * @group option
    6  */
    7 class Tests_Option_BlogOption extends WP_UnitTestCase {
    8         protected $suppress = false;
    9 
    10         function setUp() {
    11                 global $wpdb;
    12                 parent::setUp();
    13                 $this->suppress = $wpdb->suppress_errors();
    14 
    15                 $_SERVER['REMOTE_ADDR'] = null;
    16         }
    17 
    18         function tearDown() {
    19                 global $wpdb;
    20                 parent::tearDown();
    21                 $wpdb->suppress_errors( $this->suppress );
    22         }
    23 
    24         function test_from_same_site() {
    25                 $key = rand_str();
    26                 $key2 = rand_str();
    27                 $value = rand_str();
    28                 $value2 = rand_str();
    29 
    30                 $this->assertFalse( get_blog_option( 1, 'doesnotexist' ) );
    31                 $this->assertFalse( get_option( 'doesnotexist' ) ); // check get_option()
    32 
    33                 $this->assertTrue( add_blog_option( 1, $key, $value ) );
    34                 // Assert all values of $blog_id that means the current or main blog (the same here).
    35                 $this->assertEquals( $value, get_blog_option( 1, $key ) );
    36                 $this->assertEquals( $value, get_blog_option( null, $key ) );
    37                 $this->assertEquals( $value, get_blog_option( '1', $key ) );
    38                 $this->assertEquals( $value, get_option( $key ) ); // check get_option()
    39 
    40                 $this->assertFalse( add_blog_option( 1, $key, $value ) );  // Already exists
    41                 $this->assertFalse( update_blog_option( 1, $key, $value ) );  // Value is the same
    42                 $this->assertTrue( update_blog_option( 1, $key, $value2 ) );
    43                 $this->assertEquals( $value2, get_blog_option( 1, $key ) );
    44                 $this->assertEquals( $value2, get_option( $key ) ); // check get_option()
    45                 $this->assertFalse( add_blog_option( 1, $key, $value ) );
    46                 $this->assertEquals( $value2, get_blog_option( 1, $key ) );
    47                 $this->assertEquals( $value2, get_option( $key ) ); // check get_option()
    48 
    49                 $this->assertTrue( delete_blog_option( 1, $key ) );
    50                 $this->assertFalse( get_blog_option( 1, $key ) );
    51                 $this->assertFalse( get_option( $key ) ); // check get_option()
    52                 $this->assertFalse( delete_blog_option( 1, $key ) );
    53                 $this->assertTrue( update_blog_option( 1, $key2, $value2 ) );
    54                 $this->assertEquals( $value2, get_blog_option( 1, $key2 ) );
    55                 $this->assertEquals( $value2, get_option( $key2 ) ); // check get_option()
    56                 $this->assertTrue( delete_blog_option( 1, $key2 ) );
    57                 $this->assertFalse( get_blog_option( 1, $key2 ) );
    58                 $this->assertFalse( get_option( $key2 ) ); // check get_option()
    59         }
    60 
    61         function test_from_same_site_with_null_blog_id() {
    62                 $key = rand_str();
    63                 $key2 = rand_str();
    64                 $value = rand_str();
    65                 $value2 = rand_str();
    66 
    67                 $this->assertFalse( get_blog_option( null, 'doesnotexist' ) );
    68                 $this->assertFalse( get_option( 'doesnotexist' ) ); // check get_option()
    69 
    70                 $this->assertTrue( add_blog_option( null, $key, $value ) );
    71                 // Assert all values of $blog_id that means the current or main blog (the same here).
    72                 $this->assertEquals( $value, get_blog_option( null, $key ) );
    73                 $this->assertEquals( $value, get_blog_option( null, $key ) );
    74                 $this->assertEquals( $value, get_option( $key ) ); // check get_option()
    75 
    76                 $this->assertFalse( add_blog_option( null, $key, $value ) );  // Already exists
    77                 $this->assertFalse( update_blog_option( null, $key, $value ) );  // Value is the same
    78                 $this->assertTrue( update_blog_option( null, $key, $value2 ) );
    79                 $this->assertEquals( $value2, get_blog_option( null, $key ) );
    80                 $this->assertEquals( $value2, get_option( $key ) ); // check get_option()
    81                 $this->assertFalse( add_blog_option( null, $key, $value ) );
    82                 $this->assertEquals( $value2, get_blog_option( null, $key ) );
    83                 $this->assertEquals( $value2, get_option( $key ) ); // check get_option()
    84 
    85                 $this->assertTrue( delete_blog_option( null, $key ) );
    86                 $this->assertFalse( get_blog_option( null, $key ) );
    87                 $this->assertFalse( get_option( $key ) ); // check get_option()
    88                 $this->assertFalse( delete_blog_option( null, $key ) );
    89                 $this->assertTrue( update_blog_option( null, $key2, $value2 ) );
    90                 $this->assertEquals( $value2, get_blog_option( null, $key2 ) );
    91                 $this->assertEquals( $value2, get_option( $key2 ) ); // check get_option()
    92                 $this->assertTrue( delete_blog_option( null, $key2 ) );
    93                 $this->assertFalse( get_blog_option( null, $key2 ) );
    94                 $this->assertFalse( get_option( $key2 ) ); // check get_option()
    95         }
    96 
    97         function test_with_another_site() {
    98                 global $current_site, $base;
    99 
    100                 $title = 'Fooblog';
    101                 $domain = 'blogoptiontest';
    102 
    103                 if ( is_subdomain_install() ) {
    104                         $newdomain = $domain . '.' . preg_replace( '|^www\.|', '', $current_site->domain );
    105                         $path = $base;
    106                 } else {
    107                         $newdomain = $current_site->domain;
    108                         $path = $base . $domain . '/';
    109                 }
    110 
    111                 $email = 'foo@foo.foo';
    112                 $password = wp_generate_password( 12, false );
    113                 $user_id = wpmu_create_user( $domain, $password, $email );
    114                 $this->assertInternalType( 'integer', $user_id );
    115 
    116                 $blog_id = wpmu_create_blog( $newdomain, $path, $title, $user_id , array( 'public' => 1 ), $current_site->id );
    117                 $this->assertInternalType( 'integer', $blog_id );
    118 
    119                 $key = rand_str();
    120                 $key2 = rand_str();
    121                 $value = rand_str();
    122                 $value2 = rand_str();
    123 
    124                 $this->assertFalse( get_blog_option( $blog_id, 'doesnotexist' ) );
    125                 //$this->assertFalse( get_option( 'doesnotexist' ) ); // check get_option()
    126 
    127                 $this->assertTrue( add_blog_option( $blog_id, $key, $value ) );
    128                 // Assert all values of $blog_id that means the current or main blog (the same here).
    129                 $this->assertEquals( $value, get_blog_option( $blog_id, $key ) );
    130                 $this->assertEquals( $value, get_blog_option( "$blog_id", $key ) );
    131                 //$this->assertEquals( $value, get_option( $key ) ); // check get_option()
    132 
    133                 $this->assertFalse( add_blog_option( $blog_id, $key, $value ) );  // Already exists
    134                 $this->assertFalse( update_blog_option( $blog_id, $key, $value ) );  // Value is the same
    135                 $this->assertTrue( update_blog_option( $blog_id, $key, $value2 ) );
    136                 $this->assertEquals( $value2, get_blog_option( $blog_id, $key ) );
    137                 //$this->assertEquals( $value2, get_option( $key ) ); // check get_option()
    138                 $this->assertFalse( add_blog_option( $blog_id, $key, $value ) );
    139                 $this->assertEquals( $value2, get_blog_option( $blog_id, $key ) );
    140                 //$this->assertEquals( $value2, get_option( $key ) ); // check get_option()
    141 
    142                 $this->assertTrue( delete_blog_option( $blog_id, $key ) );
    143                 $this->assertFalse( get_blog_option( $blog_id, $key ) );
    144                 //$this->assertFalse( get_option( $key ) ); // check get_option()
    145                 $this->assertFalse( delete_blog_option( $blog_id, $key ) );
    146                 $this->assertTrue( update_blog_option( $blog_id, $key2, $value2 ) );
    147                 $this->assertEquals( $value2, get_blog_option( $blog_id, $key2 ) );
    148                 //$this->assertEquals( $value2, get_option( $key2 ) ); // check get_option()
    149                 $this->assertTrue( delete_blog_option( $blog_id, $key2 ) );
    150                 $this->assertFalse( get_blog_option( $blog_id, $key2 ) );
    151                 //$this->assertFalse( get_option( $key2 ) ); // check get_option()
    152         }
    153 }
    154 endif;
    155  No newline at end of file
  • tests/phpunit/tests/option/multisite.php

     
    11<?php
    22
    33if ( is_multisite() ) :
     4
    45/**
     6 * Tests specific to network and site options in Multisite.
     7 *
    58 * @group option
     9 * @group ms-option
     10 * @group multisite
    611 */
    7 class Tests_Option_BlogOption extends WP_UnitTestCase {
     12class Tests_Multisite_Option extends WP_UnitTestCase {
    813        protected $suppress = false;
    914
    1015        function setUp() {
     
    150155                $this->assertFalse( get_blog_option( $blog_id, $key2 ) );
    151156                //$this->assertFalse( get_option( $key2 ) ); // check get_option()
    152157        }
     158
     159        /**
     160         * @group multisite
     161         */
     162        function test_site_notoptions() {
     163                global $wpdb;
     164                $notoptions_key = "{$wpdb->siteid}:notoptions";
     165
     166                $_notoptions = wp_cache_get( 'notoptions', 'site-options' );
     167                $this->assertEmpty( $_notoptions );
     168                $_notoptions1 = wp_cache_get( $notoptions_key, 'site-options' );
     169                $this->assertEmpty( $_notoptions1 );
     170
     171                get_site_option( 'burrito' );
     172
     173                $notoptions = wp_cache_get( 'notoptions', 'site-options' );
     174                $this->assertEmpty( $notoptions );
     175                $notoptions1 = wp_cache_get( $notoptions_key, 'site-options' );
     176                $this->assertNotEmpty( $notoptions1 );
     177        }
     178
     179        function test_users_can_register_signup_filter() {
     180
     181                $registration = get_site_option('registration');
     182                $this->assertFalse( users_can_register_signup_filter() );
     183
     184                update_site_option('registration', 'all');
     185                $this->assertTrue( users_can_register_signup_filter() );
     186
     187                update_site_option('registration', 'user');
     188                $this->assertTrue( users_can_register_signup_filter() );
     189
     190                update_site_option('registration', 'none');
     191                $this->assertFalse( users_can_register_signup_filter() );
     192        }
     193
     194        /**
     195         * @ticket 21552
     196         * @ticket 23418
     197         */
     198        function test_sanitize_ms_options() {
     199                update_site_option( 'illegal_names', array( '', 'Woo', '' ) );
     200                update_site_option( 'limited_email_domains', array(  'woo', '', 'boo.com', 'foo.net.biz..'  ) );
     201                update_site_option( 'banned_email_domains', array(  'woo', '', 'boo.com', 'foo.net.biz..'  ) );
     202
     203                $this->assertEquals( array( 'Woo' ), get_site_option( 'illegal_names' ) );
     204                $this->assertEquals( array( 'woo', 'boo.com' ), get_site_option( 'limited_email_domains' ) );
     205                $this->assertEquals( array( 'woo', 'boo.com' ), get_site_option( 'banned_email_domains' ) );
     206
     207                update_site_option( 'illegal_names', 'foo bar' );
     208                update_site_option( 'limited_email_domains', "foo\nbar" );
     209                update_site_option( 'banned_email_domains', "foo\nbar" );
     210
     211                $this->assertEquals( array( 'foo', 'bar' ), get_site_option( 'illegal_names' ) );
     212                $this->assertEquals( array( 'foo', 'bar' ), get_site_option( 'limited_email_domains' ) );
     213                $this->assertEquals( array( 'foo', 'bar' ), get_site_option( 'banned_email_domains' ) );
     214
     215                foreach ( array( 'illegal_names', 'limited_email_domains', 'banned_email_domains' ) as $option ) {
     216                        update_site_option( $option, array() );
     217                        $this->assertSame( '', get_site_option( $option ) );
     218                }
     219        }
    153220}
     221
    154222endif;
     223 No newline at end of file
  • tests/phpunit/tests/option/siteOption.php

     
    9090                $this->assertEquals( get_site_option( $option, $default ), $default );
    9191                $this->assertFalse( get_site_option( $option ) );
    9292        }
    93 
    94         /**
    95          * @group multisite
    96          */
    97         function test_site_notoptions() {
    98                 if ( ! is_multisite() ) {
    99                         $this->markTestSkipped( 'Should only run in multisite' );
    100                 }
    101 
    102                 global $wpdb;
    103                 $notoptions_key = "{$wpdb->siteid}:notoptions";
    104 
    105                 $_notoptions = wp_cache_get( 'notoptions', 'site-options' );
    106                 $this->assertEmpty( $_notoptions );
    107                 $_notoptions1 = wp_cache_get( $notoptions_key, 'site-options' );
    108                 $this->assertEmpty( $_notoptions1 );
    109 
    110                 get_site_option( 'burrito' );
    111 
    112                 $notoptions = wp_cache_get( 'notoptions', 'site-options' );
    113                 $this->assertEmpty( $notoptions );
    114                 $notoptions1 = wp_cache_get( $notoptions_key, 'site-options' );
    115                 $this->assertNotEmpty( $notoptions1 );
    116         }
    11793}
  • tests/phpunit/tests/user/multisite.php

     
     1<?php
     2
     3if ( is_multisite() ) :
     4
     5/**
     6 * Tests specific to users in multisite.
     7 *
     8 * @group user
     9 * @group ms-user
     10 * @group multisite
     11 */
     12class Tests_Multisite_User extends WP_UnitTestCase {
     13        protected $suppress = false;
     14
     15        function setUp() {
     16                global $wpdb;
     17                parent::setUp();
     18                $this->suppress = $wpdb->suppress_errors();
     19
     20                $_SERVER[ 'REMOTE_ADDR' ] = '';
     21        }
     22
     23        function tearDown() {
     24                global $wpdb;
     25                parent::tearDown();
     26                $wpdb->suppress_errors( $this->suppress );
     27        }
     28
     29        function test_remove_user_from_blog() {
     30                $user1 = $this->factory->user->create_and_get();
     31                $user2 = $this->factory->user->create_and_get();
     32
     33                $post_id = $this->factory->post->create( array( 'post_author' => $user1->ID ) );
     34
     35                remove_user_from_blog( $user1->ID, 1, $user2->ID );
     36
     37                $post = get_post( $post_id );
     38
     39                $this->assertNotEquals( $user1->ID, $post->post_author );
     40                $this->assertEquals( $user2->ID, $post->post_author );
     41        }
     42
     43        function test_get_blogs_of_user() {
     44                // Logged out users don't have blogs.
     45                $this->assertEquals( array(), get_blogs_of_user( 0 ) );
     46
     47                $user1_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
     48                $blog_ids = $this->factory->blog->create_many( 10, array( 'user_id' => $user1_id ) );
     49
     50                foreach ( $blog_ids as $blog_id )
     51                        $this->assertInternalType( 'int', $blog_id );
     52
     53                $blogs_of_user = array_keys( get_blogs_of_user( $user1_id, false ) );
     54                sort( $blogs_of_user );
     55                $this->assertEquals ( array_merge( array( 1 ), $blog_ids), $blogs_of_user );
     56
     57                $this->assertTrue( remove_user_from_blog( $user1_id, 1 ) );
     58
     59                $blogs_of_user = array_keys( get_blogs_of_user( $user1_id, false ) );
     60                sort( $blogs_of_user );
     61                $this->assertEquals ( $blog_ids, $blogs_of_user );
     62
     63                foreach ( get_blogs_of_user( $user1_id, false ) as $blog ) {
     64                        $this->assertTrue( isset( $blog->userblog_id ) );
     65                        $this->assertTrue( isset( $blog->blogname ) );
     66                        $this->assertTrue( isset( $blog->domain ) );
     67                        $this->assertTrue( isset( $blog->path ) );
     68                        $this->assertTrue( isset( $blog->site_id ) );
     69                        $this->assertTrue( isset( $blog->siteurl ) );
     70                        $this->assertTrue( isset( $blog->archived ) );
     71                        $this->assertTrue( isset( $blog->spam ) );
     72                        $this->assertTrue( isset( $blog->deleted ) );
     73                }
     74
     75                // Non-existent users don't have blogs.
     76                wpmu_delete_user( $user1_id );
     77                $user = new WP_User( $user1_id );
     78                $this->assertFalse( $user->exists(), 'WP_User->exists' );
     79                $this->assertEquals( array(), get_blogs_of_user( $user1_id ) );
     80        }
     81
     82        /**
     83         * @expectedDeprecated is_blog_user
     84         */
     85        function test_is_blog_user() {
     86                global $wpdb;
     87
     88                $user1_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
     89
     90                $old_current = get_current_user_id();
     91                wp_set_current_user( $user1_id );
     92
     93                $this->assertTrue( is_blog_user() );
     94                $this->assertTrue( is_blog_user( $wpdb->blogid ) );
     95
     96                $blog_ids = array();
     97
     98                $blog_ids = $this->factory->blog->create_many( 5 );
     99                foreach ( $blog_ids as $blog_id ) {
     100                        $this->assertInternalType( 'int', $blog_id );
     101                        $this->assertTrue( is_blog_user( $blog_id ) );
     102                        $this->assertTrue( remove_user_from_blog( $user1_id, $blog_id ) );
     103                        $this->assertFalse( is_blog_user( $blog_id ) );
     104                }
     105
     106                wp_set_current_user( $old_current );
     107        }
     108
     109        function test_is_user_member_of_blog() {
     110                global $wpdb;
     111
     112                $user1_id = $this->factory->user->create( array( 'role' => 'administrator' ) );
     113
     114                $old_current = get_current_user_id();
     115                wp_set_current_user( $user1_id );
     116
     117                $this->assertTrue( is_user_member_of_blog() );
     118                $this->assertTrue( is_user_member_of_blog( 0, 0 ) );
     119                $this->assertTrue( is_user_member_of_blog( 0, $wpdb->blogid ) );
     120                $this->assertTrue( is_user_member_of_blog( $user1_id ) );
     121                $this->assertTrue( is_user_member_of_blog( $user1_id, $wpdb->blogid ) );
     122
     123                $blog_ids = $this->factory->blog->create_many( 5 );
     124                foreach ( $blog_ids as $blog_id ) {
     125                        $this->assertInternalType( 'int', $blog_id );
     126                        $this->assertTrue( is_user_member_of_blog( $user1_id, $blog_id ) );
     127                        $this->assertTrue( remove_user_from_blog( $user1_id, $blog_id ) );
     128                        $this->assertFalse( is_user_member_of_blog( $user1_id, $blog_id ) );
     129                }
     130
     131                wpmu_delete_user( $user1_id );
     132                $user = new WP_User( $user1_id );
     133                $this->assertFalse( $user->exists(), 'WP_User->exists' );
     134                $this->assertFalse( is_user_member_of_blog( $user1_id ), 'is_user_member_of_blog' );
     135
     136                wp_set_current_user( $old_current );
     137        }
     138
     139        /**
     140         * @ticket 23192
     141         */
     142        function test_is_user_spammy() {
     143                $user_id = $this->factory->user->create( array(
     144                        'role' => 'author',
     145                        'user_login' => 'testuser1',
     146                ) );
     147
     148                $spam_username = (string) $user_id;
     149                $spam_user_id = $this->factory->user->create( array(
     150                        'role' => 'author',
     151                        'user_login' => $spam_username,
     152                ) );
     153                update_user_status( $spam_user_id, 'spam', '1' );
     154
     155                $this->assertTrue( is_user_spammy( $spam_username ) );
     156                $this->assertFalse( is_user_spammy( 'testuser1' ) );
     157        }
     158
     159        /**
     160         * @ticket 20601
     161         */
     162        function test_user_member_of_blog() {
     163                global $wp_rewrite;
     164
     165                $this->factory->blog->create();
     166                $user_id = $this->factory->user->create();
     167                $this->factory->blog->create( array( 'user_id' => $user_id ) );
     168
     169                $blogs = get_blogs_of_user( $user_id );
     170                $this->assertCount( 2, $blogs );
     171                $first = reset( $blogs )->userblog_id;
     172                remove_user_from_blog( $user_id, $first );
     173
     174                $blogs = get_blogs_of_user( $user_id );
     175                $second = reset( $blogs )->userblog_id;
     176                $this->assertCount( 1, $blogs );
     177
     178                switch_to_blog( $first );
     179                $wp_rewrite->init();
     180
     181                $this->go_to( get_author_posts_url( $user_id ) );
     182                $this->assertQueryTrue( 'is_404' );
     183
     184                switch_to_blog( $second );
     185                $wp_rewrite->init();
     186
     187                $this->go_to( get_author_posts_url( $user_id ) );
     188                $this->assertQueryTrue( 'is_author', 'is_archive' );
     189
     190                add_user_to_blog( $first, $user_id, 'administrator' );
     191                $blogs = get_blogs_of_user( $user_id );
     192                $this->assertCount( 2, $blogs );
     193
     194                switch_to_blog( $first );
     195                $wp_rewrite->init();
     196
     197                $this->go_to( get_author_posts_url( $user_id ) );
     198                $this->assertQueryTrue( 'is_author', 'is_archive' );
     199        }
     200
     201        /**
     202         * @ticket 27205
     203         */
     204        function test_granting_super_admins() {
     205                if ( isset( $GLOBALS['super_admins'] ) ) {
     206                        $old_global = $GLOBALS['super_admins'];
     207                        unset( $GLOBALS['super_admins'] );
     208                }
     209
     210                $user_id = $this->factory->user->create();
     211
     212                $this->assertFalse( is_super_admin( $user_id ) );
     213                $this->assertFalse( revoke_super_admin( $user_id ) );
     214                $this->assertTrue( grant_super_admin( $user_id ) );
     215                $this->assertTrue( is_super_admin( $user_id ) );
     216                $this->assertFalse( grant_super_admin( $user_id ) );
     217                $this->assertTrue( revoke_super_admin( $user_id ) );
     218
     219                // None of these operations should set the $super_admins global.
     220                $this->assertFalse( isset( $GLOBALS['super_admins'] ) );
     221
     222                // Try with two users.
     223                $second_user = $this->factory->user->create();
     224                $this->assertTrue( grant_super_admin( $user_id ) );
     225                $this->assertTrue( grant_super_admin( $second_user ) );
     226                $this->assertTrue( is_super_admin( $second_user ) );
     227                $this->assertTrue( is_super_admin( $user_id ) );
     228                $this->assertTrue( revoke_super_admin( $user_id ) );
     229                $this->assertTrue( revoke_super_admin( $second_user ) );
     230
     231                if ( isset( $old_global ) ) {
     232                        $GLOBALS['super_admins'] = $old_global;
     233                }
     234        }
     235
     236}
     237
     238endif ;
     239 No newline at end of file