WordPress.org
Get WordPress

Make WordPress Core


Ignore:
Timestamp:
10/15/2015 12:10:45 AM (11 years ago)
Author:
wonderboymusic
Message:

Unit Tests: wrestle performance out of Tests_Auth by cloning the same user for a majority of the tests.

See #30017, #33968.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/tests/phpunit/tests/auth.php

    r33744 r35171  
    66 */
    77class Tests_Auth extends WP_UnitTestCase {
    8         var $user_id;
    9         var $wp_hasher;
     8        protected $user;
     9        protected static $_user;
     10        protected static $user_id;
     11        protected static $wp_hasher;
    1012
    1113        /**
    … …  
    1315         */
    1416        protected $nonce_failure_hook = 'wp_verify_nonce_failed';
     17
     18        static function setUpBeforeClass() {
     19                parent::setUpBeforeClass();
     20
     21                $factory = new WP_UnitTest_Factory();
     22
     23                self::$_user = $factory->user->create_and_get( array(
     24                        'user_login' => 'password-tests'
     25                ) );
     26
     27                self::$user_id = self::$_user->ID;
     28
     29                require_once( ABSPATH . WPINC . '/class-phpass.php' );
     30                self::$wp_hasher = new PasswordHash( 8, true );
     31        }
    1532
    1633        function setUp() {
    1734                parent::setUp();
    18                 $this->user_id = $this->factory->user->create();
    19 
    20                 require_once ABSPATH . WPINC . '/class-phpass.php';
    21                 $this->wp_hasher = new PasswordHash( 8, true );
     35
     36                $this->user = clone self::$_user;
    2237        }
    2338
    2439        function test_auth_cookie_valid() {
    25                 $cookie = wp_generate_auth_cookie( $this->user_id, time() + 3600, 'auth' );
    26                 $this->assertEquals( $this->user_id, wp_validate_auth_cookie( $cookie, 'auth' ) );
     40                $cookie = wp_generate_auth_cookie( self::$user_id, time() + 3600, 'auth' );
     41                $this->assertEquals( self::$user_id, wp_validate_auth_cookie( $cookie, 'auth' ) );
    2742        }
    2843
    … …  
    3146                // as an ajax test may have defined DOING_AJAX, failing the test.
    3247
    33                 $cookie = wp_generate_auth_cookie( $this->user_id, time() - 7200, 'auth' );
     48                $cookie = wp_generate_auth_cookie( self::$user_id, time() - 7200, 'auth' );
    3449                $this->assertEquals( false, wp_validate_auth_cookie( $cookie, 'auth' ), 'expired cookie' );
    3550
    36                 $cookie = wp_generate_auth_cookie( $this->user_id, time() + 3600, 'auth' );
     51                $cookie = wp_generate_auth_cookie( self::$user_id, time() + 3600, 'auth' );
    3752                $this->assertEquals( false, wp_validate_auth_cookie( $cookie, 'logged_in' ), 'wrong auth scheme' );
    3853
    39                 $cookie = wp_generate_auth_cookie( $this->user_id, time() + 3600, 'auth' );
     54                $cookie = wp_generate_auth_cookie( self::$user_id, time() + 3600, 'auth' );
    4055                list($a, $b, $c) = explode('|', $cookie);
    4156                $cookie = $a . '|' . ($b + 1) . '|' . $c;
    42                 $this->assertEquals( false, wp_validate_auth_cookie( $this->user_id, 'auth' ), 'altered cookie' );
     57                $this->assertEquals( false, wp_validate_auth_cookie( self::$user_id, 'auth' ), 'altered cookie' );
    4358        }
    4459
    4560        function test_auth_cookie_scheme() {
    4661                // arbitrary scheme name
    47                 $cookie = wp_generate_auth_cookie( $this->user_id, time() + 3600, 'foo' );
    48                 $this->assertEquals( $this->user_id, wp_validate_auth_cookie( $cookie, 'foo' ) );
     62                $cookie = wp_generate_auth_cookie( self::$user_id, time() + 3600, 'foo' );
     63                $this->assertEquals( self::$user_id, wp_validate_auth_cookie( $cookie, 'foo' ) );
    4964
    5065                // wrong scheme name - should fail
    51                 $cookie = wp_generate_auth_cookie( $this->user_id, time() + 3600, 'foo' );
     66                $cookie = wp_generate_auth_cookie( self::$user_id, time() + 3600, 'foo' );
    5267                $this->assertEquals( false, wp_validate_auth_cookie( $cookie, 'bar' ) );
    5368        }
    … …  
    5772         */
    5873        function test_password_trimming() {
    59                 $another_user = $this->factory->user->create( array( 'user_login' => 'password-triming-tests' ) );
    60 
    6174                $passwords_to_test = array(
    6275                        'a password with no trailing or leading spaces',
    … …  
    6780
    6881                foreach( $passwords_to_test as $password_to_test ) {
    69                         wp_set_password( $password_to_test, $another_user );
    70                         $authed_user = wp_authenticate( 'password-triming-tests', $password_to_test );
     82                        wp_set_password( $password_to_test, $this->user->ID );
     83                        $authed_user = wp_authenticate( $this->user->user_login, $password_to_test );
    7184
    7285                        $this->assertInstanceOf( 'WP_User', $authed_user );
    73                         $this->assertEquals( $another_user, $authed_user->ID );
     86                        $this->assertEquals( $this->user->ID, $authed_user->ID );
    7487                }
    7588        }
    … …  
    141154
    142155        function test_password_length_limit() {
    143                 $passwords = array(
    144                         str_repeat( 'a', 4095 ), // short
    145                         str_repeat( 'a', 4096 ), // limit
    146                         str_repeat( 'a', 4097 ), // long
    147                 );
    148 
    149                 $user_id = $this->factory->user->create( array( 'user_login' => 'password-length-test' ) );
    150 
    151                 wp_set_password( $passwords[1], $user_id );
    152                 $user = get_user_by( 'id', $user_id );
     156                $limit = str_repeat( 'a', 4096 );
     157
     158                wp_set_password( $limit, self::$user_id );
    153159                // phpass hashed password
    154                 $this->assertStringStartsWith( '$P$', $user->data->user_pass );
    155 
    156                 $user = wp_authenticate( 'password-length-test', $passwords[0] );
     160                $this->assertStringStartsWith( '$P$', $this->user->data->user_pass );
     161
     162                $user = wp_authenticate( $this->user->user_login, 'aaaaaaaa' );
    157163                // Wrong Password
    158164                $this->assertInstanceOf( 'WP_Error', $user );
    159165
    160                 $user = wp_authenticate( 'password-length-test', $passwords[1] );
     166                $user = wp_authenticate( $this->user->user_login, $limit );
    161167                $this->assertInstanceOf( 'WP_User', $user );
    162                 $this->assertEquals( $user_id, $user->ID );
    163 
    164                 $user = wp_authenticate( 'password-length-test', $passwords[2] );
     168                $this->assertEquals( self::$user_id, $user->ID );
     169
     170                // one char too many
     171                $user = wp_authenticate( $this->user->user_login, $limit . 'a' );
    165172                // Wrong Password
    166173                $this->assertInstanceOf( 'WP_Error', $user );
    167174
    168 
    169                 wp_set_password( $passwords[2], $user_id );
    170                 $user = get_user_by( 'id', $user_id );
     175                wp_set_password( $limit . 'a', self::$user_id );
     176                $user = get_user_by( 'id', self::$user_id );
    171177                // Password broken by setting it to be too long.
    172178                $this->assertEquals( '*', $user->data->user_pass );
    173179
    174                 $user = wp_authenticate( 'password-length-test', '*' );
    175                 $this->assertInstanceOf( 'WP_Error', $user );
    176 
    177                 $user = wp_authenticate( 'password-length-test', '*0' );
    178                 $this->assertInstanceOf( 'WP_Error', $user );
    179 
    180                 $user = wp_authenticate( 'password-length-test', '*1' );
    181                 $this->assertInstanceOf( 'WP_Error', $user );
    182 
    183                 $user = wp_authenticate( 'password-length-test', $passwords[0] );
     180                $user = wp_authenticate( $this->user->user_login, '*' );
     181                $this->assertInstanceOf( 'WP_Error', $user );
     182
     183                $user = wp_authenticate( $this->user->user_login, '*0' );
     184                $this->assertInstanceOf( 'WP_Error', $user );
     185
     186                $user = wp_authenticate( $this->user->user_login, '*1' );
     187                $this->assertInstanceOf( 'WP_Error', $user );
     188
     189                $user = wp_authenticate( $this->user->user_login, 'aaaaaaaa' );
    184190                // Wrong Password
    185191                $this->assertInstanceOf( 'WP_Error', $user );
    186192
    187                 $user = wp_authenticate( 'password-length-test', $passwords[1] );
     193                $user = wp_authenticate( $this->user->user_login, $limit );
    188194                // Wrong Password
    189195                $this->assertInstanceOf( 'WP_Error', $user );
    190196
    191                 $user = wp_authenticate( 'password-length-test', $passwords[2] );
     197                $user = wp_authenticate( $this->user->user_login, $limit . 'a' );
    192198                // Password broken by setting it to be too long.
    193199                $this->assertInstanceOf( 'WP_Error', $user );
    … …  
    201207
    202208                $key  = wp_generate_password( 20, false );
    203                 $user = $this->factory->user->create_and_get();
    204209                $wpdb->update( $wpdb->users, array(
    205                         'user_activation_key' => strtotime( '-1 hour' ) . ':' . $this->wp_hasher->HashPassword( $key ),
     210                        'user_activation_key' => strtotime( '-1 hour' ) . ':' . self::$wp_hasher->HashPassword( $key ),
    206211                ), array(
    207                         'ID' => $user->ID,
     212                        'ID' => $this->user->ID,
    208213                ) );
    209214
    210215                // A valid key should be accepted
    211                 $check = check_password_reset_key( $key, $user->user_login );
     216                $check = check_password_reset_key( $key, $this->user->user_login );
    212217                $this->assertInstanceOf( 'WP_User', $check );
    213                 $this->assertSame( $user->ID, $check->ID );
     218                $this->assertSame( $this->user->ID, $check->ID );
    214219
    215220                // An invalid key should be rejected
    216                 $check = check_password_reset_key( 'key', $user->user_login );
     221                $check = check_password_reset_key( 'key', $this->user->user_login );
    217222                $this->assertInstanceOf( 'WP_Error', $check );
    218223
    219224                // An empty key should be rejected
    220                 $check = check_password_reset_key( '', $user->user_login );
     225                $check = check_password_reset_key( '', $this->user->user_login );
    221226                $this->assertInstanceOf( 'WP_Error', $check );
    222227
    223228                // A truncated key should be rejected
    224229                $partial = substr( $key, 0, 10 );
    225                 $check = check_password_reset_key( $partial, $user->user_login );
     230                $check = check_password_reset_key( $partial, $this->user->user_login );
    226231                $this->assertInstanceOf( 'WP_Error', $check );
    227232        }
    … …  
    234239
    235240                $key  = wp_generate_password( 20, false );
    236                 $user = $this->factory->user->create_and_get();
    237241                $wpdb->update( $wpdb->users, array(
    238                         'user_activation_key' => strtotime( '-48 hours' ) . ':' . $this->wp_hasher->HashPassword( $key ),
     242                        'user_activation_key' => strtotime( '-48 hours' ) . ':' . self::$wp_hasher->HashPassword( $key ),
    239243                ), array(
    240                         'ID' => $user->ID,
     244                        'ID' => $this->user->ID,
    241245                ) );
    242246
    243247                // An expired but otherwise valid key should be rejected
    244                 $check = check_password_reset_key( $key, $user->user_login );
     248                $check = check_password_reset_key( $key, $this->user->user_login );
    245249                $this->assertInstanceOf( 'WP_Error', $check );
    246250        }
    … …  
    250254         */
    251255        function test_empty_user_activation_key_fails_key_check() {
    252                 global $wpdb;
    253 
    254                 $user = $this->factory->user->create_and_get();
    255 
    256256                // An empty user_activation_key should not allow any key to be accepted
    257                 $check = check_password_reset_key( 'key', $user->user_login );
     257                $check = check_password_reset_key( 'key', $this->user->user_login );
    258258                $this->assertInstanceOf( 'WP_Error', $check );
    259259
    260260                // An empty user_activation_key should not allow an empty key to be accepted
    261                 $check = check_password_reset_key( '', $user->user_login );
     261                $check = check_password_reset_key( '', $this->user->user_login );
    262262                $this->assertInstanceOf( 'WP_Error', $check );
    263263        }
    … …  
    272272
    273273                $key  = wp_generate_password( 20, false );
    274                 $user = $this->factory->user->create_and_get();
    275274                $wpdb->update( $wpdb->users, array(
    276                         'user_activation_key' => $this->wp_hasher->HashPassword( $key ),
     275                        'user_activation_key' => self::$wp_hasher->HashPassword( $key ),
    277276                ), array(
    278                         'ID' => $user->ID,
     277                        'ID' => $this->user->ID,
    279278                ) );
    280279
    281280                // A legacy user_activation_key should not be accepted
    282                 $check = check_password_reset_key( $key, $user->user_login );
     281                $check = check_password_reset_key( $key, $this->user->user_login );
    283282                $this->assertInstanceOf( 'WP_Error', $check );
    284283
    285284                // An empty key with a legacy user_activation_key should be rejected
    286                 $check = check_password_reset_key( '', $user->user_login );
     285                $check = check_password_reset_key( '', $this->user->user_login );
    287286                $this->assertInstanceOf( 'WP_Error', $check );
    288287        }
    … …  
    298297
    299298                $key  = wp_generate_password( 20, false );
    300                 $user = $this->factory->user->create_and_get();
    301299                $wpdb->update( $wpdb->users, array(
    302300                        'user_activation_key' => $key,
    303301                ), array(
    304                         'ID' => $user->ID,
     302                        'ID' => $this->user->ID,
    305303                ) );
    306304
    307305                // A plaintext user_activation_key should not allow an otherwise valid key to be accepted
    308                 $check = check_password_reset_key( $key, $user->user_login );
     306                $check = check_password_reset_key( $key, $this->user->user_login );
    309307                $this->assertInstanceOf( 'WP_Error', $check );
    310308
    311309                // A plaintext user_activation_key should not allow an empty key to be accepted
    312                 $check = check_password_reset_key( '', $user->user_login );
     310                $check = check_password_reset_key( '', $this->user->user_login );
    313311                $this->assertInstanceOf( 'WP_Error', $check );
    314312        }
Note: See TracChangeset for help on using the changeset viewer.