WordPress.org

Make WordPress Core

Changeset 34033


Ignore:
Timestamp:
09/11/2015 01:50:40 AM (5 years ago)
Author:
boonebgorges
Message:

Move wp_delete_user() tests to their own file.

See #33800.

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

Legend:

Unmodified
Added
Removed
  • trunk/tests/phpunit/tests/user.php

    r33771 r34033  
    336336
    337337    /**
    338      * Test that usermeta cache is cleared after user deletion.
    339      *
    340      * @ticket 19500
    341      */
    342     function test_get_blogs_of_user() {
    343         // Logged out users don't have blogs.
    344         $this->assertEquals( array(), get_blogs_of_user( 0 ) );
    345 
    346         $user_id = $this->factory->user->create( array( 'role' => 'subscriber' ) );
    347         $blogs = get_blogs_of_user( $user_id );
    348         $this->assertEquals( array( 1 ), array_keys( $blogs ) );
    349 
    350         // Non-existent users don't have blogs.
    351         if ( is_multisite() )
    352             wpmu_delete_user( $user_id );
    353         else
    354             wp_delete_user( $user_id );
    355 
    356         $user = new WP_User( $user_id );
    357         $this->assertFalse( $user->exists(), 'WP_User->exists' );
    358         $this->assertEquals( array(), get_blogs_of_user( $user_id ) );
    359     }
    360 
    361     /**
    362      * Test that usermeta cache is cleared after user deletion.
    363      *
    364      * @ticket 19500
    365      */
    366     function test_is_user_member_of_blog() {
    367         $old_current = get_current_user_id();
    368 
    369         $this->assertSame( 0, $old_current );
    370 
    371         // test for "get current user" when not logged in
    372         $this->assertFalse( is_user_member_of_blog() );
    373 
    374         $user_id = $this->factory->user->create( array( 'role' => 'subscriber' ) );
    375         wp_set_current_user( $user_id );
    376 
    377         $this->assertTrue( is_user_member_of_blog() );
    378         $this->assertTrue( is_user_member_of_blog( 0, 0 ) );
    379         $this->assertTrue( is_user_member_of_blog( 0, get_current_blog_id() ) );
    380         $this->assertTrue( is_user_member_of_blog( $user_id ) );
    381         $this->assertTrue( is_user_member_of_blog( $user_id, get_current_blog_id() ) );
    382 
    383         // Will only remove the user from the current site in multisite; this is desired
    384         // and will achieve the desired effect with is_user_member_of_blog().
    385         wp_delete_user( $user_id );
    386 
    387         $this->assertFalse( is_user_member_of_blog( $user_id ) );
    388         $this->assertFalse( is_user_member_of_blog( $user_id, get_current_blog_id() ) );
    389 
    390         wp_set_current_user( $old_current );
    391     }
    392 
    393     /**
    394338     * ticket 19595
    395339     */
     
    462406    }
    463407
    464     function test_delete_user() {
    465         $user_id = $this->factory->user->create( array( 'role' => 'author' ) );
    466         $user = new WP_User( $user_id );
    467 
    468         $post = array(
    469             'post_author' => $user_id,
    470             'post_status' => 'publish',
    471             'post_content' => rand_str(),
    472             'post_title' => rand_str(),
    473             'post_type' => 'post',
    474         );
    475 
    476         // insert a post and make sure the ID is ok
    477         $post_id = wp_insert_post($post);
    478         $this->assertTrue(is_numeric($post_id));
    479         $this->assertTrue($post_id > 0);
    480 
    481         $post = get_post( $post_id );
    482         $this->assertEquals( $post_id, $post->ID );
    483 
    484         $post = array(
    485             'post_author' => $user_id,
    486             'post_status' => 'publish',
    487             'post_content' => rand_str(),
    488             'post_title' => rand_str(),
    489             'post_type' => 'nav_menu_item',
    490         );
    491 
    492         // insert a post and make sure the ID is ok
    493         $nav_id = wp_insert_post($post);
    494         $this->assertTrue(is_numeric($nav_id));
    495         $this->assertTrue($nav_id > 0);
    496 
    497         $post = get_post( $nav_id );
    498         $this->assertEquals( $nav_id, $post->ID );
    499 
    500         wp_delete_user( $user_id );
    501         $user = new WP_User( $user_id );
    502         if ( is_multisite() )
    503             $this->assertTrue( $user->exists() );
    504         else
    505             $this->assertFalse( $user->exists() );
    506 
    507         $this->assertNotNull( get_post( $post_id ) );
    508         $this->assertEquals( 'trash', get_post( $post_id )->post_status );
    509         // nav_menu_item is delete_with_user = false so the nav post should remain published.
    510         $this->assertNotNull( get_post( $nav_id ) );
    511         $this->assertEquals( 'publish', get_post( $nav_id )->post_status );
    512         wp_delete_post( $nav_id, true );
    513         $this->assertNull( get_post( $nav_id ) );
    514         wp_delete_post( $post_id, true );
    515         $this->assertNull( get_post( $post_id ) );
    516     }
    517 
    518408    /**
    519409     * @ticket 13317
     
    554444        $user = WP_User::get_data_by( 'id', 99999 );
    555445        $this->assertEquals( false, $user );
    556     }
    557 
    558     /**
    559      * @ticket 20447
    560      */
    561     function test_wp_delete_user_reassignment_clears_post_caches() {
    562         $user_id   = $this->factory->user->create();
    563         $reassign  = $this->factory->user->create();
    564         $post_id   = $this->factory->post->create( array( 'post_author' => $user_id ) );
    565 
    566         get_post( $post_id ); // Ensure this post is in the cache.
    567 
    568         wp_delete_user( $user_id, $reassign );
    569 
    570         $post = get_post( $post_id );
    571         $this->assertEquals( $reassign, $post->post_author );
    572446    }
    573447
  • trunk/tests/phpunit/tests/user/wpDeleteUser.php

    r34032 r34033  
    11<?php
    22
    3 // test functions in wp-includes/user.php
    43/**
    54 * @group user
    65 */
    7 class Tests_User extends WP_UnitTestCase {
    8 
    9     protected $user_data;
    10 
    11     function setUp() {
    12         parent::setUp();
    13 
    14         $this->user_data = array(
    15             'user_login' => 'user1',
    16             'user_nicename' => 'userone',
    17             'user_pass'  => 'password',
    18             'first_name' => 'John',
    19             'last_name'  => 'Doe',
    20             'display_name' => 'John Doe',
    21             'user_email' => 'blackburn@battlefield3.com',
    22             'user_url' => 'http://tacos.com'
    23         );
    24     }
    25 
    26     function test_get_users_of_blog() {
    27         // add one of each user role
    28         $nusers = array();
    29         foreach ( array('administrator', 'editor', 'author', 'contributor', 'subscriber' ) as $role ) {
    30             $id = $this->factory->user->create( array( 'role' => $role ) );
    31             $nusers[ $id ] = $id;
    32         }
    33 
    34         $user_list = get_users();
    35 
    36         // find the role of each user as returned by get_users_of_blog
    37         $found = array();
    38         foreach ( $user_list as $user ) {
    39             // only include the users we just created - there might be some others that existed previously
    40             if ( isset( $nusers[$user->ID] ) ) {
    41                 $found[ $user->ID] = $user->ID;
    42             }
    43         }
    44 
    45         // make sure every user we created was returned
    46         $this->assertEquals($nusers, $found);
    47     }
    48 
    49     // simple get/set tests for user_option functions
    50     function test_user_option() {
    51         $key = rand_str();
    52         $val = rand_str();
    53 
    54         $user_id = $this->factory->user->create( array( 'role' => 'author' ) );
    55 
    56         // get an option that doesn't exist
    57         $this->assertFalse(get_user_option($key, $user_id));
    58 
    59         // set and get
    60         update_user_option( $user_id, $key, $val );
    61         $this->assertEquals( $val, get_user_option($key, $user_id) );
    62 
    63         // change and get again
    64         $val2 = rand_str();
    65         update_user_option( $user_id, $key, $val2 );
    66         $this->assertEquals( $val2, get_user_option($key, $user_id) );
    67 
    68     }
    69 
    70     // simple tests for usermeta functions
    71     function test_usermeta() {
    72 
    73         $key = rand_str();
    74         $val = rand_str();
    75 
    76         $user_id = $this->factory->user->create( array( 'role' => 'author' ) );
    77 
    78         // get a meta key that doesn't exist
    79         $this->assertEquals( '', get_user_meta($user_id, $key, true));
    80 
    81         // set and get
    82         update_user_meta( $user_id, $key, $val );
    83         $this->assertEquals( $val, get_user_meta($user_id, $key, true) );
    84 
    85         // change and get again
    86         $val2 = rand_str();
    87         update_user_meta( $user_id, $key, $val2 );
    88         $this->assertEquals( $val2, get_user_meta($user_id, $key, true) );
    89 
    90         // delete and get
    91         delete_user_meta( $user_id, $key );
    92         $this->assertEquals( '', get_user_meta($user_id, $key, true) );
    93 
    94         // delete by key AND value
    95         update_user_meta( $user_id, $key, $val );
    96         // incorrect key: key still exists
    97         delete_user_meta( $user_id, $key, rand_str() );
    98         $this->assertEquals( $val, get_user_meta($user_id, $key, true) );
    99         // correct key: deleted
    100         delete_user_meta( $user_id, $key, $val );
    101         $this->assertEquals( '', get_user_meta($user_id, $key, true) );
    102 
    103     }
    104 
    105     // test usermeta functions in array mode
    106     function test_usermeta_array() {
    107         // some values to set
    108         $vals = array(
    109             rand_str() => 'val-'.rand_str(),
    110             rand_str() => 'val-'.rand_str(),
    111             rand_str() => 'val-'.rand_str(),
    112         );
    113 
    114         $user_id = $this->factory->user->create( array( 'role' => 'author' ) );
    115 
    116         // there is already some stuff in the array
    117         $this->assertTrue(is_array(get_user_meta($user_id)));
    118 
    119         foreach ($vals as $k=>$v)
    120             update_user_meta( $user_id, $k, $v );
    121 
    122         // get the complete usermeta array
    123         $out = get_user_meta($user_id);
    124 
    125         // for reasons unclear, the resulting array is indexed numerically; meta keys are not included anywhere.
    126         // so we'll just check to make sure our values are included somewhere.
    127         foreach ($vals as $k=>$v)
    128             $this->assertTrue(isset($out[$k]) && $out[$k][0] == $v);
    129 
    130         // delete one key and check again
    131         $keys = array_keys( $vals );
    132         $key_to_delete = array_pop( $keys );
    133         delete_user_meta($user_id, $key_to_delete);
    134         $out = get_user_meta($user_id);
    135         // make sure that key is excluded from the results
    136         foreach ($vals as $k=>$v) {
    137             if ($k == $key_to_delete)
    138                 $this->assertFalse(isset($out[$k]));
    139             else
    140             $this->assertTrue(isset($out[$k]) && $out[$k][0] == $v);
    141         }
    142     }
    143 
    144     // Test property magic functions for property get/set/isset.
    145     function test_user_properties() {
    146         $user_id = $this->factory->user->create( array( 'role' => 'author' ) );
    147         $user = new WP_User( $user_id );
    148 
    149         foreach ( $user->data as $key => $data ) {
    150             $this->assertEquals( $data, $user->$key );
    151         }
    152 
    153         $this->assertTrue( isset( $user->$key ) );
    154         $this->assertFalse( isset( $user->fooooooooo ) );
    155 
    156         $user->$key = 'foo';
    157         $this->assertEquals( 'foo', $user->$key );
    158         $this->assertEquals( 'foo', $user->data->$key );  // This will fail with WP < 3.3
    159 
    160         foreach ( (array) $user as $key => $value ) {
    161             $this->assertEquals( $value, $user->$key );
    162         }
    163     }
    164 
    165     // Test meta property magic functions for property get/set/isset.
    166     function test_user_meta_properties() {
    167         global $wpdb;
    168 
    169         $user_id = $this->factory->user->create( array( 'role' => 'author' ) );
    170         $user = new WP_User( $user_id );
    171 
    172         update_user_option( $user_id, 'foo', 'foo', true );
    173 
    174         $this->assertTrue( isset( $user->foo ) );
    175 
    176         $this->assertEquals( 'foo', $user->foo );
    177     }
    178 
    179     /**
    180      * @expectedDeprecated WP_User->id
    181      */
    182     function test_id_property_back_compat() {
    183         $user_id = $this->factory->user->create( array( 'role' => 'author' ) );
    184         $user = new WP_User( $user_id );
    185 
    186         $this->assertTrue( isset( $user->id ) );
    187         $this->assertEquals( $user->ID, $user->id );
    188         $user->id = 1234;
    189         $this->assertEquals( $user->ID, $user->id );
    190     }
    191 
    192     /**
    193      * ticket 19265
    194      */
    195     function test_user_level_property_back_compat() {
    196         $roles = array(
    197             'administrator' => 10,
    198             'editor' => 7,
    199             'author' => 2,
    200             'contributor' => 1,
    201             'subscriber' => 0,
    202         );
    203 
    204         foreach ( $roles as $role => $level ) {
    205             $user_id = $this->factory->user->create( array( 'role' => $role ) );
    206             $user = new WP_User( $user_id );
    207 
    208             $this->assertTrue( isset( $user->user_level ) );
    209             $this->assertEquals( $level, $user->user_level );
    210         }
    211     }
    212 
    213     function test_construction() {
    214         $user_id = $this->factory->user->create( array( 'role' => 'author' ) );
    215 
    216         $user = new WP_User( $user_id );
    217         $this->assertInstanceOf( 'WP_User', $user );
    218         $this->assertEquals( $user_id, $user->ID );
    219 
    220         $user2 = new WP_User( 0,  $user->user_login );
    221         $this->assertInstanceOf( 'WP_User', $user2 );
    222         $this->assertEquals( $user_id, $user2->ID );
    223         $this->assertEquals( $user->user_login, $user2->user_login );
    224 
    225         $user3 = new WP_User();
    226         $this->assertInstanceOf( 'WP_User', $user3 );
    227         $this->assertEquals( 0, $user3->ID );
    228         $this->assertFalse( isset( $user3->user_login ) );
    229 
    230         $user3->init( $user->data );
    231         $this->assertEquals( $user_id, $user3->ID );
    232 
    233         $user4 = new WP_User( $user->user_login );
    234         $this->assertInstanceOf( 'WP_User', $user4 );
    235         $this->assertEquals( $user_id, $user4->ID );
    236         $this->assertEquals( $user->user_login, $user4->user_login );
    237 
    238         $user5 = new WP_User( null, $user->user_login );
    239         $this->assertInstanceOf( 'WP_User', $user5 );
    240         $this->assertEquals( $user_id, $user5->ID );
    241         $this->assertEquals( $user->user_login, $user5->user_login );
    242 
    243         $user6 = new WP_User( $user );
    244         $this->assertInstanceOf( 'WP_User', $user6 );
    245         $this->assertEquals( $user_id, $user6->ID );
    246         $this->assertEquals( $user->user_login, $user6->user_login );
    247 
    248         $user7 = new WP_User( $user->data );
    249         $this->assertInstanceOf( 'WP_User', $user7 );
    250         $this->assertEquals( $user_id, $user7->ID );
    251         $this->assertEquals( $user->user_login, $user7->user_login );
    252     }
    253 
    254     function test_get() {
    255         $user_id = $this->factory->user->create( array(
    256             'role' => 'author',
    257             'user_login' => 'test_wp_user_get',
    258             'user_pass' => 'password',
    259             'user_email' => 'test@test.com',
    260         ) );
    261 
    262         $user = new WP_User( $user_id );
    263         $this->assertEquals( 'test_wp_user_get', $user->get( 'user_login' ) );
    264         $this->assertEquals( 'test@test.com', $user->get( 'user_email' ) );
    265         $this->assertEquals( 0, $user->get( 'use_ssl' ) );
    266         $this->assertEquals( '', $user->get( 'field_that_does_not_exist' ) );
    267 
    268         update_user_meta( $user_id, 'dashed-key', 'abcdefg' );
    269         $this->assertEquals( 'abcdefg', $user->get( 'dashed-key' ) );
    270     }
    271 
    272     function test_has_prop() {
    273         $user_id = $this->factory->user->create( array(
    274             'role' => 'author',
    275             'user_login' => 'test_wp_user_has_prop',
    276             'user_pass' => 'password',
    277             'user_email' => 'test2@test.com',
    278         ) );
    279 
    280         $user = new WP_User( $user_id );
    281         $this->assertTrue( $user->has_prop( 'user_email') );
    282         $this->assertTrue( $user->has_prop( 'use_ssl' ) );
    283         $this->assertFalse( $user->has_prop( 'field_that_does_not_exist' ) );
    284 
    285         update_user_meta( $user_id, 'dashed-key', 'abcdefg' );
    286         $this->assertTrue( $user->has_prop( 'dashed-key' ) );
    287     }
    288 
    289     function test_update_user() {
    290         $user_id = $this->factory->user->create( array(
    291             'role' => 'author',
    292             'user_login' => 'test_wp_update_user',
    293             'user_pass' => 'password',
    294             'user_email' => 'test3@test.com',
    295         ) );
    296         $user = new WP_User( $user_id );
    297 
    298         update_user_meta( $user_id, 'description', 'about me' );
    299         $this->assertEquals( 'about me', $user->get( 'description' ) );
    300 
    301         $user_data = array( 'ID' => $user_id, 'display_name' => 'test user' );
    302         wp_update_user( $user_data );
    303 
    304         $user = new WP_User( $user_id );
    305         $this->assertEquals( 'test user', $user->get( 'display_name' ) );
    306 
    307         // Make sure there is no collateral damage to fields not in $user_data
    308         $this->assertEquals( 'about me', $user->get( 'description' ) );
    309 
    310         // Pass as stdClass
    311         $user_data = array( 'ID' => $user_id, 'display_name' => 'a test user' );
    312         wp_update_user( (object) $user_data );
    313 
    314         $user = new WP_User( $user_id );
    315         $this->assertEquals( 'a test user', $user->get( 'display_name' ) );
    316 
    317         // Pass as WP_User
    318         $user = new WP_User( $user_id );
    319         $user->display_name = 'some test user';
    320         wp_update_user( $user );
    321 
    322         $user = new WP_User( $user_id );
    323         $this->assertEquals( 'some test user', $user->get( 'display_name' ) );
    324 
    325         // Test update of fields in _get_additional_user_keys()
    326         $user_data = array( 'ID' => $user_id, 'use_ssl' => 1, 'show_admin_bar_front' => 1,
    327                            'rich_editing' => 1, 'first_name' => 'first', 'last_name' => 'last',
    328                            'nickname' => 'nick', 'comment_shortcuts' => 'true', 'admin_color' => 'classic',
    329                            'description' => 'describe' );
    330         wp_update_user( $user_data );
    331 
    332         $user = new WP_User( $user_id );
    333         foreach ( $user_data as $key => $value )
    334             $this->assertEquals( $value, $user->get( $key ), $key );
    335     }
     6class Tests_User_WpDeleteUser extends WP_UnitTestCase {
    3367
    3378    /**
     
    36738        $old_current = get_current_user_id();
    36839
    369         $this->assertSame( 0, $old_current );
    370 
    371         // test for "get current user" when not logged in
    372         $this->assertFalse( is_user_member_of_blog() );
    373 
    37440        $user_id = $this->factory->user->create( array( 'role' => 'subscriber' ) );
    37541        wp_set_current_user( $user_id );
     
    38955
    39056        wp_set_current_user( $old_current );
    391     }
    392 
    393     /**
    394      * ticket 19595
    395      */
    396     function test_global_userdata() {
    397         global $userdata, $wpdb;
    398 
    399         $user_id = $this->factory->user->create( array( 'role' => 'subscriber' ) );
    400         wp_set_current_user( $user_id );
    401 
    402         $this->assertNotEmpty( $userdata );
    403         $this->assertInstanceOf( 'WP_User', $userdata );
    404         $this->assertEquals( $userdata->ID, $user_id );
    405         $prefix = $wpdb->get_blog_prefix();
    406         $cap_key = $prefix . 'capabilities';
    407         $this->assertTrue( isset( $userdata->$cap_key ) );
    408     }
    409 
    410     /**
    411      * ticket 19769
    412      */
    413     function test_global_userdata_is_null_when_logged_out() {
    414         global $userdata;
    415         wp_set_current_user(0);
    416         $this->assertNull( $userdata );
    417     }
    418 
    419     function test_exists() {
    420         $user_id = $this->factory->user->create( array( 'role' => 'author' ) );
    421         $user = new WP_User( $user_id );
    422 
    423         $this->assertTrue( $user->exists() );
    424 
    425         $user = new WP_User( 123456789 );
    426 
    427         $this->assertFalse( $user->exists() );
    428 
    429         $user = new WP_User( 0 );
    430 
    431         $this->assertFalse( $user->exists() );
    432     }
    433 
    434     function test_global_authordata() {
    435         global $authordata, $id;
    436 
    437         $old_post_id = $id;
    438 
    439         $user_id = $this->factory->user->create( array( 'role' => 'author' ) );
    440         $user = new WP_User( $user_id );
    441 
    442         $post = array(
    443             'post_author' => $user_id,
    444             'post_status' => 'publish',
    445             'post_content' => rand_str(),
    446             'post_title' => rand_str(),
    447             'post_type' => 'post'
    448         );
    449 
    450         // insert a post and make sure the ID is ok
    451         $post_id = wp_insert_post( $post );
    452         $this->assertTrue( is_numeric( $post_id ) );
    453 
    454         setup_postdata( get_post( $post_id ) );
    455 
    456         $this->assertNotEmpty( $authordata );
    457         $this->assertInstanceOf( 'WP_User', $authordata );
    458         $this->assertEquals( $authordata->ID, $user_id );
    459 
    460         if ( $old_post_id )
    461             setup_postdata( get_post( $old_post_id ) );
    46257    }
    46358
     
    517112
    518113    /**
    519      * @ticket 13317
    520      */
    521     function test_get_userdata() {
    522         $this->assertFalse( get_userdata( 0 ) );
    523         $this->assertFalse( get_userdata( '0' ) );
    524         $this->assertFalse( get_userdata( 'string' ) );
    525         $this->assertFalse( get_userdata( array( 'array' ) ) );
    526     }
    527 
    528     function test_user_get_data_by_id() {
    529         $user_id   = $this->factory->user->create();
    530 
    531         $user = WP_User::get_data_by( 'id', $user_id );
    532         $this->assertInstanceOf( 'stdClass', $user );
    533         $this->assertEquals( $user_id, $user->ID );
    534 
    535         // @ticket 23480
    536         $user = WP_User::get_data_by( 'id', -1 );
    537         $this->assertEquals( false, $user );
    538 
    539         $user = WP_User::get_data_by( 'id', 0 );
    540         $this->assertEquals( false, $user );
    541 
    542         $user = WP_User::get_data_by( 'id', null );
    543         $this->assertEquals( false, $user );
    544 
    545         $user = WP_User::get_data_by( 'id', '' );
    546         $this->assertEquals( false, $user );
    547 
    548         $user = WP_User::get_data_by( 'id', false );
    549         $this->assertEquals( false, $user );
    550 
    551         $user = WP_User::get_data_by( 'id', @$user->user_nicename );
    552         $this->assertEquals( false, $user );
    553 
    554         $user = WP_User::get_data_by( 'id', 99999 );
    555         $this->assertEquals( false, $user );
    556     }
    557 
    558     /**
    559114     * @ticket 20447
    560115     */
     
    571126        $this->assertEquals( $reassign, $post->post_author );
    572127    }
    573 
    574     /**
    575      * @ticket 21431
    576      */
    577     function test_count_many_users_posts() {
    578         $user_id_a = $this->factory->user->create( array( 'role' => 'author' ) );
    579         $user_id_b = $this->factory->user->create( array( 'role' => 'author' ) );
    580         $post_id_a = $this->factory->post->create( array( 'post_author' => $user_id_a ) );
    581         $post_id_b = $this->factory->post->create( array( 'post_author' => $user_id_b ) );
    582         $post_id_c = $this->factory->post->create( array( 'post_author' => $user_id_b, 'post_status' => 'private' ) );
    583 
    584         wp_set_current_user( $user_id_a );
    585         $counts = count_many_users_posts( array( $user_id_a, $user_id_b), 'post', false );
    586         $this->assertEquals( 1, $counts[$user_id_a] );
    587         $this->assertEquals( 1, $counts[$user_id_b] );
    588 
    589         $counts = count_many_users_posts( array( $user_id_a, $user_id_b), 'post', true );
    590         $this->assertEquals( 1, $counts[$user_id_a] );
    591         $this->assertEquals( 1, $counts[$user_id_b] );
    592 
    593         wp_set_current_user( $user_id_b );
    594         $counts = count_many_users_posts( array( $user_id_a, $user_id_b), 'post', false );
    595         $this->assertEquals( 1, $counts[$user_id_a] );
    596         $this->assertEquals( 2, $counts[$user_id_b] );
    597 
    598         $counts = count_many_users_posts( array( $user_id_a, $user_id_b), 'post', true );
    599         $this->assertEquals( 1, $counts[$user_id_a] );
    600         $this->assertEquals( 1, $counts[$user_id_b] );
    601     }
    602 
    603     /**
    604      * @ticket 22858
    605      */
    606     function test_wp_update_user_on_nonexistent_users() {
    607         $user_id = 1;
    608         // Find me a non-existent user ID.
    609         while ( get_userdata( $user_id ) )
    610             ++$user_id;
    611 
    612         // If this test fails, it will error out for calling the to_array() method on a non-object.
    613         $this->assertInstanceOf( 'WP_Error', wp_update_user( array( 'ID' => $user_id ) ) );
    614     }
    615 
    616     /**
    617      * @ticket 28315
    618      */
    619     function test_user_meta_error() {
    620         $id1 = wp_insert_user( array(
    621             'user_login' => rand_str(),
    622             'user_pass' => 'password',
    623             'user_email' => 'taco@burrito.com',
    624         ) );
    625         $this->assertEquals( $id1, email_exists( 'taco@burrito.com' ) );
    626 
    627         $id2 = wp_insert_user( array(
    628             'user_login' => rand_str(),
    629             'user_pass' => 'password',
    630             'user_email' => 'taco@burrito.com',
    631         ) );
    632 
    633         if ( ! defined( 'WP_IMPORTING' ) ) {
    634             $this->assertWPError( $id2 );
    635         }
    636 
    637         @update_user_meta( $id2, 'key', 'value' );
    638 
    639         $metas = array_keys( get_user_meta( 1 ) );
    640         $this->assertNotContains( 'key', $metas );
    641     }
    642 
    643     /**
    644      * @ticket 30647
    645      */
    646     function test_user_update_email_error() {
    647         $id1 = wp_insert_user( array(
    648             'user_login' => rand_str(),
    649             'user_pass'  => 'password',
    650             'user_email' => 'blackburn@battlefield3.com',
    651         ) );
    652         $this->assertEquals( $id1, email_exists( 'blackburn@battlefield3.com' ) );
    653 
    654         $id2 = wp_insert_user( array(
    655             'user_login' => rand_str(),
    656             'user_pass'  => 'password',
    657             'user_email' => 'miller@battlefield3.com',
    658         ) );
    659         $this->assertEquals( $id2, email_exists( 'miller@battlefield3.com' ) );
    660 
    661         if( ! is_wp_error( $id2 ) ){
    662             $return = wp_update_user( array(
    663                 'ID'         => $id2,
    664                 'user_email' => 'david@battlefield3.com',
    665             ) );
    666             $this->assertEquals( $id2, email_exists( 'david@battlefield3.com' ) );
    667 
    668             $return = wp_update_user( array(
    669                 'ID'         => $id2,
    670                 'user_email' => 'blackburn@battlefield3.com',
    671             ) );
    672             if ( ! defined( 'WP_IMPORTING' ) ) {
    673                 $this->assertWPError( $return );
    674             }
    675         }
    676     }
    677 
    678     /**
    679      * @ticket 29696
    680      */
    681     public function test_wp_insert_user_should_sanitize_user_nicename_parameter() {
    682         $user = $this->factory->user->create_and_get();
    683 
    684         $userdata = $user->to_array();
    685         $userdata['user_nicename'] = str_replace( '-', '.', $user->user_nicename );
    686         wp_insert_user( $userdata );
    687 
    688         $updated_user = new WP_User( $user->ID );
    689 
    690         $this->assertSame( $user->user_nicename, $updated_user->user_nicename );
    691     }
    692 
    693     function test_changing_email_invalidates_password_reset_key() {
    694         global $wpdb;
    695 
    696         $user = $this->factory->user->create_and_get();
    697         $wpdb->update( $wpdb->users, array( 'user_activation_key' => 'key' ), array( 'ID' => $user->ID ) );
    698         clean_user_cache( $user );
    699 
    700         $user = get_userdata( $user->ID );
    701         $this->assertEquals( 'key', $user->user_activation_key );
    702 
    703         // Check that changing something other than the email doesn't remove the key.
    704         $userdata = array(
    705             'ID'            => $user->ID,
    706             'user_nicename' => 'wat',
    707         );
    708         wp_update_user( $userdata );
    709 
    710         $user = get_userdata( $user->ID );
    711         $this->assertEquals( 'key', $user->user_activation_key );
    712 
    713         // Now check that changing the email does remove it.
    714         $userdata = array(
    715             'ID'            => $user->ID,
    716             'user_nicename' => 'cat',
    717             'user_email'    => 'foo@bar.dev',
    718         );
    719         wp_update_user( $userdata );
    720 
    721         $user = get_userdata( $user->ID );
    722         $this->assertEmpty( $user->user_activation_key );
    723     }
    724 
    725     public function test_search_users_login() {
    726         $id = $this->factory->user->create( $this->user_data );
    727 
    728         $users = get_users( array( 'search' => 'user1', 'fields' => 'ID' ) );
    729 
    730         $this->assertTrue( in_array( $id, $users ) );
    731     }
    732 
    733     public function test_search_users_url() {
    734         $id = $this->factory->user->create( $this->user_data );
    735 
    736         $users = get_users( array( 'search' => '*tacos*', 'fields' => 'ID' ) );
    737 
    738         $this->assertTrue( in_array( $id, $users ) );
    739     }
    740 
    741     public function test_search_users_email() {
    742         $id = $this->factory->user->create( $this->user_data );
    743 
    744         $users = get_users( array( 'search' => '*battle*', 'fields' => 'ID' ) );
    745 
    746         $this->assertTrue( in_array( $id, $users ) );
    747     }
    748 
    749     public function test_search_users_nicename() {
    750         $id = $this->factory->user->create( $this->user_data );
    751 
    752         $users = get_users( array( 'search' => '*one*', 'fields' => 'ID' ) );
    753 
    754         $this->assertTrue( in_array( $id, $users ) );
    755     }
    756 
    757     public function test_search_users_display_name() {
    758         $id = $this->factory->user->create( $this->user_data );
    759 
    760         $users = get_users( array( 'search' => '*Doe*', 'fields' => 'ID' ) );
    761 
    762         $this->assertTrue( in_array( $id, $users ) );
    763     }
    764 
    765     /**
    766      * @ticket 32158
    767      */
    768     function test_email_case() {
    769         // Create a test user with a lower-case email address.
    770         $user_id = $this->factory->user->create( array(
    771             'user_email' => 'test@test.com',
    772         ) );
    773 
    774         // Alter the case of the email address (which stays the same).
    775         $userdata = array(
    776             'ID' => $user_id,
    777             'user_email' => 'test@TEST.com',
    778         );
    779         $update = wp_update_user( $userdata );
    780 
    781         $this->assertEquals( $user_id, $update );
    782     }
    783 
    784     /**
    785      * @ticket 32158
    786      */
    787     function test_email_change() {
    788         // Create a test user.
    789         $user_id = $this->factory->user->create( array(
    790             'user_email' => 'test@test.com',
    791         ) );
    792 
    793         // Change the email address.
    794         $userdata = array(
    795             'ID' => $user_id,
    796             'user_email' => 'test2@test.com',
    797         );
    798         $update = wp_update_user( $userdata );
    799 
    800         // Was this successful?
    801         $this->assertEquals( $user_id, $update );
    802 
    803         // Verify that the email address has been updated.
    804         $user = get_userdata( $user_id );
    805         $this->assertEquals( $user->user_email, 'test2@test.com' );
    806     }
    807 
    808128}
Note: See TracChangeset for help on using the changeset viewer.