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                 $user->loadDefaults();
 218                 $user->addToDatabase();
 219
 220                 // let the user have a few (3) edits
 221                 $page = WikiPage::factory( Title::newFromText( 'Help:UserTest_EditCount' ) );
 222                 for ( $i = 0; $i < 3; $i++ ) {
 223                         $page->doEdit( (string)$i, 'test', 0, false, $user );
 224                 }
 225
 226                 $user->clearInstanceCache();
 227                 $this->assertEquals(
 228                         3,
 229                         $user->getEditCount(),
 230                         'After three edits, the user edit count should be 3'
 231                 );
 232
 233                 // increase the edit count and clear the cache
 234                 $user->incEditCount();
 235
 236                 $user->clearInstanceCache();
 237                 $this->assertEquals(
 238                         4,
 239                         $user->getEditCount(),
 240                         'After increasing the edit count manually, the user edit count should be 4'
 241                 );
 242         }
 243
 244         /**
 245          * Test changing user options.
 246          * @covers User::setOption
 247          * @covers User::getOption
 248          */
 249         public function testOptions() {
 250                 $user = User::newFromName( 'UnitTestUser' );
 251                 $user->addToDatabase();
 252
 253                 $user->setOption( 'someoption', 'test' );
 254                 $user->setOption( 'cols', 200 );
 255                 $user->saveSettings();
 256
 257                 $user = User::newFromName( 'UnitTestUser' );
 258                 $this->assertEquals( 'test', $user->getOption( 'someoption' ) );
 259                 $this->assertEquals( 200, $user->getOption( 'cols' ) );
 260         }
 261
 262         /**
 263          * Bug 37963
 264          * Make sure defaults are loaded when setOption is called.
 265          * @covers User::loadOptions
 266          */
 267         public function testAnonOptions() {
 268                 global $wgDefaultUserOptions;
 269                 $this->user->setOption( 'someoption', 'test' );
 270                 $this->assertEquals( $wgDefaultUserOptions['cols'], $this->user->getOption( 'cols' ) );
 271                 $this->assertEquals( 'test', $this->user->getOption( 'someoption' ) );
 272         }
 273
 274         /**
 275          * Test password expiration.
 276          * @covers User::getPasswordExpired()
 277          */
 278         public function testPasswordExpire() {
 279                 global $wgPasswordExpireGrace;
 280                 $wgTemp = $wgPasswordExpireGrace;
 281                 $wgPasswordExpireGrace = 3600 * 24 * 7; // 7 days
 282
 283                 $user = User::newFromName( 'UnitTestUser' );
 284                 $user->loadDefaults();
 285                 $this->assertEquals( false, $user->getPasswordExpired() );
 286
 287                 $ts = time() - ( 3600 * 24 * 1 ); // 1 day ago
 288                 $user->expirePassword( $ts );
 289                 $this->assertEquals( 'soft', $user->getPasswordExpired() );
 290
 291                 $ts = time() - ( 3600 * 24 * 10 ); // 10 days ago
 292                 $user->expirePassword( $ts );
 293                 $this->assertEquals( 'hard', $user->getPasswordExpired() );
 294
 295                 $wgPasswordExpireGrace = $wgTemp;
 296         }
 297
 298         /**
 299          * Test password validity checks. There are 3 checks in core,
 300          *      - ensure the password meets the minimal length
 301          *      - ensure the password is not the same as the username
 302          *      - ensure the username/password combo isn't forbidden
 303          * @covers User::checkPasswordValidity()
 304          * @covers User::getPasswordValidity()
 305          * @covers User::isValidPassword()
 306          */
 307         public function testCheckPasswordValidity() {
 308                 $this->setMwGlobals( 'wgMinimalPasswordLength', 6 );
 309                 $user = User::newFromName( 'Useruser' );
 310                 // Sanity
 311                 $this->assertTrue( $user->isValidPassword( 'Password1234' ) );
 312
 313                 // Minimum length
 314                 $this->assertFalse( $user->isValidPassword( 'a' ) );
 315                 $this->assertFalse( $user->checkPasswordValidity( 'a' )->isGood() );
 316                 $this->assertEquals( 'passwordtooshort', $user->getPasswordValidity( 'a' ) );
 317
 318                 // Matches username
 319                 $this->assertFalse( $user->checkPasswordValidity( 'Useruser' )->isGood() );
 320                 $this->assertEquals( 'password-name-match', $user->getPasswordValidity( 'Useruser' ) );
 321
 322                 // On the forbidden list
 323                 $this->assertFalse( $user->checkPasswordValidity( 'Passpass' )->isGood() );
 324                 $this->assertEquals( 'password-login-forbidden', $user->getPasswordValidity( 'Passpass' ) );
 325         }
 326
 327         /**
 328          * @covers User::getCanonicalName()
 329          * @dataProvider provideGetCanonicalName
 330          */
 331         public function testGetCanonicalName( $name, $expectedArray, $msg ) {
 332                 foreach ( $expectedArray as $validate => $expected ) {
 333                         $this->assertEquals(
 334                                 User::getCanonicalName( $name, $validate === 'false' ? false : $validate ),
 335                                 $expected,
 336                                 $msg . ' (' . $validate . ')'
 337                         );
 338                 }
 339         }
 340
 341         public static function provideGetCanonicalName() {
 342                 return array(
 343                         array( ' trailing space ', array( 'creatable' => 'Trailing space' ), 'Trailing spaces' ),
 344                         // @todo FIXME: Maybe the createable name should be 'Talk:Username' or false to reject?
 345                         array( 'Talk:Username', array( 'creatable' => 'Username', 'usable' => 'Username',
 346                                 'valid' => 'Username', 'false' => 'Talk:Username' ), 'Namespace prefix' ),
 347                         array( ' name with # hash', array( 'creatable' => false, 'usable' => false ), 'With hash' ),
 348                         array( 'Multi  spaces', array( 'creatable' => 'Multi spaces',
 349                                 'usable' => 'Multi spaces' ), 'Multi spaces' ),
 350                         array( 'lowercase', array( 'creatable' => 'Lowercase' ), 'Lowercase' ),
 351                         array( 'in[]valid', array( 'creatable' => false, 'usable' => false, 'valid' => false,
 352                                 'false' => 'In[]valid' ), 'Invalid' ),
 353                         array( 'with / slash', array( 'creatable' => false, 'usable' => false, 'valid' => false,
 354                                 'false' => 'With / slash' ), 'With slash' ),
 355                 );
 356         }
 357 }