tests/phpunit/includes/UserTest.php

   1 <?php
   2
   3 define( 'NS_UNITTEST', 5600 );
   4 define( 'NS_UNITTEST_TALK', 5601 );
   5
   6 /**
   7  * @group Database
   8  */
   9 class UserTest extends MediaWikiTestCase {
  10         /**
  11          * @var User
  12          */
  13         protected $user;
  14
  15         protected function setUp() {
  16                 parent::setUp();
  17
  18                 $this->setMwGlobals( array(
  19                         'wgGroupPermissions' => array(),
  20                         'wgRevokePermissions' => array(),
  21                 ) );
  22
  23                 $this->setUpPermissionGlobals();
  24
  25                 $this->user = new User;
  26                 $this->user->addGroup( 'unittesters' );
  27         }
  28
  29         private function setUpPermissionGlobals() {
  30                 global $wgGroupPermissions, $wgRevokePermissions;
  31
  32                 # Data for regular $wgGroupPermissions test
  33                 $wgGroupPermissions['unittesters'] = array(
  34                         'test' => true,
  35                         'runtest' => true,
  36                         'writetest' => false,
  37                         'nukeworld' => false,
  38                 );
  39                 $wgGroupPermissions['testwriters'] = array(
  40                         'test' => true,
  41                         'writetest' => true,
  42                         'modifytest' => true,
  43                 );
  44
  45                 # Data for regular $wgRevokePermissions test
  46                 $wgRevokePermissions['formertesters'] = array(
  47                         'runtest' => true,
  48                 );
  49
  50                 # For the options test
  51                 $wgGroupPermissions['*'] = array(
  52                         'editmyoptions' => true,
  53                 );
  54         }
  55
  56         /**
  57          * @covers User::getGroupPermissions
  58          */
  59         public function testGroupPermissions() {
  60                 $rights = User::getGroupPermissions( array( 'unittesters' ) );
  61                 $this->assertContains( 'runtest', $rights );
  62                 $this->assertNotContains( 'writetest', $rights );
  63                 $this->assertNotContains( 'modifytest', $rights );
  64                 $this->assertNotContains( 'nukeworld', $rights );
  65
  66                 $rights = User::getGroupPermissions( array( 'unittesters', 'testwriters' ) );
  67                 $this->assertContains( 'runtest', $rights );
  68                 $this->assertContains( 'writetest', $rights );
  69                 $this->assertContains( 'modifytest', $rights );
  70                 $this->assertNotContains( 'nukeworld', $rights );
  71         }
  72
  73         /**
  74          * @covers User::getGroupPermissions
  75          */
  76         public function testRevokePermissions() {
  77                 $rights = User::getGroupPermissions( array( 'unittesters', 'formertesters' ) );
  78                 $this->assertNotContains( 'runtest', $rights );
  79                 $this->assertNotContains( 'writetest', $rights );
  80                 $this->assertNotContains( 'modifytest', $rights );
  81                 $this->assertNotContains( 'nukeworld', $rights );
  82         }
  83
  84         /**
  85          * @covers User::getRights
  86          */
  87         public function testUserPermissions() {
  88                 $rights = $this->user->getRights();
  89                 $this->assertContains( 'runtest', $rights );
  90                 $this->assertNotContains( 'writetest', $rights );
  91                 $this->assertNotContains( 'modifytest', $rights );
  92                 $this->assertNotContains( 'nukeworld', $rights );
  93         }
  94
  95         /**
  96          * @dataProvider provideGetGroupsWithPermission
  97          * @covers User::getGroupsWithPermission
  98          */
  99         public function testGetGroupsWithPermission( $expected, $right ) {
 100                 $result = User::getGroupsWithPermission( $right );
 101                 sort( $result );
 102                 sort( $expected );
 103
 104                 $this->assertEquals( $expected, $result, "Groups with permission $right" );
 105         }
 106
 107         public static function provideGetGroupsWithPermission() {
 108                 return array(
 109                         array(
 110                                 array( 'unittesters', 'testwriters' ),
 111                                 'test'
 112                         ),
 113                         array(
 114                                 array( 'unittesters' ),
 115                                 'runtest'
 116                         ),
 117                         array(
 118                                 array( 'testwriters' ),
 119                                 'writetest'
 120                         ),
 121                         array(
 122                                 array( 'testwriters' ),
 123                                 'modifytest'
 124                         ),
 125                 );
 126         }
 127
 128         /**
 129          * @dataProvider provideIPs
 130          * @covers User::isIP
 131          */
 132         public function testIsIP( $value, $result, $message ) {
 133                 $this->assertEquals( $this->user->isIP( $value ), $result, $message );
 134         }
 135
 136         public static function provideIPs() {
 137                 return array(
 138                         array( '', false, 'Empty string' ),
 139                         array( ' ', false, 'Blank space' ),
 140                         array( '10.0.0.0', true, 'IPv4 private 10/8' ),
 141                         array( '10.255.255.255', true, 'IPv4 private 10/8' ),
 142                         array( '192.168.1.1', true, 'IPv4 private 192.168/16' ),
 143                         array( '203.0.113.0', true, 'IPv4 example' ),
 144                         array( '2002:ffff:ffff:ffff:ffff:ffff:ffff:ffff', true, 'IPv6 example' ),
 145                         // Not valid IPs but classified as such by MediaWiki for negated asserting
 146                         // of whether this might be the identifier of a logged-out user or whether
 147                         // to allow usernames like it.
 148                         array( '300.300.300.300', true, 'Looks too much like an IPv4 address' ),
 149                         array( '203.0.113.xxx', true, 'Assigned by UseMod to cloaked logged-out users' ),
 150                 );
 151         }
 152
 153         /**
 154          * @dataProvider provideUserNames
 155          * @covers User::isValidUserName
 156          */
 157         public function testIsValidUserName( $username, $result, $message ) {
 158                 $this->assertEquals( $this->user->isValidUserName( $username ), $result, $message );
 159         }
 160
 161         public static function provideUserNames() {
 162                 return array(
 163                         array( '', false, 'Empty string' ),
 164                         array( ' ', false, 'Blank space' ),
 165                         array( 'abcd', false, 'Starts with small letter' ),
 166                         array( 'Ab/cd', false, 'Contains slash' ),
 167                         array( 'Ab cd', true, 'Whitespace' ),
 168                         array( '192.168.1.1', false, 'IP' ),
 169                         array( 'User:Abcd', false, 'Reserved Namespace' ),
 170                         array( '12abcd232', true, 'Starts with Numbers' ),
 171                         array( '?abcd', true, 'Start with ? mark' ),
 172                         array( '#abcd', false, 'Start with #' ),
 173                         array( 'Abcdകഖഗഘ', true, ' Mixed scripts' ),
 174                         array( 'ജോസ്‌തോമസ്', false, 'ZWNJ- Format control character' ),
 175                         array( 'Ab　cd', false, ' Ideographic space' ),
 176                         array( '300.300.300.300', false, 'Looks too much like an IPv4 address' ),
 177                         array( '302.113.311.900', false, 'Looks too much like an IPv4 address' ),
 178                         array( '203.0.113.xxx', false, 'Reserved for usage by UseMod for cloaked logged-out users' ),
 179                 );
 180         }
 181
 182         /**
 183          * Test, if for all rights a right- message exist,
 184          * which is used on Special:ListGroupRights as help text
 185          * Extensions and core
 186          */
 187         public function testAllRightsWithMessage() {
 188                 // Getting all user rights, for core: User::$mCoreRights, for extensions: $wgAvailableRights
 189                 $allRights = User::getAllRights();
 190                 $allMessageKeys = Language::getMessageKeysFor( 'en' );
 191
 192                 $rightsWithMessage = array();
 193                 foreach ( $allMessageKeys as $message ) {
 194                         // === 0: must be at beginning of string (position 0)
 195                         if ( strpos( $message, 'right-' ) === 0 ) {
 196                                 $rightsWithMessage[] = substr( $message, strlen( 'right-' ) );
 197                         }
 198                 }
 199
 200                 sort( $allRights );
 201                 sort( $rightsWithMessage );
 202
 203                 $this->assertEquals(
 204                         $allRights,
 205                         $rightsWithMessage,
 206                         'Each user rights (core/extensions) has a corresponding right- message.'
 207                 );
 208         }
 209
 210         /**
 211          * Test User::editCount
 212          * @group medium
 213          * @covers User::getEditCount
 214          */
 215         public function testEditCount() {
 216                 $user = User::newFromName( 'UnitTestUser' );
 217
 218                 if ( !$user->getId() ) {
 219                         $user->addToDatabase();
 220                 }
 221
 222                 // let the user have a few (3) edits
 223                 $page = WikiPage::factory( Title::newFromText( 'Help:UserTest_EditCount' ) );
 224                 for ( $i = 0; $i < 3; $i++ ) {
 225                         $page->doEdit( (string)$i, 'test', 0, false, $user );
 226                 }
 227
 228                 $user->clearInstanceCache();
 229                 $this->assertEquals(
 230                         3,
 231                         $user->getEditCount(),
 232                         'After three edits, the user edit count should be 3'
 233                 );
 234
 235                 // increase the edit count and clear the cache
 236                 $user->incEditCount();
 237
 238                 $user->clearInstanceCache();
 239                 $this->assertEquals(
 240                         4,
 241                         $user->getEditCount(),
 242                         'After increasing the edit count manually, the user edit count should be 4'
 243                 );
 244         }
 245
 246         /**
 247          * Test changing user options.
 248          * @covers User::setOption
 249          * @covers User::getOption
 250          */
 251         public function testOptions() {
 252                 $user = User::newFromName( 'UnitTestUser' );
 253
 254                 if ( !$user->getId() ) {
 255                         $user->addToDatabase();
 256                 }
 257
 258                 $user->setOption( 'userjs-someoption', 'test' );
 259                 $user->setOption( 'cols', 200 );
 260                 $user->saveSettings();
 261
 262                 $user = User::newFromName( 'UnitTestUser' );
 263                 $this->assertEquals( 'test', $user->getOption( 'userjs-someoption' ) );
 264                 $this->assertEquals( 200, $user->getOption( 'cols' ) );
 265         }
 266
 267         /**
 268          * Bug 37963
 269          * Make sure defaults are loaded when setOption is called.
 270          * @covers User::loadOptions
 271          */
 272         public function testAnonOptions() {
 273                 global $wgDefaultUserOptions;
 274                 $this->user->setOption( 'userjs-someoption', 'test' );
 275                 $this->assertEquals( $wgDefaultUserOptions['cols'], $this->user->getOption( 'cols' ) );
 276                 $this->assertEquals( 'test', $this->user->getOption( 'userjs-someoption' ) );
 277         }
 278
 279         /**
 280          * Test password expiration.
 281          * @covers User::getPasswordExpired()
 282          */
 283         public function testPasswordExpire() {
 284                 $this->setMwGlobals( 'wgPasswordExpireGrace', 3600 * 24 * 7 ); // 7 days
 285
 286                 $user = User::newFromName( 'UnitTestUser' );
 287                 $user->loadDefaults( 'UnitTestUser' );
 288                 $this->assertEquals( false, $user->getPasswordExpired() );
 289
 290                 $ts = time() - ( 3600 * 24 * 1 ); // 1 day ago
 291                 $user->expirePassword( $ts );
 292                 $this->assertEquals( 'soft', $user->getPasswordExpired() );
 293
 294                 $ts = time() - ( 3600 * 24 * 10 ); // 10 days ago
 295                 $user->expirePassword( $ts );
 296                 $this->assertEquals( 'hard', $user->getPasswordExpired() );
 297         }
 298
 299         /**
 300          * Test password validity checks. There are 3 checks in core,
 301          *      - ensure the password meets the minimal length
 302          *      - ensure the password is not the same as the username
 303          *      - ensure the username/password combo isn't forbidden
 304          * @covers User::checkPasswordValidity()
 305          * @covers User::getPasswordValidity()
 306          * @covers User::isValidPassword()
 307          */
 308         public function testCheckPasswordValidity() {
 309                 $this->setMwGlobals( 'wgMinimalPasswordLength', 6 );
 310                 $user = User::newFromName( 'Useruser' );
 311                 // Sanity
 312                 $this->assertTrue( $user->isValidPassword( 'Password1234' ) );
 313
 314                 // Minimum length
 315                 $this->assertFalse( $user->isValidPassword( 'a' ) );
 316                 $this->assertFalse( $user->checkPasswordValidity( 'a' )->isGood() );
 317                 $this->assertEquals( 'passwordtooshort', $user->getPasswordValidity( 'a' ) );
 318
 319                 // Matches username
 320                 $this->assertFalse( $user->checkPasswordValidity( 'Useruser' )->isGood() );
 321                 $this->assertEquals( 'password-name-match', $user->getPasswordValidity( 'Useruser' ) );
 322
 323                 // On the forbidden list
 324                 $this->assertFalse( $user->checkPasswordValidity( 'Passpass' )->isGood() );
 325                 $this->assertEquals( 'password-login-forbidden', $user->getPasswordValidity( 'Passpass' ) );
 326         }
 327
 328         /**
 329          * @covers User::getCanonicalName()
 330          * @dataProvider provideGetCanonicalName
 331          */
 332         public function testGetCanonicalName( $name, $expectedArray, $msg ) {
 333                 foreach ( $expectedArray as $validate => $expected ) {
 334                         $this->assertEquals(
 335                                 User::getCanonicalName( $name, $validate === 'false' ? false : $validate ),
 336                                 $expected,
 337                                 $msg . ' (' . $validate . ')'
 338                         );
 339                 }
 340         }
 341
 342         public static function provideGetCanonicalName() {
 343                 return array(
 344                         array( ' trailing space ', array( 'creatable' => 'Trailing space' ), 'Trailing spaces' ),
 345                         // @todo FIXME: Maybe the creatable name should be 'Talk:Username' or false to reject?
 346                         array( 'Talk:Username', array( 'creatable' => 'Username', 'usable' => 'Username',
 347                                 'valid' => 'Username', 'false' => 'Talk:Username' ), 'Namespace prefix' ),
 348                         array( ' name with # hash', array( 'creatable' => false, 'usable' => false ), 'With hash' ),
 349                         array( 'Multi  spaces', array( 'creatable' => 'Multi spaces',
 350                                 'usable' => 'Multi spaces' ), 'Multi spaces' ),
 351                         array( 'lowercase', array( 'creatable' => 'Lowercase' ), 'Lowercase' ),
 352                         array( 'in[]valid', array( 'creatable' => false, 'usable' => false, 'valid' => false,
 353                                 'false' => 'In[]valid' ), 'Invalid' ),
 354                         array( 'with / slash', array( 'creatable' => false, 'usable' => false, 'valid' => false,
 355                                 'false' => 'With / slash' ), 'With slash' ),
 356                 );
 357         }
 358
 359         /**
 360          * @covers User::equals
 361          */
 362         public function testEquals() {
 363                 $first = User::newFromName( 'EqualUser' );
 364                 $second = User::newFromName( 'EqualUser' );
 365
 366                 $this->assertTrue( $first->equals( $first ) );
 367                 $this->assertTrue( $first->equals( $second ) );
 368                 $this->assertTrue( $second->equals( $first ) );
 369
 370                 $third = User::newFromName( '0' );
 371                 $fourth = User::newFromName( '000' );
 372
 373                 $this->assertFalse( $third->equals( $fourth ) );
 374                 $this->assertFalse( $fourth->equals( $third ) );
 375
 376                 // Test users loaded from db with id
 377                 $user = User::newFromName( 'EqualUnitTestUser' );
 378                 if ( !$user->getId() ) {
 379                         $user->addToDatabase();
 380                 }
 381
 382                 $id = $user->getId();
 383
 384                 $fifth = User::newFromId( $id );
 385                 $sixth = User::newFromName( 'EqualUnitTestUser' );
 386                 $this->assertTrue( $fifth->equals( $sixth ) );
 387         }
 388 }